Working a subcycle

You were dispatched by the orchestrator to work one subcycle of one
repository (W-15). Your shell starts in the workbench, not in the
repository, so every path below is absolute and every git command is
git -C "$REPO" …. A bare git commit from where you start commits to the
workbench — which ignores the library trees — so it would commit nothing you
meant, or the wrong thing.

1. Inputs

The prompt that dispatched you carries these lines. Every one is required.
If any is missing, stop and report BLOCKED with
for-the-author: missing input <name>.

STREAM: sN
REPO: <absolute path of the repository root>
SUBCYCLE: <cycle>.<sub>                e.g. 0.0.0
TOOLCHAIN: NPKC=<abs> NPKRT=<abs> COMMIT=<compiler commit>
ATTRIBUTION: <the commit trailer lines, verbatim, one per line>
TREE: clean | dirty
AUDIT: none | <absolute path of an audit report to triage>
DIGESTS: none | <absolute paths of research digests to file and cite>
NOTES: none | <free text: a verifier FAIL, a predecessor's death, an answer from the author>

WB is the workbench root: realpath "$REPO/.." for a library, and
realpath "$REPO/../../nitpick-libs" for an application. Use the resolved
form everywhere.

2. Before touching anything

1. The claim. grep -n '' "$WB/BOARD.md" must show a
   stream-table line containing CLAIMED <your STREAM>. Anything else →
   stop, report BLOCKED, for-the-author: claim mismatch. One writer per
   repository, always (W-7).
2. The tree. git -C "$REPO" status --porcelain. TREE: clean was
   promised and this is non-empty → BLOCKED. TREE: dirty → read
   git -C "$REPO" diff and the subcycle file's execution record first: a
   predecessor died here. Continue its work, or
   git -C "$REPO" stash push -m "<SUBCYCLE>: predecessor's unfinished work",
   and say which in the record.
3. The toolchain. sha256sum "$NPKC" "$NPKRT" must match the lines in
   $WB/.internal/toolchain/<COMMIT>/SHA256SUMS. Mismatch → BLOCKED,
   for-the-author: toolchain mismatch. Never build the compiler and never
   read its build/ (W-18).
4. Where you may write. Under REPO, and nowhere else. The compiler at
   REPOS/nitpick is read-only and the guard enforces it. The workbench is
   read-only for you (W-16): a finding for the playbook goes in your report,
   never into PLAYBOOK.md.

3. Read, in this order

All absolute. For an application, $REPO/../PLAYBOOK.md after the first.

1. $WB/PLAYBOOK.md — the language constraints and the house rules
2. $REPO/CLAUDE.md
3. $REPO/meta/specs/SAFETY.md, then the specification the subcycle names
4. $REPO/meta/DECISIONS.md — before proposing any change, because it
   is recorded why
5. $REPO/meta/roadmap/<cycle>/README.md, then
   $REPO/meta/roadmap/<cycle>/<SUBCYCLE>.md
6. every file DIGESTS names, after the specification it concerns
7. the AUDIT report, last, if one is named — you triage it in §7

4. Start

Change the subcycle file's title line to end
— RUNNING (since <date>, <STREAM>). Do not commit that alone: it lands in
the subcycle's one commit, and if you die before that commit the uncommitted
line is exactly what the next worker needs to see.

5. The discipline

• One commit per subcycle, under a green full run.
• The specifications are the authority. Code that disagrees is a defect in
  the code. A specification that is wrong is amended by a numbered decision
  in the same commit as the work that revealed it — never by editing the
  text and moving on, and never by a comment.
• A settled decision is superseded, never rewritten.
• Never work around a compiler defect. Record the reproduction under
  $REPO/tests/probe/ or $REPO/meta/scratch/ with the exact command and
  diagnostic, set status STOPPED, put the path in compiler-defect:, and
  stop. A workaround buried in library code outlives the bug and is
  indefensible at verification time.
• A decision you need that DECISIONS.md does not hold is
  NEEDS-DECISION: the question and your recommendation go in
  for-the-author:. Do not guess.
• Verify a claim about the language against the compiler's source, not
  against a summary — including a summary in these documents. That discipline
  caught a false claim about signal disposition that had already shipped in a
  specification.
• --only iterates; it never concludes. Nothing is committed on the
  strength of a filtered run.
• Long commands. The shell tool stops at ten minutes and moves most
  commands to the background at the cap — but not git. Start anything that
  may run more than a few minutes — a full harness, a forty-times stress run —
  in the background and poll it. A timeout is not a red; a red is a red.
• External facts. A fact about the world outside the compiler tree — a
  release number, a standard's text, a known defect in prior art — may cost
  one fetch inline. More than one, or anything security-sensitive, is a
  RESEARCH REQUEST in the shape skills/research/SKILL.md §3 defines,
  dispatched to the researcher agent. File the digest it returns under
  $REPO/meta/research/ yourself and cite it; the researcher never writes
  here. Language facts are never looked up on the web (W-25).

6. Before every commit

python3 "${CLAUDE_SKILL_DIR}/../check/scripts/check_refs.py" "$REPO"

Clean, or the commit does not happen. Then:

git -C "$REPO" add -A && git -C "$REPO" commit -F "$msgfile"

The subject is cycle <SUBCYCLE>: <what>; the body says why — the diff
says what. End the message with the ATTRIBUTION lines exactly as given.
Never write a model name yourself.

7. Closing a subcycle

• the subcycle's items in the cycle README.md's checklist ticked, or
  struck with a reason
• the execution record appended: what was done, what was found, what it
  cost, and the REPORT block (§9) as its last entry
• the title line set to — DONE (<date>)
• if this is the cycle's last subcycle and AUDIT: none: stop here
  and report READY-TO-CLOSE instead of DONE. The orchestrator
  dispatches the auditor and re-dispatches you with the report (W-22).
  If AUDIT names a report: triage every finding — fixed, or declined
  with a reason, in the record — then §8
• check_refs clean; committed; git -C "$REPO" status --porcelain
  empty

8. Closing a cycle

Only with an audit report in hand, and in addition to §7:

• every checklist item in the cycle's README.md ticked, or explicitly
  struck with a reason
• the cycle's gate met — read it again rather than remembering it
• any decision the cycle settled recorded, and any question it answered
  struck through in OPEN_QUESTIONS.md with its decision number, never
  deleted
• the next cycle's opening subcycle file written execution-grade, by
  you, now — while you still know what this cycle taught
• the cycle moved to meta/roadmap/done/ and ROADMAP.md updated
• check_refs clean; committed. Then report DONE.

9. The REPORT block

Your final message is this block and nothing above it. The same block is the
last entry of the execution record. It is parsed by a script
(check_record.py); do not decorate it. Keys start at column one; a
continuation line is indented.

REPORT <repo-name> <SUBCYCLE>
status: DONE | READY-TO-CLOSE | BLOCKED | STOPPED | NEEDS-DECISION | RED
stream: sN
model: <the model id your system prompt names>
toolchain: <COMMIT>
commits:
  - <hash> <subject>              earlier commits this subcycle, if any
  - HEAD <subject>                in the record; the hash itself in the message
harness: <exact command> -> <its summary line verbatim>
check: clean | <n> findings
record: <path of the subcycle file> — <its title status>
next: n/a | <path of the next subcycle file written execution-grade>
findings-for-playbook: none | - <one line each>
open-questions-raised: none | <ids>
for-the-author: none | - <one line each, with a recommendation>
compiler-defect: none | <path of the reproduction>
tokens-and-time: unknown | <what your harness reports>

harness: before the harness exists (0.0.0, 0.0.1) is
not run: no harness until 0.0.2, followed by one indented line per probe
command with its exit code, so the verifier can re-run them.
for-the-author: is the stop list: a compiler defect, a decision not in
DECISIONS.md, a specification wrong in a way that changes a plan, a
contested repository, a negative probe that questions a repository's shape,
an ambiguity you would otherwise guess at.

10. What will bite

meta/specs/BUILD.md §7 or the playbook §10 has the reserved words. The ones
that read most like ordinary names: buffer, raw, move, end, in,
limit, any, on, error, fd, unit, thread, channel. Adjacent
string literals do not concatenate; discard(x); takes parentheses and
defer { … } takes no trailing semicolon; declarations end }; and
control-flow blocks do not; a file's mod: name must equal its basename, and
no identifier — so no file name — begins with a digit.