pi-gauntlet 7.10.0 → 7.10.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## v7.10.1 - 2026-10-13
+
+### Changed
+
+- `gauntlet-resume` repairs plan citation drift on a `plan_check` failure instead of stopping: moved anchors, missing literals, `Modify:` rows that completed tasks deleted, and renamed `Test:` paths are fixed in place through a new `## Plan repair` section of the brief contract, re-checked up to three rounds, committed alone when the plan was tracked and clean, and reported on a `Repaired plan:` receipt line; the restore then continues with the task list verbatim. A finding that needs a task renamed, reordered, added, or removed stops before any write with a `Repair stopped:` line. Reconstruction reads task evidence from the union of the working-copy and plan-commit `Files:` paths. New eval target `eval/gauntlet-resume`.
+
 ## v7.10.0 - 2026-10-11
 
 ### Changed

package/README.md

@@ -87,7 +87,7 @@ pi-gauntlet is **opinionated**: it recommends this pipeline for non-trivial chan
 
 ## Handoff and resume
 
-`/skill:gauntlet-handoff` and `/skill:gauntlet-resume` are a pair: cohort's `handoff` skill writes the six flow-agnostic headings, gauntlet-handoff appends `## Process state`, and gauntlet-resume reads the whole brief back. Both gauntlet skills read one grammar file, `skills/gauntlet-resume/reference/brief-contract.md`; the repo validator (`scripts/ci.mjs`) fails if a grammar line appears anywhere else under `skills/`. Requires pi-cohort >= 7.1.0 (the `handoff` skill, [pi-cohort #18](https://github.com/jjuraszek/pi-cohort/issues/18)); on an older pi-cohort, gauntlet-handoff stops before writing. A resume also reads the spec's `**Amend-grant:**` header line and prints `Standing grant active: <sentence>` or `No standing grant.` on the line after its closing line; the brief itself carries no grant.
+`/skill:gauntlet-handoff` and `/skill:gauntlet-resume` are a pair: cohort's `handoff` skill writes the six flow-agnostic headings, gauntlet-handoff appends `## Process state`, and gauntlet-resume reads the whole brief back. Both gauntlet skills read one grammar file, `skills/gauntlet-resume/reference/brief-contract.md`; the repo validator (`scripts/ci.mjs`) fails if a grammar line appears anywhere else under `skills/`. Requires pi-cohort >= 7.1.0 (the `handoff` skill, [pi-cohort #18](https://github.com/jjuraszek/pi-cohort/issues/18)); on an older pi-cohort, gauntlet-handoff stops before writing. A resume also reads the spec's `**Amend-grant:**` header line and prints `Standing grant active: <sentence>` or `No standing grant.` on the line after its closing line; the brief itself carries no grant. On a `plan_check` failure, resume repairs plan citation drift itself (moved anchors, changed literals, file rows that completed tasks deleted) and stops only when a task must change.
 
 ### Smoke walkthrough (release-gated)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-gauntlet",
-  "version": "7.10.0",
+  "version": "7.10.1",
   "description": "Opinionated, gated workflow skills, subagent personas, and runtime extensions for the pi coding agent.",
   "author": "Jacek Juraszek",
   "type": "module",

package/skills/gauntlet-resume/SKILL.md

@@ -23,7 +23,8 @@ before any tracker mutation; every stop names the offending path, field, or line
 
 - Reads: anything.
 - Writes: `phase_tracker` / `plan_tracker` state after every check passes and every
-  human question is answered; on the seed route, what `/skill:using-git-worktrees`
+  human question is answered; the plan file, only through `reference/brief-contract.md`
+  `## Plan repair`; on the seed route, what `/skill:using-git-worktrees`
   writes. Never a spec copy, rename, or marker commit.
 - Never: `git worktree add` directly; worktree creation by resume itself only on
   the seed route, only through `/skill:using-git-worktrees`; infer approval from

package/skills/gauntlet-resume/reference/brief-contract.md

@@ -130,7 +130,7 @@ announcement without re-resolving it.
 |---|---|
 | brainstorm | `start brainstorm`; `substep` if the brief shows one |
 | plan | `start brainstorm`; `skip brainstorm S`; `start plan`; `substep` if shown |
-| implement | `start brainstorm`; `skip brainstorm S`; `start plan`; `plan_check({ planPath })`; on FAIL print findings and stop with plan in_progress, no init; on PASS `skip plan R`; `start implement`; `substep` if shown; `plan_tracker init` |
+| implement | `start brainstorm`; `skip brainstorm S`; `start plan`; `plan_check({ planPath })`; on FAIL run `## Plan repair`; on PASS `skip plan R`; `start implement`; `substep` if shown; `plan_tracker init` |
 | verify | as implement through `skip plan R`, then `skip implement R`; `start verify`; `substep` if shown; `plan_tracker init` |
 | ship | as verify. Restoration stops at verify in_progress: `complete verify` needs a fresh conformance dispatch and `skip verify` would bypass a real gate. Announce that the closure review re-runs before ship |
 
@@ -141,6 +141,42 @@ spec was added after base or tracked from base (`reconstruction.md` "Candidates"
 resolve the selected plan to an absolute path under the worktree before `plan_check`.
 Zero pairs -> stop; more than one -> human picks.
 
+## Plan repair
+
+Entered from the call table's `implement` row and from `reconstruction.md` "Spec with plan" step 2 when `plan_check` returns FAIL. Inputs: the findings, and the task list with statuses (the brief's, or the confirmed reconstruction snapshot) - read it for evidence, never rewrite it.
+
+Record the plan's state before any write: tracked and clean when `git -C <worktree> ls-files --error-unmatch -- <plan path>` exits 0 and `git -C <worktree> status --porcelain -- <plan path>` prints nothing (index and working copy both match HEAD; a staged edit alone makes it dirty); otherwise copy the file to a temp path outside the worktree.
+
+Classify every finding against the table by its `check` and `reason`, gathering the row's evidence first. One finding with no row -> stop (below) before any write.
+
+| Finding (`check`, `reason`) | Evidence | Edit |
+|---|---|---|
+| `anchor-resolution`, range outside section or line shift | the anchor's heading string matches exactly one current spec heading | set the `**Spec:**` `L<n>-L<m>` range to the current span of that section that holds the task body's existing literals |
+| `quote-integrity`, task-owned row | the row's anchor already resolves (repair anchors first) | add the missing backtick literal to the owning task's body; never replace or remove task text |
+| `quote-integrity`, `Verification`-owned row | as above | add the missing literal to the header `**Verification:**` line |
+| `table-closure`, row anchor not in the owner's `**Spec:**` set | the owner cell names an existing task whose body does the row's requirement | move the row's anchor together with that same owner's `**Spec:**` anchor; the owner cell never changes |
+| `paths-exist`, `Modify: path "<p>" does not exist` | the owning task is `complete` or `skipped` in the task list, and `git -C <worktree> log --diff-filter=D --format=%h -1 -- <p>` is non-empty | drop that `Modify:` row |
+| `paths-exist` or `tests-block`, a `Test:` path that does not exist or a `Tests:` segment not anchored | `git -C <worktree> log --diff-filter=R --format= --name-status -M -1 -- <old> <new>` shows the rename `<old>` -> `<new>` | substitute `<new>` for `<old>` in the `Test:` line and in the `Tests:` command; nothing else in the command changes |
+
+Every other `check` (`input`, `placeholder-scan`, `header-entrypoint`, `header-happy-path`, `waiver-literal`, `wave-file-disjointness`, `solo-line`, `internal`) and every reason not listed (a missing `Files:` block, an invalid or empty glob, a missing or ambiguous heading, a `pending`/`in_progress` owner of a dead `Modify:` row, a command broadening) has no row. Task names, count, order, wave membership, `Solo:` lines, the owner column, and task text beyond an added literal or a substituted path never change.
+
+Loop: write every classified edit, re-run `plan_check({ planPath })`, classify any new finding the same way; at most 3 rounds.
+
+PASS with the plan tracked and clean before the loop -> commit the plan alone:
+
+```bash
+git -C <worktree> add -- <plan path> && git -C <worktree> commit -q -m "resume: plan citation repair - <n> findings" -- <plan path>
+```
+
+The subject is not `amend:`, so `finishing-a-development-branch` Step 4's digest ignores it; a failed commit stops with git's output. PASS with the plan untracked or dirty before the loop -> leave the repair in the working copy; it lands with the next task commit. Then continue the originating route: the call table from `skip plan R`, or reconstruction step 3.
+
+Stop (a finding with no row, or a finding surviving the third round): when a round wrote the plan, restore its pre-loop bytes (`git -C <worktree> checkout -- <plan path>` when tracked and clean, else the saved copy) - a stop before the first write runs no git command; print the findings (a dead `Modify:` row prefixed with its owning task, e.g. `Task 5:`), leave `plan` in_progress with no `init`, and print one line:
+
+- no row: `Repair stopped: <check> - <reason> is outside citation repair; the plan file is unchanged. Edit the plan (task changes allowed), then re-run /skill:gauntlet-resume.`
+- third round: `Repair stopped: <check> - <reason> survived 3 rounds. Edit the plan, then re-run /skill:gauntlet-resume.`
+
+Resume never edits the spec; no Open Question is written.
+
 "Exact" restoration binds: the active phase identity and substep, and the plan task list
 (names, order, statuses) verbatim. Prior phases show `⊘ (resume: ...)` regardless of the
 brief's glyph - skip-arming is the mechanism and completing priors would fabricate gated
@@ -161,3 +197,5 @@ Gate history not restored; re-validating `<task>` before any stage advance
 where `<task>` is the brief's `Active task`, else the first in-progress task, else `none`
 (whole-deliverable re-validation). Gate history, closure-review evidence, and fix rounds
 are never inferred or restored; a ship-stage brief resumes at verify.
+
+A restore that ran `## Plan repair` prints `Repaired plan: <n> findings (<comma-separated check names, deduplicated>)` on its own line directly before the closing line; the `Standing grant` line (SKILL.md "Post-restore continuation") keeps its place after the closing line. A first-check PASS prints no receipt and makes no commit.

package/skills/gauntlet-resume/reference/reconstruction.md

@@ -69,7 +69,11 @@ with this unapproved spec as the draft? Show the spec path (and the brief's
 Show, and ask the human to confirm or edit both in one reply:
 
 1. Per task, in plan order: the commits after the plan commit that touch any path in
-   the task's declared `Files:` block. Strip a trailing `:digits[-digits]` range from
+   the task's declared `Files:` block, taking the union of the block in the working
+   copy and in `git -C <worktree> show <plan-commit>:<plan path relative to the worktree>`
+   (an object path inside the repository, never the absolute `planPath`; a `Modify:` row
+   dropped by `brief-contract.md` "Plan repair" still yields its `complete` evidence).
+   Strip a trailing `:digits[-digits]` range from
    each `Modify:` path before matching `git -C <worktree> log -- <path>`:
    `git -C <worktree> log --format=%h --oneline <plan-commit>..HEAD -- <path>`.
    Uncommitted plan (no
@@ -94,7 +98,8 @@ edits override proposals; never rewrite confirmed state silently.
 After confirmation:
 
 1. Run SKILL.md entry check 6 on `<spec path>` (a malformed `**Amend-grant:**` line stops here, no tracker call); then `start brainstorm`; `skip brainstorm resume: <spec path>`; `start plan`.
-2. `plan_check` with `planPath` = the plan's absolute path. FAIL -> print the findings, stop with plan
+2. `plan_check` with `planPath` = the plan's absolute path. FAIL -> run `brief-contract.md`
+   `## Plan repair`; its PASS continues at step 3, its stop ends the restore with plan
    in_progress, no `init`.
 3. PASS -> `skip plan` with the same `resume:` reason; for stage verify also
    `skip implement`; `start <stage>`.