@ersbeth/codelife 0.0.0-stage → 0.11.1

package/skills/roadmap/SKILL.md

@@ -0,0 +1,137 @@
+---
+name: roadmap
+description: File the lots of what the specification changed since the roadmap's mark, turn the tracker's orphan issues into lots, and propose a closure only on evidence.
+argument-hint: "[label-or-milestone]"
+---
+
+# /roadmap
+
+Reads two sources and proposes **one table**: the lots that what `docs/spec/` changed since the
+roadmap's mark needs, and what to do with the open issues — the stale ones rewritten or closed, the
+**orphans** (open, no lot in their title) grouped, joined to a lot, closed on evidence or left
+alone. One answer for the whole table, then the writes, the roadmap rewritten last. The first write
+that does not complete ends the run, the rest untouched; a re-run resumes from the tracker itself.
+
+## Preconditions
+
+A contract, and the forge connected: `codelife roadmap prep` checks both. Under `tracker.kind:
+none` the issues are files and the run is the same. No clean tree is required and no branch is
+switched: the run writes to the tracker, and to the repository only the refusal lines of its
+`wontfix` rows, each committed on the branch you stand on before its closure.
+
+## Brief
+
+**Who gave the go-ahead**, and from what, opens it: you, typing the command or answering this
+brief; your confirmed table in a driver, which answers what it named — ask only the rest; the word
+`delegate`; or a session that relayed your words, quoted here — relayed is not delegated. Typed or
+tabled, this brief is an announcement; otherwise the run **stops here** for your go-ahead, after
+nothing but a preparation that only reads.
+
+`codelife roadmap prep [<label-or-milestone>]`, its summary naming the run folder. A `- stop:` line
+ends the run, its reason said — except the two that ask a commit to read from (a mark that is not
+an ancestor of `HEAD`, a first roadmap over a tracker that already holds `spec:` lots): put the
+question to the user with the commit it proposes, then run it again with `--from <sha>`.
+
+Then write in your reply — a tool's output is not one —: the roadmap and its mark, or where a first
+run reads from; `HEAD`; how many cases the range covers, how many are proposed built because they
+were merged with their code (the merges named), how many are left to cut, and the `no case` rules;
+the open lots with their *Done when*; the members that wait for a case; the issues citing what
+changed; how many orphans, and the scope when an argument narrowed it; on a first run, the test
+files each capability will be handed; and that **nothing is written before the table is answered**.
+
+## Parameters
+
+`[label-or-milestone]`, optional, narrowing the orphans considered. Nothing else is asked: the table
+is the one answer.
+
+## Steps
+
+1. **Prepare** — the brief, written in your reply before any agent is dispatched.
+2. **Cite, on a first run** whose summary says `citation pass:` with capabilities handed tests: one
+   `codelife:prerequisites` agent per `citation:` line, its prompt `citations`, the capability's
+   folder in the run folder and the repository's absolute root. A block reading `not passed` stops the run.
+   None proposed → step 3. Some → the table is the **citation lot alone**: one line per capability
+   with its count of renames, every rename in a file of the run folder. Confirmed, the umbrella —
+   `codelife issue create lot - citation <file>`, the sentence *The suite's tests do not cite the
+   cases they prove*, its *Done when* every rename landed — then per capability
+   `codelife issue create feature mid citation <file>` and `codelife lot join`. No roadmap is
+   written: the plan is cut once that lot is merged.
+3. **Cut** — one `codelife:prerequisites` agent per `capability:` line, its prompt `cases`, its
+   two paths under the run folder and the repository's absolute root; each block saved as
+   `<run folder>/blocks/<K-n>.md`. Agents go all in one message, as many as Claude Code runs at
+   once, the rest as the first return. A block reading `not passed` stops the run. Then
+   `codelife roadmap cut <run folder>`; a `- stop:` line is said and ends the run. No
+   `capability:` line, no cut.
+4. **Judge the issues**, from their files in the run folder:
+   - each `cites:` line — **rewrite** (the rule stands, changed: a new body to the rule at `HEAD`,
+     a new title when its sentence no longer holds; for a started one, what its lot branch's commits
+     naming it already do), **close** (the rule retired or replaced, on the commit that did it),
+     **keep**, or the **member** of a cut row;
+   - each orphan — **new lot** (a shared cause, subsystem or promise, named; origin
+     `triage:<slug>`, its sentence the symptom the members share), **join** an open lot whose
+     members share its class and whose *Done when* serves it, **wontfix**, or left alone;
+   - each `waits:` line whose case an issue in a lot builds — **move** the member to an open lot
+     waiting for that one whose *Done when* serves it, or to a new lot of its own,
+     `triage:waits-for-c-<n>`;
+   - **places** — the cut's lots after the confirmed order, in its order; a lot of orphans, or an
+     open lot the roadmap lacks, by its highest severity. A lot you raise for its risk goes no
+     higher than the last lot it waits for.
+
+   A `wontfix` needs evidence anyone can check: the file, command or symbol is gone; a decision of
+   the specification refused it; issue #n supersedes it; it no longer reproduces, the check named.
+   Age, inactivity or a hard read is none.
+5. **Propose one table**, in your reply: one line per lot — rank, title, members, total effort,
+   what it waits for —, every rewrite and every closure **in full**, the cases proposed built, the
+   `no case` rules to place, the orphans left alone; the members, in `table.md`, its path named. A
+   row is corrected or struck by naming it; one answer for the whole. Nothing is written yet.
+6. **Write**, in this order, each write reported:
+   - each lot — its umbrella `codelife issue create lot - <origin> <file>`, the body of
+     `codelife help template lot` with *The order* empty, unless the summary's `lot:` lines already
+     hold that origin (a cut run: create only what it lacks); then each member at once, a new one
+     `codelife issue create feature mid spec:R-<n> <file>` — `bug` for a rule that repairs a
+     behaviour — from its nature's template, its *Where it comes from* citing the rule and its
+     cases, then `codelife lot join <umbrella> <n>…`;
+   - each **join** — `codelife lot join`; each **move** —
+     `codelife lot leave <lot> <n> <reason file>`, the case as the reason, then `codelife lot join`;
+   - each **rewrite** — `codelife issue update <n> <body file> [<title file>]`, then
+     `codelife issue note <n> <file>` with the `rewritten` comment of
+     `codelife help method comments`.
+7. **Close the `wontfix` rows**, one at a time. A member leaves its lot first, `codelife lot leave`,
+   the evidence its reason. A rule a commit of the range retired: the comment quotes the refusal
+   line that commit wrote, with its file — `codelife issue close <n> <file> <commit> --wontfix`.
+   Any other: one line of `## Rejected` as `codelife help method refusal` says, committed with
+   `codelife commit` — `docs(spec): refuse …`, a `Closes: #<n>` footer — then
+   `codelife issue close <n> <file> <hash> --wontfix`, the evidence verbatim and the line quoted.
+8. **Rewrite the roadmap, last** — `codelife roadmap write <run folder> <order> <left alone>`, the
+   order one `#<n> <sentence>[ — after #<a>, #<b>]` per open lot as confirmed, the other one
+   `#<n> <sentence>` per orphan left alone. Not when the table was refused outright, nor after the citation lot alone; a range with
+   no row is written all the same, so the mark passes it.
+
+## Never
+
+- Propose a closure on age, inactivity, or how hard the issue is to read.
+- Group by severity or by milestone, or widen a lot's *Done when* to admit a member.
+- Read code but to write a new member's body or judge a `cites:` line, or re-estimate an effort an
+  issue carries.
+- Open an issue other than the umbrellas and members the table confirmed: a lead noticed while
+  planning is `/new-issue`'s.
+- Assign anyone, create a label or create a milestone.
+- Report an orphan that grouped with nothing as a failure.
+- Check out, switch, stash or add a worktree.
+- Answer in a language the user did not write in, or write anything but English into the
+  repository or the tracker.
+
+## Output
+
+The run ends on this block, under this exact heading:
+
+```markdown
+### roadmap result
+- Produced: the lots filed, each with its members; the issues joined, moved, rewritten and closed,
+  each closure with its evidence and its refusal line; the roadmap rewritten — or the citation lot
+  alone.
+- Decided: the table, and every row you changed.
+- Left open: the orphans left alone; any lot whose *Done when* refused a member.
+- Next: `/work <umbrella>` on the first open lot of the order — or, after the citation lot, on it,
+  the plan cut once it is merged.
+```

package/skills/setup/SKILL.md

@@ -0,0 +1,112 @@
+---
+name: setup
+description: Set a repository up for codelife — write its contract, then bring the base every skill rests on, one commit per item.
+argument-hint: "[item]"
+---
+
+# /setup
+
+Brings a repository to the state every other skill rests on: a valid contract, then the base every
+codelife repository shares, under every `kind` and whatever its toolchain. The first skill any
+repository runs, re-run on a new machine or after a plugin upgrade. It keeps **no state file** — the
+verbs read what is done from the repository — and never chains into another skill; the target
+toolchain is `/port-toolchain`'s, and nothing here writes it. Three verbs read and do the work; this
+brief carries what is yours to decide.
+
+## Preconditions
+
+None to check here: `codelife setup prep` prints a `- stop:` line for each — not a git repository,
+an invalid contract, a machine not connected to its host, a default branch other than `main`. A stop
+ends the run: say it in your reply with what to do, and run nothing else. Work on the branch checked
+out; a dirty tree is fine, and named.
+
+## Brief
+
+**Who gave the go-ahead**, and from what, opens it: you, typing the command or answering this
+brief; your confirmed table in a driver, which answers what it named — ask only the rest; the word
+`delegate`; or a session that relayed your words, quoted here — relayed is not delegated. Typed or
+tabled, this brief is an announcement; otherwise the run **stops here** for your go-ahead, after
+nothing but a preparation that only reads.
+
+Then `codelife setup prep`, and its block written **in your reply**, in the user's language — a
+tool's output is not one: every line, commands, paths and quoted errors kept as printed. Its
+`- guide:` lines are the connection: the token goes from the browser to the clipboard to the user's
+own terminal, never into the conversation. A missing CLI is installed on the user's yes; then the run
+waits for *done* and runs `codelife setup prep` again — nothing is written before it passes.
+
+## Parameters
+
+`[item]` — one base item to play or replay; without it, every item *to do*, in prep's order.
+
+## Steps
+
+1. **Draft** — on a first run, the whole contract in block form, each value tagged *inferred from
+   `<file>`*, *to confirm* or *missing*, from prep's lines and the `- prose:` files **read whole**:
+   `guards[]` are the conditional checks the prose states — *when X changes, run Y* — each quoted;
+   `generated[]` the committed outputs a script builds, and `CHANGELOG.md` by
+   `node node_modules/@ersbeth/codelife/scripts/changelog.mjs` with `when: []`; the `app` block under
+   `kind: app` only, both fields asked. Prose goes to `## Setup` (a one-off install, never a token),
+   `## Never` (a command warned against, with its reason), `## Raise before doing` (a defended
+   property), `## Tracker notes` (the forge's traps). On an update, the divergences only — a prose
+   section is never substituted, an addition is proposed. **Shown in your reply, not asked.**
+2. **Ask** — every *to confirm* and *missing* value in one `AskUserQuestion` batch, each with its
+   inferred default first and the file it came from. Never a sure inference, a language, a model, a
+   label name or a branch prefix.
+3. **Write** — the answered draft to a file, then `codelife setup contract <file>`; an `- invalid:`
+   line is fixed and the verb run again. Then `CLAUDE.md`: absent, created short and prose — the
+   purpose, the architecture if it is clear, the pointer. Present, the pointer paragraph appended —
+   *the verifiable facts live in [`.claude/codelife.md`](.claude/codelife.md), the codelife contract;
+   this document stays prose* — and on a **first run only** a trim, one passage per question: a
+   passage restating the contract or a plugin convention (pre-commit commands, labels and titles,
+   branch names, commit format, tags, committed outputs, *when X run Y*) is proposed for removal;
+   *never run* and one-off setup passages **move** to `## Never` and `## Setup` first; architecture,
+   code rules and reasons stay. A refusal goes to *Left open*, never argued again. Then
+   `codelife commit` on the verb's `- paths:` and `CLAUDE.md`, as `chore(setup): write the project contract`.
+4. **Items** — `connect`, `labels`, `templates`, `scripts`, `hooks`, `folders`, `changelog`,
+   `develop`, each *to do* in that order: `codelife setup item <name>`, its block in your reply, an
+   existing file's difference included; then **now, or later**.
+   - **Now** — `codelife setup item <name> --write`; a `- stop:` or `- failed:` line ends the run,
+     quoted — the run does not fix the repository's tests. Then `codelife commit` on its `- paths:`,
+     `chore(setup): <what the item did>`; `labels` and `develop` write no file, and say so.
+   - **Later** — a deferral, never a refusal: `codelife issue create --once feature low setup:<item>
+     <file>`, the reason just given as its body. The item stays *to do*; a repository that will
+     never take it closes that issue `wontfix`.
+   - **scripts** — first the mapping of the five from what `package.json` runs, confirmed: a script
+     doing the job under another name is renamed (`verify:pre-commit` → `verify:commit`), its
+     callers in CI, `README.md` and `CONTRIBUTING.md` updated; a tier with nothing gets
+     `echo 'nothing to run'`, said aloud, after looking once for a real check. You edit
+     `package.json` — a private one when there is none — then `--write --test <a test file>`.
+   - **hooks** — no package: propose prep's install command as a decision. A hook of the
+     repository's own: its extra lines kept as an issue, or dropped on the user's word.
+   - **changelog** — a hand-written `[Unreleased]` stops it: fold its entries, show, confirm,
+     remove, then again. **develop** — its push is the user's, with `! `.
+
+   What an item finds outside its scope is an issue — `codelife issue create` — never a wider item.
+   Ask whether to continue after each.
+5. **Close** — the result block below.
+
+## Never
+
+- Read, print, store or pass a token, widen one, or create a label outside the plugin's own.
+- Rewrite `CLAUDE.md` silently or in one pass, or propose a trim on an update.
+- Mix two items in one commit, or widen an item to fix what it finds.
+- Rename the default branch, push, bypass a hook, check out, stash, create a branch other than
+  `develop`, or chain into `/onboard`, `/audit` or any other skill.
+- Write a toolchain's command into a script: that is `/port-toolchain`'s.
+- Answer in a language the user did not write in, or write anything but English into the
+  repository or the tracker.
+
+## Output
+
+The run ends on this block, under this exact heading, its fields in the user's language:
+
+```markdown
+### setup result
+- Produced: the contract, the `CLAUDE.md` pointer, the passages trimmed, one commit per item played,
+  the labels created, `develop`.
+- Decided: each answer of the batch, each trim, each item played or deferred.
+- Left open: the items still *to do*, each deferred one with its issue; a tier with nothing to run;
+  a passage refused; a push not yet made.
+- Next: `/setup` again for what is left; `/onboard`, `/overview` or `/audit` after that. Name them;
+  start none.
+```

package/skills/work/SKILL.md

@@ -0,0 +1,139 @@
+---
+name: work
+description: Walk a lot's members in the umbrella's order, or one lone issue, each planned, implemented and reviewed by fresh agents, to the merge request.
+argument-hint: "[issue-number] [delegate]"
+---
+
+# /work
+
+Walks a lot — its umbrella's open members, in order — or one lone issue, to one merge request. Each
+member is planned, implemented and reviewed by fresh agents whose reports alone enter this session;
+every write that leaves the machine is this session's.
+
+## Preconditions
+
+`codelife work prep` checks them and stops on the first that fails, naming it: a contract; the
+forge connected; a clean tree; a `test:one` script, else `/setup`; a task list on an umbrella;
+before a cut, a `develop` that `origin/develop` holds whole; no rule a member cites moved since the
+roadmap's mark, else `/roadmap`.
+
+## Brief
+
+**Who gave the go-ahead**, and from what, opens it: you, typing the command or answering this
+brief; your confirmed table in a driver, which answers what it named — ask only the rest; the word
+`delegate`; or a session that relayed your words, quoted here — relayed is not delegated. Typed or
+tabled, this brief is an announcement; otherwise the run **stops here** for your go-ahead, after
+nothing but a preparation that only reads.
+
+Made from `work prep`'s summary alone: the umbrella, its open members in order with their efforts
+and plan state, the joins it proposes — or the lone issue; the branch the work belongs on, and the
+one you stand on.
+
+## Parameters
+
+`[issue-number]`, an umbrella or a lone issue, inferred from the conversation or the current
+branch when absent, and stated. `[delegate]`, typed after it, never asked nor inferred.
+
+## Steps
+
+1. **Prepare** — `codelife work prep <n>`. A `- stop:` line ends the run, its reason said. A closed
+   member is skipped, whatever its tick. A `closed:` line — a delegated run's return — goes to
+   step 3, then step 5.
+2. **One table** — the open members in order with their efforts, a *join #n, last* row per `join:`
+   line, and the branch. Delegated, it also states: a choice inside the change is taken alone and
+   named in its commit; any other — a public API, a file format, a new dependency, a test weakened,
+   the specification contradicted, what the contract's `## Raise before doing` names — is committed
+   apart, ending on a `Held:` trailer; plans are posted and issues closed unseen; nothing is pushed;
+   and *a session that asks permission at each action stops at the first one while you are away;
+   Claude Code's `auto` mode lets it go on.* One answer; nothing is written before it.
+3. **Reach the branch** the summary names: `git switch <branch>`; to cut one,
+   `git switch develop`, `git merge --ff-only origin/develop`, `git switch -c <branch> <from>`;
+   nothing when `in place`. Then one `codelife lot join` for the confirmed joins.
+4. **Each member, in order**, in agents no other member shares:
+   - **Plan** — skipped when the member carries a `plan` comment. One `codelife:planner` agent,
+     given the issue, its table line, present or delegated, the lens folder
+     `<this skill's directory>/../../scripts/lenses/`, and the `refused` comments when the
+     summary says refused. Present, you approve or correct it. A plan that warns it publishes a
+     withheld reproduction is asked on its own first; delegated, it stops the member unposted.
+     Post it: a file opening on `codelife: plan — /work — <date>`, the plan, and `## Go-ahead`
+     quoting the table's line with your corrections or, delegated, its constraints, then
+     `codelife issue note <n> <file>`.
+   - **Implement** — note the start, `HEAD`, or on a resume the parent of the oldest commit
+     `codelife log since <base> <n>` prints. One `codelife:implementer` agent, on Sonnet, on Opus
+     when the plan says L, given the issue, the base, the table's line, the plan or *resume*, and
+     present or delegated. Put its question to you, and your answer to that same agent with
+     `SendMessage`.
+   - **Review** — `codelife checks <start>`, each `failed:` line a finding. Then, in one message and
+     blind to each other: one `codelife:reader` agent, its case the range `<start>..HEAD`, the
+     member and its umbrella, *Command line* `codelife`; and the Skill tool on `code-review`, args
+     `medium <start>..HEAD — post nothing and fix nothing`. Present, you keep or drop each finding;
+     delegated, each is kept.
+   - **Fix** — the kept findings to the implementer with `SendMessage`, one commit each, delegated
+     citing its finding. Then `/code-review` once on those fix commits, its findings kept or dropped
+     as above — one repeating a dropped finding stays dropped, unasked; what is kept is fixed once and
+     kept for the description.
+   - **Close** — the `closing` comment in a file, as `codelife help method comments` writes it, then
+     `codelife issue close <n> <file> <hash>…` with every hash `codelife log since <base> <n>`
+     prints; it ticks the umbrella and closes it with its last member. *This will not be done* —
+     you decided the issue is not worth its cost: a line of `## Rejected` through
+     `codelife help method refusal`, committed `docs(spec)` with `Closes: #<n>`, then the
+     close with `--wontfix`.
+5. **Open the merge request**, once every member closed or left — a description as
+   `codelife help method description` prints it, from the reports — on a return, the `closing`
+   comments — and the dry run of `codelife mr open`; then `codelife mr open <file>`, what it prints put to you with each question
+   a line names — on a yes to merging the target in, `git merge origin/<target>` and the dry run
+   again. Its `held:` lines are one table: each row the hash, the issue, the `Held:` line and, from
+   the commit's body, why and what it costs if wrong, **validated** or **refused** with your reason.
+   All validated → `--send`, which is their validation. One refused → nothing sent; per refusal, a
+   file opening on `codelife: refused — /work — <date>`, the `Held:` line, your reason quoted and
+   the later commits its line names, then `codelife issue reopen <n> <file>`; its member goes
+   through step 4 again from a new plan, its planner given that comment, then step 5.
+   No merge request when the run is delegated — the push is yours, `/work <n>` again —, under
+   `tracker.kind: none`, when every member left, or for a lone issue worked `in place` on a branch
+   not its own, *Next* naming `/mr`.
+
+## When a member does not complete
+
+A red or a verification still failing at the cap of `codelife help method red-green`, or a plan you
+refuse, stops the run: name the member, quote the reason, list what remains, start no further
+member. Present at the cap, you are offered a revised plan or the stop. Re-running `/work <n>`
+resumes there: the issues and the branch are the whole record.
+
+- **Waits for a case** — a plan saying `Waits for: C-<n>` is posted and stops the run, the case
+  named: another lot builds it, and `/roadmap` moves the member after that lot.
+- **Not located** — the planner, the implementer or a STATUS the summary shows found no cause:
+  propose that the member leave the lot, the refuted hypotheses its reason. Yes → `codelife lot leave <umbrella> <n> <reason
+  file>`, and the run goes on; no, or a lone issue → the run stops.
+- **Delegated** — restore the step's files, keep what is committed, post the STATUS
+  (`codelife help method comments`) through `codelife issue note`, and leave the issue open; a
+  member not located stays open the same way. No commit of the member on the branch
+  (`codelife log since <base> <n>`) → the next member; one, or a verification that could not
+  run → the lot stops.
+
+## Never
+
+- Work a member of another lot on this branch, join an issue the table did not carry, reorder the
+  umbrella, or skip a member because it looks hard.
+- Let an agent post, close, reopen, tick, join, leave or push; or tick a line by hand.
+- Revert a refused held choice: the work that used it would no longer build.
+- Review a member's fixes more than once, or give its merge request to `/review-mr` or
+  `/work-feedback`.
+- Stash, detach, add a worktree, or switch branch after step 3.
+- Answer in a language the user did not write in, or write anything but English into the
+  repository or the tracker.
+
+## Output
+
+The run ends on this block, under this exact heading:
+
+```markdown
+### work result
+- Produced: per member, its commits, what its review found and fixed, its close; the joins; the
+  branch; the umbrella's state; the merge request. Delegated, each held choice with the commits
+  resting on it.
+- Decided: the table, each plan, each finding kept or dropped, each question an agent put to you.
+- Left open: the members not reached, the one that stopped the run with its reason, the members
+  that left. Delegated: closed, stopped with their STATUS, not reached.
+- Next: the merge; or `/work <n>` again, without `delegate` — after a delegated run, to validate
+  its held choices and open the merge request.
+```

package/skills/work-feedback/SKILL.md

@@ -0,0 +1,113 @@
+---
+name: work-feedback
+description: Answer the review of your own merge request once — the latest pass's open numbers and the comments people wrote, one confirmed table, one commit per cause by a fresh agent, one push, and one answer citing the pushed hashes.
+argument-hint: "[mr-number]"
+---
+
+# /work-feedback
+
+Answers what another person's review left on **your own** merge request: the latest `/review-mr`
+pass's open numbers, and the comments and open threads people wrote after it. One table and one
+answer from you; one implementer agent makes one commit per cause; this session pushes once and
+posts one answer, which the reviewer's next pass reads.
+
+## Preconditions
+
+`codelife feedback prep` checks them and stops on the first that fails, naming it: a contract whose
+`tracker.kind` names a forge, connected — else `/setup`; an open merge request this account
+authored; `HEAD` on its branch, at its head or ahead of it — a previous run's commits waiting to be
+pushed —, and a clean tree, asserted, never arranged: the stop names the forge's checkout command.
+
+## Brief
+
+**Who gave the go-ahead**, and from what, opens it: you, typing the command or answering this
+brief; your confirmed table in a driver, which answers what it named — ask only the rest; the word
+`delegate`; or a session that relayed your words, quoted here — relayed is not delegated. Typed or
+tabled, this brief is an announcement; otherwise the run **stops here** for your go-ahead, after
+nothing but a preparation that only reads.
+
+Made from `feedback prep`'s summary alone: the merge request and where its number came from; the
+pass it answers, or none — the comments alone; the rows, and those a commit already answers; the
+commits waiting to be pushed.
+
+## Parameters
+
+`[mr-number]`; absent, the open merge request of the current branch, which the preparation names.
+Nothing else is asked: the table is the one answer. No `delegate`: a run left alone waits at its
+first question or at the push, which is where a delegated one would have stopped.
+
+## Steps
+
+1. **Prepare** — `TMPDIR=<the session's scratchpad> codelife feedback prep [<n>]`. A `- stop:` line
+   ends the run, its reason said. `rows.md` in its run folder holds each row whole; a row a commit
+   already answers names that commit.
+2. **One table** — each row, its subject in a few words, its disposition, its cause, and why in the
+   same cell:
+
+   | Disposition | What it does |
+   |---|---|
+   | `change` | the row asks for what the branch does not yet do: its cause's commit |
+   | `answer` | no file touched — the row asks a question; a commit already does it, named; or another open merge request carries the fix, named with the merge order, that one first |
+   | `refuse` | not done, the reason in the answer; a row that would undo what the specification decided also leaves one line of that capability's `## Rejected`, as `codelife help method refusal` writes it |
+   | `file` | outside this merge request: an issue |
+
+   Rows whose fix is one change — one sentence two findings fault, one fact written in two places —
+   share a cause, adjacent, and one commit answers them all. A row a commit already answers is an
+   `answer` citing it. A `refuse` is yours: proposed, never decided. One answer; nothing is written
+   before it.
+3. **The causes** — when the table holds a `change` or a refusal line: one `codelife:implementer`
+   agent, given the merge request, its merge base, *review*, and the confirmed causes in order —
+   each with its rows' text from `rows.md`, its disposition, and the trailer its commit ends on:
+   `Answers: pass <k>: <n>, <m>`, or `Answers: <the comment's link>` for a person's row. Put its
+   question to you, and your answer to that same agent with `SendMessage`.
+4. **File** each `file` row: written as `codelife help template bug` or `feature` prints an issue,
+   its first line `# <sentence>`, and filed by `codelife issue create <nature> <severity|->
+   mr:!<n> <file>`.
+5. **Push once**, when the branch is ahead of its upstream: `codelife mr open`, which keeps the
+   description; what it prints put to you with each question a line names — on a yes to merging
+   the target in, `git merge origin/<target>` and the dry run again; a `held:` line, a stop naming
+   `/work <n>`, whose choice it is; on your yes, `codelife mr open --send`. Always before the answer: an unpushed
+   hash is one the reviewer cannot open.
+6. **Answer once** — a file in the scratchpad: its first line `codelife: answer — pass <k> — <the
+   pushed head sha>`, or `codelife: answer — comments — <sha>` with no pass; then a table
+   `| Row | Answer |`, each row's number or its comment's link — a cause's rows in one cell — →
+   `fixed in <sha>`, the refusal and its reason with its line and hash when it left one,
+   `filed as #<n>`, or the answer; after a stop, a last line `Not reached: <rows> — <why>`. Then
+   `codelife mr post <n> <file>`.
+
+## When a cause does not complete
+
+The implementer stops at a red or a verification still failing at the cap of
+`codelife help method red-green`, or at a behaviour whose cause is `not located`: its step is
+restored, what is committed stays, and no further cause starts. Steps 4 to 6 still run for what
+completed, the answer naming the rows not reached and why. A re-run resumes from the forge — the
+answer and the trailers are the whole record; a row not located is proposed there as a `file` or a
+`refuse`, its refuted hypotheses the reason.
+
+## Never
+
+- Commit, file, push or post what the table did not confirm.
+- Widen a row: what it did not raise is a `file` row, or nothing.
+- Edit or delete a comment, or resolve a thread: the pass is never edited, a person's thread is
+  theirs to close.
+- Re-review, or post a finding: this skill evaluates nothing.
+- Push outside `codelife mr open --send`, or answer with a hash not pushed.
+- Check out, switch or stash anything.
+- Answer in a language the user did not write in, or write anything but English into the
+  repository or the tracker.
+
+## Output
+
+The run ends on this block, under this exact heading:
+
+```markdown
+### work-feedback result
+- Produced: each cause's commit; each refusal, with its line when it left one; the issues filed;
+  the push; the answer's link.
+- Decided: the table, each disposition and cause you changed, each question the implementer put to
+  you.
+- Left open: the refusals, for the reviewer to accept or keep; the rows a stop left unanswered,
+  with its reason.
+- Next: `/review-mr` for the reviewer's next pass; the merge when nothing stands; `/work <n>` on an
+  issue filed.
+```