@linimin/pi-letscook 0.1.26

package/CHANGELOG.md

@@ -0,0 +1,196 @@
+# Changelog
+
+## 0.1.26
+
+### Changed
+
+- clarified the README install guidance and `/cook` behavior matrix, including tracked-vs-ignored `.agent` file explanations, active-workflow replacement examples, and safer `/reload` guidance for completion work
+
+## 0.1.25
+
+### Changed
+
+- `/cook` with no goal can now propose a context-derived startup plan for confirmation when no active workflow exists, including starting a fresh next round after the previous workflow already reached `done`
+- `/cook <goal>` now builds a goal-anchored, context-enriched startup proposal before writing canonical state, uses more explicit active-workflow replacement wording, and starts the next round directly from the explicit goal after a completed workflow instead of reopening continue/refocus choices
+
+## 0.1.24
+
+### Changed
+
+- removed the completion status line entirely; the remaining completion widget appears only when no role is actively running
+
+## 0.1.23
+
+### Changed
+
+- renamed the public workflow command from `/complete` to `/cook`
+- aligned the published package/install identity around `@linimin/pi-letscook` and `pi-letscook`
+- removed the completion status line entirely; the remaining completion widget now appears only when no role is actively running
+- kept the richer live role observability lanes and waiting/stalled signaling without reintroducing a status-line surface
+- added this current release entry so the shipped `/cook`, package rename, and current completion UI behavior are documented without rewriting older `/complete` history
+
+## 0.1.22
+
+### Changed
+
+- clarified the existing-workflow continue/refocus selection UI with a clearer prompt, current-vs-proposed mission summary, and shorter option descriptions
+
+## 0.1.21
+
+### Changed
+
+- kept the persistent completion status line from canonical `.agent/**` state and live role activity, while suppressing the widget whenever a role is actively running
+- separated live running-role observability into distinct tool activity, role judgment, verification, and state-delta lanes with waiting/stalled signaling
+- added deterministic observability status regression coverage to the release-check path
+- refreshed README and release-verifier guidance so the shipped observability surfaces and verification flow are documented truthfully
+
+## 0.1.18
+
+### Changed
+
+- reduced the public slash-command surface to a single `/complete` entrypoint
+- `/complete` with no goal now resumes from canonical `.agent/**` state when present
+- `/complete <new goal>` now asks whether to continue the current mission or refocus canonical mission state before continuing
+- removed dedicated resume, reground, panel, history, verify, and pause slash commands in favor of the always-visible workflow status
+- pruned helper code that only supported the removed slash commands
+- added a regression test for existing-workflow refocus handling and included it in release checks
+
+## 0.1.16
+
+### Improved
+
+- richer operator-facing live role execution display with progress, rationale, next-step, verification, and state-delta parsing
+- elapsed-time tracking for running completion roles
+- no emoji in workflow-specific status, widget, panel, or role execution displays
+- role prompts now emit structured `PROGRESS`, `RATIONALE`, `NEXT`, `VERIFYING`, and `STATE-DELTA` lines for observability
+
+## 0.1.15
+
+### Changed
+
+- removed `/completion-status`; rely on the persistent widget/footer and `/completion-panel` for state inspection
+
+## 0.1.14
+
+### Changed
+
+- removed `/completion-init` and made `/complete <goal>` the single bootstrap-and-run entrypoint
+- smoke test now validates bootstrap through `/complete`
+- docs updated to treat `/complete` as the canonical initialization path
+
+## 0.1.13
+
+### Improved
+
+- persistent footer/widget status is now more compact and useful for day-to-day workflow use
+- always-visible status now surfaces live role/action summaries without requiring the panel to be open
+- widget lines now favor concise mission, goal, reason, and live activity previews over verbose raw fields
+
+## 0.1.12
+
+### Improved
+
+- `/completion-panel` now live-follows current running role activity
+- side panel and print-mode panel output now include current role, current action, recent activity, and assistant-progress previews while a completion role is running
+
+## 0.1.11
+
+### Added
+
+- `/completion-panel` command for an on-demand right-side completion workflow panel
+- live panel view for canonical mission, current phase, active slice, remaining work, and recent history
+- print-mode fallback that renders panel contents as plain text when interactive UI is unavailable
+
+## 0.1.10
+
+### Improved
+
+- ambiguous bootstrap goals can now trigger developer confirmation or editing of the proposed `MISSION ANCHOR`
+- `/complete` and `/completion-init` keep auto-bootstrap for clear goals but ask before writing weak or underspecified anchors into canonical state
+- mission-anchor confirmation uses extension UI instead of relying on model-side clarification later in the workflow
+
+## 0.1.9
+
+### Improved
+
+- bootstrap now derives a cleaner `MISSION ANCHOR` from vague `/complete` and `/completion-init` goals
+- weak or underspecified goals now fall back to a stable repo-based mission anchor instead of using raw ambiguous text
+- common phrasing noise like `/complete`, `please`, and `end-to-end` is normalized before seeding canonical mission state
+
+## 0.1.8
+
+### Fixed
+
+- removed duplicate prompt-template aliases for `/complete`, `/complete-resume`, and `/completion-status`
+- package now exposes those names only as extension commands, avoiding duplicate command entries in pi
+
+## 0.1.7
+
+### Fixed
+
+- generated `verify_completion_control_plane.sh` now validates canonical `plan.json` and `active-slice.json` structure instead of only checking JSON parseability
+- exact implementer handoff states now require `priority` and `why_now`, matching the completion protocol docs and role expectations
+- scaffolded `active-slice.json` now includes `priority` and `why_now` placeholders to avoid schema drift during later role updates
+- `ensureGitignore` now repairs duplicated or drifted completion-protocol ignore blocks instead of bailing out on the first marker match
+- smoke test now covers the selected active-slice handoff schema regression and fails closed when `priority`/`why_now` are missing
+
+## 0.1.6
+
+### Fixed
+
+- additional stale-context guards for command handlers and completion role execution
+- avoid stale ctx access through cwd, hasUI, ui, and system-prompt lookups after session replacement or reload
+
+## 0.1.5
+
+### Fixed
+
+- stale extension context handling after session replacement or reload
+- guarded UI status, widget, theme, and notify calls to avoid stale-ctx runtime errors
+
+## 0.1.4
+
+### Improved
+
+- stronger implementer instructions for roadmap-level drift discovered during implementation
+- explicit requirement to hand plan repair back to `completion-regrounder` instead of silently redesigning slices
+- implementer report now includes `Plan adjustment required: yes/no - ...`
+
+## 0.1.3
+
+### Improved
+
+- richer live progress visibility for `completion_role`
+- current action, recent activity, and assistant-progress previews while roles are running
+- less opaque role execution UX during long-running workflow steps
+
+## 0.1.2
+
+### Improved
+
+- stronger post-compaction driver recovery instructions
+- transient post-compaction recovery marker with automatic cleanup after recovery turn
+- stricter canonical-file-first continuation guidance after compaction
+
+## 0.1.1
+
+### Improved
+
+- print-mode output for `/completion-status`, `/completion-history`, `/completion-verify`, and `/completion-pause`
+- package-local runtime polish for release workflow
+
+## 0.1.0
+
+Initial packaged release of `pi-completion-workflow`.
+
+### Added
+
+- pi package manifest with extension, skills, prompts, and role agents
+- canonical `.agent/**` scaffolding via `/completion-init`
+- workflow entrypoints: `/complete` and `/complete-resume`
+- workflow inspection commands: `/completion-status`, `/completion-history`, `/completion-verify`
+- pause and re-ground commands
+- isolated `completion_role` execution for role-based subagents
+- canonical transcription of reviewer, auditor, regrounder, and stop-judge outputs
+- custom compaction continuity support
+- release smoke test script

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 linimin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/PUBLISHING.md

@@ -0,0 +1,60 @@
+# Publishing Guide
+
+## Before publishing
+
+Run from the package root:
+
+```bash
+npm run smoke-test
+npm run release-check
+```
+
+## GitHub release flow
+
+```bash
+git init
+git add .
+git commit -m "Initial release"
+git branch -M main
+git remote add origin git@github.com:<YOUR-USER>/pi-letscook.git
+git push -u origin main
+git tag v0.1.0
+git push origin v0.1.0
+```
+
+Users can then install with:
+
+```bash
+pi install git:github.com/<YOUR-USER>/pi-letscook@v0.1.0
+```
+
+## npm release flow
+
+For the scoped public package name `@linimin/pi-letscook`, publish with:
+
+```bash
+npm login
+npm publish --access public
+```
+
+Users can then install with:
+
+```bash
+pi install npm:@linimin/pi-letscook
+```
+
+## Recommended metadata before public release
+
+Consider updating these fields in `package.json` before publishing publicly:
+
+- `name`
+- `repository`
+- `homepage`
+- `bugs`
+- `author`
+
+## Versioning
+
+- bump `version` in `package.json`
+- add a new entry to `CHANGELOG.md`
+- create a matching git tag like `v0.1.1`

package/README.md

@@ -0,0 +1,219 @@
+# @linimin/pi-letscook
+
+Pi package for long-running coding workflows with canonical repo-local `.agent/**` state.
+
+## What it gives you
+
+- `/cook` as the single workflow command
+- `/cook <goal>` to bootstrap or continue with an explicit goal, enriched by recent discussion before canonical state is written
+- `/cook` with no goal to resume an active canonical `.agent/**` workflow, or propose a new round from recent discussion when no active workflow is running
+- `/cook <new goal>` on an active workflow asks whether to continue the current mission or abandon it for a replacement workflow; on a completed workflow it starts the next round from the new goal instead of reopening continue/refocus choices
+- no duplicate prompt-template aliases for core workflow commands
+- role-based isolated subprocess execution via `completion_role`
+- completion widget sourced from canonical `.agent/**` state when no role is actively running, with no completion status line
+- richer live role observability that keeps tool activity separate from role progress, rationale, next-step, verification, and state-delta output
+- deterministic waiting/stalled signaling for running completion roles
+- custom compaction continuity capsule
+- canonical transcription of reviewer, auditor, regrounder, and stop-judge outputs
+- repo-local verifier scripts and `.gitignore` wiring
+
+## Quick start
+
+In a git repo, after installing the package:
+
+```text
+/cook build feature X end-to-end with tests and docs
+```
+
+If you stop and come back later while that workflow is still active:
+
+```text
+/cook
+```
+
+If you want to replace the active workflow with a new goal:
+
+```text
+/cook fix onboarding crash first, with regression tests
+```
+
+If the previous workflow is already done and you want to start the next round from an explicit goal:
+
+```text
+/cook ship the next workflow round for richer /cook startup proposals
+```
+
+## Install
+
+### Try temporarily from a local checkout
+
+```bash
+pi -e /absolute/path/to/pi-letscook
+```
+
+### Install globally from a local checkout
+
+```bash
+pi install /absolute/path/to/pi-letscook
+```
+
+### Install into a project from a local checkout
+
+```bash
+pi install -l /absolute/path/to/pi-letscook
+```
+
+### Install from npm after publishing
+
+```bash
+pi install npm:@linimin/pi-letscook
+```
+
+### Install from git after publishing
+
+For normal installs, prefer the npm package above. Use the git source if you want to install directly from GitHub.
+
+```bash
+pi install git:github.com/linimin/pi-letscook
+```
+
+You can also pin a specific tag or commit if you want a fixed version, for example `git:github.com/linimin/pi-letscook@vX.Y.Z`.
+
+After install, run `/reload` in pi. For this package, it is safest to reload when pi is idle and no `completion_role` is currently running.
+
+## Usage patterns
+
+### Mental model
+
+`/cook` is the single entrypoint for this package, but its behavior depends on the current canonical workflow state.
+
+| Repo state | `/cook` | `/cook <goal>` |
+|---|---|---|
+| No canonical workflow yet | Proposes a startup plan from recent discussion, then asks for confirmation | Builds a startup proposal anchored on the explicit goal, enriches it from recent discussion, then asks for confirmation |
+| Active workflow exists | Resumes the active workflow from canonical `.agent/**` state | Asks whether to continue the current workflow or replace it with a new one |
+| Previous workflow is already `done` | Proposes the next workflow round from recent discussion, then asks for confirmation | Starts the next workflow round from the explicit goal, using recent discussion only as supplemental proposal context |
+
+### One-step start
+
+```text
+/cook Build feature X with tests and docs
+```
+
+This bootstraps `.agent/**` if missing, derives a clean initial `MISSION ANCHOR`, builds a startup proposal, lets you confirm or edit it, re-grounds canonical state, creates a slice plan, and drives the workflow.
+
+When you pass an explicit goal, that goal stays the mission anchor. Recent discussion is only used to fill in extra scope, constraints, and acceptance details before canonical state is written.
+
+### Resume later
+
+```text
+/cook
+```
+
+If canonical `.agent/**` state already exists and is still active, `/cook` with no goal resumes from that state.
+
+### Replace the active workflow
+
+```text
+/cook fix onboarding crash first, with regression tests
+```
+
+If a workflow is still active, `/cook <goal>` asks whether to:
+
+- continue the current workflow, or
+- abandon the current workflow and start this new one
+
+If you replace the active workflow, `/cook` rebuilds canonical state from the new goal and restarts from `reground`.
+
+### Start the next round after completion
+
+```text
+/cook ship the next workflow round for richer /cook startup proposals
+```
+
+If the previous workflow is already `done`, `/cook <goal>` starts the next workflow round directly from that explicit goal. It does not reopen the old continue/refocus choice. Recent discussion is only used as supplemental proposal context.
+
+### Start the next round from discussion only
+
+```text
+/cook
+```
+
+If the previous workflow is already `done`, `/cook` with no goal tries to infer the next plan from recent discussion, asks you to confirm it, and then starts the next workflow round from refreshed canonical state.
+
+## Canonical repo files
+
+This package manages repo-local canonical workflow state under:
+
+```text
+.agent/
+  README.md
+  mission.md
+  profile.json
+  verify_completion_stop.sh
+  verify_completion_control_plane.sh
+  state.json
+  plan.json
+  active-slice.json
+  slice-history.jsonl
+  stop-check-history.jsonl
+  tmp/
+```
+
+Canonical truth lives in these files plus current repo truth.
+
+### Tracked vs ignored `.agent` files
+
+The `.agent` directory mixes two different kinds of workflow data:
+
+- **Tracked repo-contract files** define the repo-level workflow contract and should stay in git:
+  - `.agent/README.md`
+  - `.agent/mission.md`
+  - `.agent/profile.json`
+  - `.agent/verify_completion_stop.sh`
+  - `.agent/verify_completion_control_plane.sh`
+- **Ignored execution-state files** are local high-churn workflow state used for resume and recovery and should stay out of git:
+  - `.agent/state.json`
+  - `.agent/plan.json`
+  - `.agent/active-slice.json`
+  - `.agent/slice-history.jsonl`
+  - `.agent/stop-check-history.jsonl`
+  - `.agent/*.log`
+  - `.agent/tmp/`
+
+In other words: tracked `.agent` files describe the workflow contract for the repo, while ignored `.agent` files are the local control-plane state for the current run.
+
+## Live observability surfaces
+
+When canonical `.agent/**` state exists and no role is actively running, the extension shows a completion widget sourced from that state. The non-running widget summarizes the current phase, selected slice, next mandatory role, and remaining work counts; there is no completion status line.
+
+While a `completion_role` subprocess is running, the widget is intentionally suppressed. Tool execution is rendered separately from assistant-provided `PROGRESS`, `RATIONALE`, `NEXT`, `VERIFYING`, and `STATE-DELTA` lines so operators can tell the difference between tool work, role judgment, and verification. The running-role display still emits deterministic active/waiting/stalled signaling from the role timestamps instead of silently looking idle.
+
+## Package layout
+
+- `extensions/completion/index.ts` — workflow extension
+- `skills/completion-protocol/` — shared protocol docs
+- `agents/completion-*.md` — package-local completion roles used by the extension
+- `scripts/` — smoke and release checks
+
+## Development and release
+
+Run validation from the package root:
+
+```bash
+npm run smoke-test
+npm run refocus-test
+npm run context-proposal-test
+npm run observability-status-test
+npm run release-check
+```
+
+`npm run release-check` is the broader packaged-release verifier. It reruns the smoke, refocus, and context-proposal checks, includes the deterministic observability regression coverage, and finishes with `npm pack --dry-run`.
+
+See [PUBLISHING.md](./PUBLISHING.md) for GitHub and npm release steps.
+
+## Notes
+
+- Canonical truth lives in repo-local `.agent/**` files.
+- The main pi session is the workflow driver.
+- Package-local role prompts are loaded directly by the extension; they do not rely on `~/.pi/agent/agents`.
+- Reviewer, auditor, and stop-judge are enforced as read-only roles.

package/agents/completion-auditor.md

@@ -0,0 +1,43 @@
+---
+name: completion-auditor
+description: Read-only completion auditor; state why the project is not yet done and whether canonical state and backlog remain truthful.
+tools: read,grep,find,ls,bash
+---
+
+You are the read-only `completion` auditor.
+
+Load `completion-protocol` before acting.
+
+You must not:
+
+- edit tracked repo files
+- write canonical `.agent` state
+- append slice-history or stop-check records yourself
+- create commits
+
+Audit current HEAD truth after a committed slice. Focus on remaining work, tracked and unignored worktree cleanliness, and canonical truthfulness.
+
+During long work, emit short operator-facing progress lines when useful using these exact prefixes:
+- `PROGRESS: ...`
+- `RATIONALE: ...`
+- `NEXT: ...`
+
+These lines are for workflow observability, not hidden reasoning. Keep them brief and truthful.
+
+Answer only:
+
+- `MISSION ANCHOR: ...`
+- `Remaining contract IDs: ...`
+- `Why the project is still not done: ...`
+- `Open top-level contract IDs: ...`
+- `Blocker count: ...`
+- `High-value gap count: ...`
+- `Tracked and unignored worktree is clean: yes/no`
+- `Worktree blockers: ...`
+- `Next mandatory slice: ...`
+- `Stale or conflicting canonical state: ...`
+- `Plan truthfully captures remaining slice backlog: yes/no - ...`
+
+If the tracked and unignored worktree is dirty after the latest committed slice, report that as a blocker to next-slice progression, do not recommend a new next slice, and point the workflow back to reconciliation of the latest slice.
+
+If no remaining gap is evident, say so plainly instead of inventing one.

package/agents/completion-bootstrapper.md

@@ -0,0 +1,56 @@
+---
+name: completion-bootstrapper
+description: Bootstrap or repair tracked completion control-plane files, then hand off to completion-regrounder.
+tools: read,grep,find,ls,bash,write,edit
+---
+
+You are the `completion` bootstrapper.
+
+Load `completion-protocol` before acting. Use it as the shared protocol source of truth.
+
+You are an onboarding-only control-plane role. You may:
+
+- read current repo truth and canonical `.agent` state
+- create or repair tracked completion contract files under `.agent/**`
+- update `.gitignore` so tracked contract files remain tracked while execution artifacts remain ignored
+- initialize missing or invalid canonical execution-state files only when repair is required for a truthful handoff
+- return the exact handoff payload for `completion-regrounder`
+
+You must not:
+
+- invoke any completion role
+- edit tracked product, docs, config, or test files outside `.agent/**` and `.gitignore`
+- overwrite existing truthful `.agent/state.json`, `.agent/plan.json`, or `.agent/active-slice.json`
+- create commits
+- append slice-history or stop-check records
+- continue into implementation, review, audit, or stop judgment yourself
+
+On onboarding or repair:
+
+During long work, emit short operator-facing progress lines when useful using these exact prefixes:
+- `PROGRESS: ...`
+- `RATIONALE: ...`
+- `NEXT: ...`
+- `STATE-DELTA: ...`
+
+These lines are for workflow observability, not hidden reasoning. Keep them brief and truthful.
+
+1. Scan the repo for the strongest intent and validation surfaces.
+2. Infer project goal, operator-visible docs surfaces, and strongest validation entrypoint.
+3. If repo intent or validation entrypoint is ambiguous, ask one short clarifying question.
+4. Create or repair `.agent/README.md`, `.agent/mission.md`, `.agent/profile.json`, `.agent/verify_completion_stop.sh`, and `.agent/verify_completion_control_plane.sh`, keeping them truthful to current repo reality.
+5. Update `.gitignore` so `.agent/*` remains ignored except the tracked repo-contract files, and keep `.agent/tmp/` ignored as scratch space.
+6. Initialize `.agent/state.json`, `.agent/plan.json`, and `.agent/active-slice.json` only when they are missing, unreadable, or structurally invalid. Preserve any existing truthful execution state.
+7. Stop after canonical bootstrap or repair is truthful and return the handoff to `completion-regrounder`.
+
+Return exactly this fixed report format:
+
+- `MISSION ANCHOR: ...`
+- `Remaining contract IDs: ...`
+- `Bootstrap applied: yes/no - ...`
+- `Tracked contract files repaired: ...`
+- `Execution-state files initialized: ...`
+- `Gitignore updated: yes/no - ...`
+- `Next role to invoke: completion-regrounder`
+- `Exact handoff payload: ...`
+- `Canonical blockers: ...`

package/agents/completion-implementer.md

@@ -0,0 +1,83 @@
+---
+name: completion-implementer
+description: Implement exactly one chosen completion slice end to end, including minimal edits, verification, canonical implementation records, and commit.
+tools: read,grep,find,ls,bash,write,edit
+---
+
+You are the `completion` slice implementer.
+
+Load `completion-protocol` before acting. Use it as the shared protocol source of truth.
+
+You execute one exact slice chosen either by `completion-regrounder` or directly by the workflow root from canonical `.agent` state.
+
+Required exact handoff from canonical `.agent` state:
+
+- blocker count before the slice
+- high-value gap count before the slice
+- open contract IDs before the slice
+- latest accepted or latest completed slice commit
+- one exact slice ID
+- one exact slice goal
+- the exact acceptance criteria for that slice
+- the exact contract IDs for that slice
+- any locked notes or caller-selected-slice notes captured in `.agent/active-slice.json`
+- any must-fix review findings captured in `.agent/active-slice.json` if this is a follow-up slice
+
+If the exact slice ID, exact slice goal, or exact acceptance criteria are missing, stale, or ambiguous in canonical state, stop and report that blocker instead of guessing.
+
+You are the only role allowed to:
+
+- edit tracked product, docs, config, or test files for the chosen slice
+- refresh tracked repo-contract verifier files such as `.agent/verify_completion_stop.sh` when the chosen slice requires truthful verifier parity
+- create the slice commit
+- append exactly one `implemented` record after the commit
+
+You must not:
+
+- choose the next slice
+- silently split, merge, rename, reorder, or replace slices in the canonical roadmap
+- write `reviewed`, `audited`, `accepted`, `reopened`, or `judgment` records
+- broaden scope because nearby cleanup is tempting
+
+Execution contract:
+
+During long work, emit short operator-facing progress lines when useful using these exact prefixes:
+- `PROGRESS: ...`
+- `RATIONALE: ...`
+- `NEXT: ...`
+- `VERIFYING: ...`
+- `STATE-DELTA: ...`
+
+These lines are for workflow observability, not hidden reasoning. Keep them brief and truthful.
+
+1. Read canonical `.agent` inputs before touching tracked files.
+2. After compaction or recovery, re-read canonical `.agent/state.json`, `.agent/plan.json`, and `.agent/active-slice.json` before resuming.
+3. Confirm the canonical slice ID, goal, acceptance criteria, and contract IDs in `.agent/active-slice.json` match canonical `.agent/plan.json`. If they do not match, stop and report the mismatch instead of guessing.
+4. Make truthful `.agent/state.json` and `.agent/active-slice.json` updates before implementation if needed.
+5. If implementation reveals roadmap-level drift — for example a missing prerequisite slice, invalid slice boundary, dependency reorder, or blocker that changes the current slice contract — do not silently redesign the plan. Report the discrepancy explicitly, make only the minimal truthful local state updates needed for the current slice, and hand control back for canonical re-grounding by `completion-regrounder`.
+6. Make the smallest correct tracked-file change.
+7. Add or strengthen tests or deterministic proof.
+8. Run focused verification first, then broader verification if shared surfaces changed.
+9. If the chosen slice changes top-level validation entrypoints or is explicitly about verifier freshness, refresh `.agent/verify_completion_stop.sh` so it remains a truthful repo-level baseline verifier.
+10. Create a new commit.
+11. Make truthful `.agent/state.json`, `.agent/active-slice.json`, and `.agent/plan.json` updates after the commit, including `current_phase = post_commit_review`, `continuation_policy = continue`, `continuation_reason`, and `next_mandatory_role = completion-reviewer`.
+12. Append exactly one `implemented` record to `.agent/slice-history.jsonl`.
+
+Do not stop after editing or verification if the slice changes remain uncommitted.
+
+Return exactly this fixed report format:
+
+- `MISSION ANCHOR: ...`
+- `Remaining contract IDs before slice: ...`
+- `Slice ID: ...`
+- `Slice goal: ...`
+- `Contract IDs closed or advanced: ...`
+- `Files changed: ...`
+- `Tests added or strengthened: ...`
+- `Verification commands run: ...`
+- `Verification results: ...`
+- `Commit SHA: ...`
+- `What release gap this closed: ...`
+- `Plan adjustment required: yes/no - ...`
+- `Residual risks discovered: ...`
+- `Remaining contract IDs after slice: ...`