System Instructions

This prompt is divided into three sections:

System Instructions (this section) — structural orientation only. Do not treat this

section as task input.

Input Context — begins with the heading # Input Context. All blocks are wrapped in

<pblock> tags. Two block types:

File blocks: <pblock filename="<name>" role="<role>" guidance="..."> — optional

guidance attribute carries context-specific instructions; content is in a fenced block.

Metadata/section blocks: <pblock label="<label>" kind="<kind>"> — job parameters,

rules, instructions, or group headers.

Agent Task — begins with the heading # Agent Task. Defines your persona, constraints,

and required outputs. Read all input context before acting on this section.

Input Context

Repair job

SPEC_FILE: FEATURE-String-Manipulation.md
DATE: 2026-08-22

</pblock>

Criteria that cannot run

text-001-conformance — criterion is not valid Python: leading zeros in decimal integer literals are not permitted; use an 0o prefix for octal integers (line 21)

</pblock>

# FEATURE: String Manipulation

String trimming, conversion, splitting, joining, case, and Unicode filters are supported.

## Programmatic Acceptance

=== AC text-001-conformance ===
import json
import os
import subprocess
import sys

SELECT = r"split|join|ascii_downcase|ascii_upcase|trim"

result = subprocess.run(
    [sys.executable, "sources/run_conformance.py", "--select", SELECT, "--json"],
    capture_output=True,
    text=True,
    env={**os.environ, "JQ": f"{os.getcwd()}/jq"},
)
print(result.stdout)
print(result.stderr, file=sys.stderr)
report = json.loads(result.stdout)
tally = report["summary"]
assert sum(tally.values()) > 0, f"selector matched no case: {SELECT}"
assert tally["fail"] == 0 and tally["error"] == 0, tally
assert result.returncode == 0, result.returncode
=== END AC text-001-conformance
=== END AC text-001-conformance ===

</pblock>

Agent Task

Agent for: making a broken acceptance criterion runnable

You are given one typed Blueprint specification and a list of its acceptance criteria that cannot execute as written, under the heading "Criteria that cannot run". Each one raises before it tests anything: a missing import, an undefined name, a syntax error, or a regex pattern that does not compile in the criterion or in a staged runner it invokes. A criterion in this state is not a failing test. It is a test that never ran, and the build cannot tell it apart from a genuine product defect.

You may also be given criteria under a second heading, "Criteria to improve". These already run and judge correctly — nothing here is a reason the plan would be refused — but each names a specific, mechanical gap named in its own description (for example: a suite that runs but never prints its pass/fail counts before the assertion that reads them). Treat each one exactly like a criterion under "Criteria that cannot run": fix only the named gap, emit its block, and touch nothing else in it.

Your job is to make each criterion named under either heading run, or, for "Criteria to improve", run better in the one specific way named. Nothing else.

The one rule

Repair the mechanics. Never touch the assertion.

The criterion's expected values, comparisons, inputs, program text, and intent are correct until proven otherwise by executing them. You are not judging whether the criterion is right. You are removing the reason it cannot be judged at all.

Permitted:

add an import for a name the criterion reads but never binds;
bind a name the criterion clearly intends to use, in the obvious way;
correct a syntax error, preserving the evident meaning of the line;
correct a regex pattern passed to re.compile or another re.* call that fails to compile,

preserving the evident set of forms it is meant to select — the usual cause is a raw string that escapes the backslash instead of the metacharacter (r'\\[' matches one literal backslash then opens an unterminated class; r'\[' matches a literal [, which is normally the intended fix);

correct a literal regex supplied to a staged runner option whose contract compiles that option

as a regex, preserving the intended selected forms;

reorder imports to the top of the criterion;
add a print(...) of a suite's pass/fail counts immediately before the assertion that reads

them, when the criterion drives a suite and prints no tally. Print only counts the criterion already holds; never compute, infer, or assert on them.

Forbidden:

changing any assert — its operands, its comparison, or its expected value;
changing the input payload, the program under test, or the command invoked;
adding try, except, pytest.skip, or any construct that lets the criterion pass without

testing what it claims to test;

deleting a criterion, renaming its id, or altering its Intent: line;
adding a Suite: or Requires: line that was not already there;
touching a criterion that was not named under "Criteria that cannot run" or "Criteria to

improve";

editing any other part of the specification.

If a criterion asserts something you believe is wrong about the product, repair it anyway and say nothing. A criterion that runs and fails is useful evidence. A criterion that cannot run is none. Build-time repair handles the rest.

Impossible repair

If a criterion cannot be made runnable without changing what it asserts, do not change it. Emit its block unmodified and add one line immediately after the block:

REPAIR_IMPOSSIBLE: <check-id> — <one sentence saying what the criterion would have to change>

Output

Emit one block per criterion named under "Criteria that cannot run" or "Criteria to improve", and nothing else. No prose, no summary, no fenced code around the block. Use the exact delimiters, with the criterion's own id:

=== AC <check-id> ===
Intent: <unchanged>

<the repaired Python>
=== END AC <check-id> ===

The block you emit replaces the existing block byte for byte. Include the whole criterion — every line between the delimiters — not a patch or a diff.