prizmkit 1.1.99 → 1.1.101

package/bundled/dev-pipeline/templates/bootstrap-prompt.md

@@ -44,3 +44,7 @@ Infer what needs to be done from the feature context above and follow the standa
 - Do NOT push to remote — the user will push manually.
 - Write all artifacts to `.prizmkit/specs/{{FEATURE_SLUG}}/`.
 - If a step fails after 3 attempts, write a status report and stop.
+- **Anti re-read**: once you read a file into context, do NOT read it again — use `grep -n`/`sed -n` for specific lines. 3 full Reads of same file → report BLOCKED.
+- **Read offset safety**: if Read returns "shorter than offset"/"empty" — run `wc -l` then `sed -n`, do NOT retry same offset.
+- **Hard Round Cap**: after 6 total test-fix rounds, STOP trial-and-error. Switch to read-once-then-rewrite. Do NOT exceed 7 rounds.
+- **Layered test**: debug with single-file tests, only run full suite as gate when single-file is green.

package/bundled/dev-pipeline/templates/bootstrap-tier1.md

@@ -12,7 +12,7 @@ You are the **session orchestrator**. Implement Feature {{FEATURE_ID}}: "{{FEATU
 
 **CRITICAL**: You MUST NOT exit until ALL work is complete and committed.
 
-**Tier 1 — Single Agent**: You handle everything directly. No normal work subagents; the log-size monitor is the only allowed persistent background subagent. No TeamCreate.
+**Tier 1 — Single Agent**: You handle everything directly. No normal work subagents. No TeamCreate.
 
 ### Feature Description
 
@@ -51,6 +51,11 @@ You are running in **headless non-interactive mode** with a FINITE context windo
 5. **Minimize tool output** — Never load full command output into context. First capture to a temp file (`cmd 2>&1 | tee /tmp/out.txt | tail -20`), then scan the head/tail to identify relevant fields, and use targeted filtering (`grep`, `sed`, `awk`) to extract only the information needed for the current task. Only read the filtered result — never the raw full output.
 6. **No intermediate commits** — Do NOT run `git add`/`git commit` during Phase 1-3. All changes are committed once at the end in Phase 4 via `/prizmkit-committer`.
 7. **Capture test output once** — When running test suites, always use `($TEST_CMD) 2>&1 | tee /tmp/test-out.txt | tail -20`. Then grep `/tmp/test-out.txt` for details. Never re-run the suite just to apply a different filter.
+8. **Scaffold / generated file awareness** — Files created by scaffolding tools (`npm init`, `npx create-*`, etc.) are boilerplate. Tag them, record in context-snapshot.md, and NEVER re-read them. If you need to modify one, edit directly without reading first.
+9. **Package version verification (BLOCKING)** — Before writing ANY dependency version, verify it exists via registry query (`npm view <pkg> dist-tags.latest`, `pip index versions <pkg>`, etc.). NEVER guess version numbers.
+10. **Build artifact hygiene** — After build/compile, ensure output is in `.gitignore`. Never commit binaries/build output.
+11. **Anti re-read hard rule (BLOCKING)** — Once you have read a file into context, do NOT read the full file again. Use `grep -n '<pattern>' <file>` or `sed -n '<start>,<end>p' <file>` for specific lines. **20-step window**: full Read forbidden within 20 tool calls of last read. **3-strike**: 3 full Reads of same file → report BLOCKED. Applies to orchestrator AND subagents.
+12. **Read offset safety (BLOCKING)** — If Read returns "shorter than offset"/"File is empty"/"Wasted call" — do NOT retry same offset. Run `wc -l <file>` to get real line count, then `sed -n` for exact range. 2 consecutive offset errors → STOP Reading that file. Never guess offsets — `grep -n '<anchor>'` first.
 
 ---
 
@@ -145,13 +150,15 @@ You know this project's tech stack. Identify ALL test commands that apply (e.g.,
 - Runs tests using `TEST_CMD` after each task
 - Writes '## Implementation Log' to `context-snapshot.md`
 
-**3b-compact.** Context management — if plan.md has more than 5 tasks, run `/compact` after completing every 3 tasks during implementation. This prevents context window exhaustion in long sessions. If `/compact` is not available (non-Claude CLI), skip this step.
+**3b-checkpoint.** Context management — if plan.md has more than 5 tasks, update durable checkpoints/artifacts after every 3 tasks, minimize output, and continue. If context overflow occurs in a headless run, the runner starts a fresh continuation session from those checkpoints and artifacts. In an interactive Claude Code session operated manually outside the headless pipeline, `/compact` may be used as an optional convenience only.
 
 **3c.** After implement completes, verify:
 1. All tasks in plan.md are `[x]`
-2. Run the full test suite to ensure nothing is broken
-3. Verify each acceptance criterion from Section 1 of context-snapshot.md is met — check mentally, do NOT re-read files you already wrote
-4. If any criterion is not met, fix it now using the convergence-based recovery loop below
+2. **Verification Gate Self-Check**: for each acceptance criterion, write one line of evidence (test name / file:line / fixture path). Any gate without evidence is BLOCKED, not success.
+3. **Layered test strategy**: debug with single-file tests (`npx vitest run <file> -t '<name>'`), only run full suite as gate when single-file is green. Never run full suite while a single-file test is still red.
+4. Run the full test suite to ensure nothing is broken
+5. Verify each acceptance criterion from Section 1 of context-snapshot.md is met — check mentally, do NOT re-read files you already wrote
+6. If any criterion is not met, fix it now using the convergence-based recovery loop below
 
 **CP-2**: All acceptance criteria met, all tests pass.
 
@@ -165,6 +172,8 @@ When tests fail, use convergence recovery — keep fixing while progress is bein
 
 **Key rule**: If failures decrease (even by 1), plateau counter resets. Do NOT block commit for unresolved failures — document and defer to next session.
 
+**Hard Round Cap (BLOCKING)**: After **6 total test-fix rounds**, STOP trial-and-error. Write failure-log listing all hypotheses tried. Switch to: read full relevant source section ONCE (via `grep -n`+`sed -n`, never full Read), understand control flow, rewrite failing block in one shot. Do NOT exceed 7 total rounds.
+
 
 ### Scoped Feature Test Gate — PrizmKit Test
 

package/bundled/dev-pipeline/templates/bootstrap-tier2.md

@@ -10,7 +10,7 @@
 
 You are the **session orchestrator**. Implement Feature {{FEATURE_ID}}: "{{FEATURE_TITLE}}".
 
-**CRITICAL**: You MUST NOT exit until ALL work is complete and committed. When you spawn normal work subagents, wait for each to finish (run_in_background=false). The log-size monitor is the only allowed persistent background subagent.
+**CRITICAL**: You MUST NOT exit until ALL work is complete and committed. When you spawn normal work subagents, wait for each to finish (run_in_background=false).
 
 **Tier 2 — Dual Agent**: You handle context + planning directly. Then spawn Dev and Reviewer subagents. Spawn Dev and Reviewer agents via the Agent tool.
 
@@ -57,6 +57,11 @@ You are running in **headless non-interactive mode** with a FINITE context windo
 5. **Minimize tool output** — Never load full command output into context. First capture to a temp file (`cmd 2>&1 | tee /tmp/out.txt | tail -20`), then scan the head/tail to identify relevant fields, and use targeted filtering (`grep`, `sed`, `awk`) to extract only the information needed for the current task. Only read the filtered result — never the raw full output.
 6. **No intermediate commits** — Do NOT run `git add`/`git commit` during Phase 1-5. All changes are committed once at the end in Phase 6 via `/prizmkit-committer`.
 7. **Capture test output once** — When running test suites, always use `($TEST_CMD) 2>&1 | tee /tmp/test-out.txt | tail -20`. Then grep `/tmp/test-out.txt` for details. Never re-run the suite just to apply a different filter.
+8. **Scaffold / generated file awareness** — Files created by scaffolding tools are boilerplate. Tag them, record in context-snapshot.md, NEVER re-read. Edit directly without reading first.
+9. **Package version verification (BLOCKING)** — Verify dependency versions via registry query before writing them. NEVER guess.
+10. **Build artifact hygiene** — After build/compile, ensure output is in `.gitignore`.
+11. **Anti re-read hard rule (BLOCKING)** — Once you have read a file into context, do NOT read the full file again. Use `grep -n '<pattern>' <file>` or `sed -n '<start>,<end>p' <file>` for specific lines. **20-step window**: full Read forbidden within 20 tool calls of last read. **3-strike**: 3 full Reads of same file → report BLOCKED. Applies to orchestrator AND subagents — subagents re-reading files in context-snapshot.md Section 4 are wasting context.
+12. **Read offset safety (BLOCKING)** — If Read returns "shorter than offset"/"File is empty"/"Wasted call" — do NOT retry same offset. Run `wc -l <file>` to get real line count, then `sed -n` for exact range. 2 consecutive offset errors → STOP Reading that file. Never guess offsets — `grep -n '<anchor>'` first.
 
 ---
 
@@ -276,10 +281,15 @@ Prompt:
 > ⚠️ DO NOT re-read source files already listed in Section 4 File Manifest unless you need implementation detail beyond the interface summary.
 > 1. Read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` for full context.
 > 2. Run `/prizmkit-implement` to execute the tasks in plan.md. Run tests with: `{{TEST_CMD}}`. Known baseline failures (pre-existing, not your fault): `{{BASELINE_FAILURES}}`.
-> 3. If plan.md has more than 5 tasks: run `/compact` after completing every 3 tasks to manage context budget. If `/compact` is unavailable, continue without it.
-> 4. After implement completes, verify the '## Implementation Log' section was written to context-snapshot.md.
-> 5. Do NOT execute any git commands (no git add/commit/reset/push).
-> Do NOT exit until all tasks are [x] and the '## Implementation Log' section is written in context-snapshot.md."
+> 3. If plan.md has more than 5 tasks: update durable checkpoints/artifacts after every 3 tasks, minimize output, and rely on runner continuation if context overflow occurs. In an interactive Claude Code session operated manually outside the headless pipeline, `/compact` may be used as an optional convenience only.
+> 4. **Verification Gate Self-Check (BLOCKING)**: before returning, write a `### Gate Evidence` section to Implementation Log — one evidence line per gate (test name / file:line / fixture path). Any gate without evidence is BLOCKED, not success.
+> 5. **Layered test strategy**: debug with single-file tests (`npx vitest run <file> -t '<name>'`), only run full suite as gate when single-file is green. Never run full suite while a single-file test is still red.
+> 6. **Anti re-read**: 20-step window (full Read forbidden within 20 tool calls of last read), 3-strike (3 full Reads same file → BLOCKED). Use `grep -n`+`sed -n` for specific lines.
+> 7. **Read offset safety**: if Read returns "shorter than offset"/"empty"/"wasted" — run `wc -l` then `sed -n`, do NOT retry same offset. 2 consecutive → STOP Reading that file.
+> 8. **Hard Round Cap**: after 6 total test-fix rounds, STOP trial-and-error. Write failure-log. Switch to read-once-then-rewrite strategy. Do NOT exceed 7 rounds.
+> 9. After implement completes, verify the '## Implementation Log' section (with Gate Evidence) was written to context-snapshot.md.
+> 10. Do NOT execute any git commands (no git add/commit/reset/push).
+> Do NOT exit until all tasks are [x] and the '## Implementation Log' section (with Gate Evidence) is written in context-snapshot.md."
 
 Wait for Dev to return. All tasks must be `[x]`, tests pass.
 
@@ -604,7 +614,7 @@ If you encounter an unrecoverable error, context overflow, or are about to exit
 - Build context-snapshot.md FIRST; all subagents read it instead of re-reading source files
 - context-snapshot.md is append-only: orchestrator writes Sections 1-4, Dev appends Implementation Log, Reviewer appends Review Notes
 - Gate checks enforce Implementation Log and Review Notes are written before proceeding
-- Do NOT use `run_in_background=true` when spawning normal work subagents; the log-size monitor is the only allowed persistent background subagent
+- Do NOT use `run_in_background=true` when spawning normal work subagents
 - **NEVER delete, modify, or touch any file under `.prizmkit/state/`** — those are pipeline runtime files managed by the runner
 - NEVER run `rm -rf`, `git clean`, or any destructive filesystem operations
 - `/prizmkit-committer` is mandatory, and must not be replaced with manual git commit commands

package/bundled/dev-pipeline/templates/bootstrap-tier3.md

@@ -10,7 +10,7 @@
 
 You are the **session orchestrator**. Implement Feature {{FEATURE_ID}}: "{{FEATURE_TITLE}}".
 
-**CRITICAL**: You MUST NOT exit until ALL work is complete and committed. When you spawn normal work subagents, wait for each to finish (run_in_background=false). The log-size monitor is the only allowed persistent background subagent. Do NOT spawn work agents in background and exit — that kills the session.
+**CRITICAL**: You MUST NOT exit until ALL work is complete and committed. When you spawn normal work subagents, wait for each to finish (run_in_background=false). Do NOT spawn work agents in background and exit — that kills the session.
 
 **Tier 3 — Full Team**: For complex features, use the full pipeline (Phase 0–6) with Dev + Reviewer agents spawned via the Agent tool.
 
@@ -57,6 +57,11 @@ You are running in **headless non-interactive mode** with a FINITE context windo
 5. **Minimize tool output** — Never load full command output into context. First capture to a temp file (`cmd 2>&1 | tee /tmp/out.txt | tail -20`), then scan the head/tail to identify relevant fields, and use targeted filtering (`grep`, `sed`, `awk`) to extract only the information needed for the current task. Only read the filtered result — never the raw full output.
 6. **No intermediate commits** — Do NOT run `git add`/`git commit` during Phase 1-5. All changes are committed once at the end in Phase 6 via `/prizmkit-committer`.
 7. **Batch independent operations** — Issue multiple independent `Write`/`Read` calls in a single message turn when they have no dependencies. Combine multiple `mkdir -p` into one command. Never run `npm test` twice just to apply a different grep filter — capture output to `/tmp/test-out.txt` once and grep the file.
+8. **Scaffold / generated file awareness** — Files created by scaffolding tools are boilerplate. Tag them, record in context-snapshot.md, NEVER re-read. Edit directly without reading first.
+9. **Package version verification (BLOCKING)** — Verify dependency versions via registry query before writing them. NEVER guess.
+10. **Build artifact hygiene** — After build/compile, ensure output is in `.gitignore`.
+11. **Anti re-read hard rule (BLOCKING)** — Once you have read a file into context, do NOT read the full file again. Use `grep -n '<pattern>' <file>` or `sed -n '<start>,<end>p' <file>` for specific lines. **20-step window**: full Read forbidden within 20 tool calls of last read. **3-strike**: 3 full Reads of same file → report BLOCKED. Applies to orchestrator AND subagents.
+12. **Read offset safety (BLOCKING)** — If Read returns "shorter than offset"/"File is empty"/"Wasted call" — do NOT retry same offset. Run `wc -l <file>` to get real line count, then `sed -n` for exact range. 2 consecutive offset errors → STOP Reading that file. Never guess offsets — `grep -n '<anchor>'` first.
 
 ---
 
@@ -284,10 +289,15 @@ Prompt:
 > ⚠️ DO NOT re-read source files already listed in Section 4 File Manifest unless you need implementation detail beyond the interface summary.
 > 1. Read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` for full context.
 > 2. Run `/prizmkit-implement` to execute the tasks in plan.md. Run tests with: `{{TEST_CMD}}`. Known baseline failures (pre-existing, not your fault): `{{BASELINE_FAILURES}}`.
-> 3. If plan.md has more than 5 tasks: run `/compact` after completing every 3 tasks to manage context budget. If `/compact` is unavailable, continue without it.
-> 4. After implement completes, verify the '## Implementation Log' section was written to context-snapshot.md.
-> 5. Do NOT execute any git commands (no git add/commit/reset/push).
-> Do NOT exit until all tasks are [x] and the '## Implementation Log' section is written in context-snapshot.md."
+> 3. If plan.md has more than 5 tasks: update durable checkpoints/artifacts after every 3 tasks, minimize output, and rely on runner continuation if context overflow occurs. In an interactive Claude Code session operated manually outside the headless pipeline, `/compact` may be used as an optional convenience only.
+> 4. **Verification Gate Self-Check (BLOCKING)**: before returning, write a `### Gate Evidence` section to Implementation Log — one evidence line per gate (test name / file:line / fixture path). Any gate without evidence is BLOCKED, not success.
+> 5. **Layered test strategy**: debug with single-file tests (`npx vitest run <file> -t '<name>'`), only run full suite as gate when single-file is green. Never run full suite while a single-file test is still red.
+> 6. **Anti re-read**: 20-step window (full Read forbidden within 20 tool calls of last read), 3-strike (3 full Reads same file → BLOCKED). Use `grep -n`+`sed -n` for specific lines.
+> 7. **Read offset safety**: if Read returns "shorter than offset"/"empty"/"wasted" — run `wc -l` then `sed -n`, do NOT retry same offset. 2 consecutive → STOP Reading that file.
+> 8. **Hard Round Cap**: after 6 total test-fix rounds, STOP trial-and-error. Write failure-log. Switch to read-once-then-rewrite strategy. Do NOT exceed 7 rounds.
+> 9. After implement completes, verify the '## Implementation Log' section (with Gate Evidence) was written to context-snapshot.md.
+> 10. Do NOT execute any git commands (no git add/commit/reset/push).
+> Do NOT exit until all tasks are [x] and the '## Implementation Log' section (with Gate Evidence) is written in context-snapshot.md."
 
 **Gate Check — Implementation Log**:
 After Dev agent returns, verify the Implementation Log was written:
@@ -638,7 +648,7 @@ If you encounter an unrecoverable error, context overflow, or are about to exit
 - Tier 3: full team — Dev (implementation) → Reviewer (review) — spawn agents directly via Agent tool
 - context-snapshot.md is append-only: orchestrator writes Sections 1-4, Dev appends Implementation Log, Reviewer appends Review Notes
 - Gate checks enforce Implementation Log and Review Notes are written before proceeding
-- Do NOT use `run_in_background=true` when spawning normal work agents; the log-size monitor is the only allowed persistent background subagent
+- Do NOT use `run_in_background=true` when spawning normal work agents
 - Commit phase must use `/prizmkit-committer`; do NOT replace with manual git commit commands
 - **NEVER delete, modify, or touch any file under `.prizmkit/state/`** — those are pipeline runtime files managed by the runner
 - NEVER run `rm -rf`, `git clean`, or any destructive filesystem operations

package/bundled/dev-pipeline/templates/bugfix-bootstrap-prompt.md

@@ -13,7 +13,7 @@ You are the **bug fix session agent**. Fix Bug {{BUG_ID}}: "{{BUG_TITLE}}".
 
 **CRITICAL**: You MUST NOT exit until ALL work is complete and committed.
 
-**SUBAGENT LIFECYCLE**: The log-size monitor is the only allowed persistent background subagent. Any normal work subagent must be awaited with `run_in_background=false`.
+**SUBAGENT LIFECYCLE**: Any normal work subagent must be awaited with `run_in_background=false`. Do not spawn persistent background subagents for headless recovery.
 
 **NON-INTERACTIVE MODE**: There is NO human on the other end. NEVER ask for user confirmation, NEVER wait for user input. Make decisions autonomously and move forward.
 

package/bundled/dev-pipeline/templates/refactor-bootstrap-prompt.md

@@ -12,7 +12,7 @@
 
 You are the **refactor session orchestrator**. Execute Refactor {{REFACTOR_ID}}: "{{REFACTOR_TITLE}}".
 
-**CRITICAL SESSION LIFECYCLE RULE**: You MUST NOT exit until ALL work is complete and session-status.json is written. When you spawn normal work subagents, you MUST **wait for each to finish** (run_in_background=false) before proceeding. The log-size monitor is the only allowed persistent background subagent. Do NOT spawn a work agent in the background and exit — that kills the session.
+**CRITICAL SESSION LIFECYCLE RULE**: You MUST NOT exit until ALL work is complete and session-status.json is written. When you spawn normal work subagents, you MUST **wait for each to finish** (run_in_background=false) before proceeding. Do NOT spawn a work agent in the background and exit — that kills the session.
 
 **NON-INTERACTIVE MODE**: You are running in headless non-interactive mode. There is NO human on the other end. NEVER ask for user confirmation, NEVER wait for user input, NEVER use interactive prompts (e.g. "Would you like me to…"). If a skill has an interactive step (e.g. offer remediation, ask for approval), skip it and proceed autonomously. Make decisions based on the data available and move forward.
 
@@ -185,7 +185,7 @@ Evidence must cover affected UI render, primary user interactions, behavior-sens
 
 {{END_IF_BROWSER_INTERACTION}}
 
-  7. If the refactor involves multiple files: run `/compact` after completing half the tasks to free context budget. If `/compact` is unavailable, continue without it.
+  7. If the refactor involves multiple files: update durable checkpoints/artifacts at the midpoint, minimize output, and rely on runner continuation if context overflow occurs. In an interactive Claude Code session operated manually outside the headless pipeline, `/compact` may be used as an optional convenience only.
   8. After all tasks complete, run the full test suite one final time
   "
 - **Wait for Dev to return**
@@ -337,4 +337,4 @@ Write to: `{{SESSION_STATUS_PATH}}`
 - **Commit with** `refactor(<scope>):` prefix, NOT `feat:` or `fix:`
 - **Run full retrospective** (Job 1 + Job 2) — refactoring changes code structure
 - ALWAYS write session-status.json before exiting
-- Do NOT use `run_in_background=true` when spawning normal work agents; the log-size monitor is the only allowed persistent background subagent
+- Do NOT use `run_in_background=true` when spawning normal work agents

package/bundled/dev-pipeline/templates/sections/context-budget-rules.md

@@ -32,3 +32,5 @@ You are running in **headless non-interactive mode** with a FINITE context windo
    - **This is a BLOCKING gate**: do NOT run `npm install` / `pip install` / `cargo build` / `go mod tidy` until ALL versions in the manifest have been verified or use open constraints
    - Batch version lookups: query multiple packages in parallel to save time (e.g., run multiple `npm view` commands concurrently)
 10. **Build artifact hygiene** — After any build/compile command (`go build`, `npm run build`, `tsc`, etc.), ensure the output binary, build directory, generated bundle, or cache directory is ignored by git before the commit phase. Never commit compiled binaries, build output, or generated artifacts.
+11. **Anti re-read hard rule (BLOCKING)** — Re-reading the same file is the #1 context burner in long sessions. Once you have read a file into context (directly or via context-snapshot.md Section 4), do NOT read the full file again. Instead use `grep -n '<pattern>' <file>` or `sed -n '<start>,<end>p' <file>` for specific lines. **20-step window**: full Read forbidden within 20 tool calls of last read. **3-strike**: 3 full Reads of same file → report BLOCKED. Never full-file Read a file already summarized in context-snapshot.md Section 4.
+12. **Read offset safety (BLOCKING)** — If Read returns "shorter than offset"/"File is empty"/"Wasted call" — do NOT retry same offset. Run `wc -l <file>` to get real line count, then `sed -n` for exact range. 2 consecutive offset errors → STOP Reading that file. Never guess offsets — `grep -n '<anchor>'` first.

package/bundled/dev-pipeline/templates/sections/log-size-awareness.md

@@ -1,76 +1,20 @@
-## Session Log Budget Monitoring (PROACTIVE)
+## Session Log Budget Awareness (CHECKPOINT GUIDANCE)
 
-Your session log grows with every tool call and subagent spawn.
-To prevent context exhaustion, **spawn a background monitoring subagent at session start**.
+This section provides passive checkpoint guidance for checkpoint/continuation only. Context-saving rules (anti re-read, output filtering) live in Context Budget Rules above — do not duplicate.
 
-### How to Set Up the Monitor
+### Checkpoint Before Large Work Batches
 
-1. **AS THE VERY FIRST ACTION** (before Phase 0), spawn a monitoring subagent
-   with `run_in_background: true` and this task:
+- `MAX_LOG_SIZE` controls whether this advisory section is included.
+- Before major phases or large task batches, update durable artifacts: plan/task checkboxes, context snapshots, implementation/review notes, workflow checkpoints, session status, test reports.
+- Checkpoint often so automatic continuation can resume from durable state.
 
-   ```
-   Run this command and keep it running:
-   bash {{LOG_MONITOR_SCRIPT}} {{SESSION_LOG_PATH}} {{MAX_LOG_SIZE}} {{LOG_MONITOR_POLL_INTERVAL}} {{LOG_MONITOR_STATUS_FILE}} {{LOG_MONITOR_BASELINE_FILE}}
-   ```
+### Headless Recovery Source of Truth
 
-   The subagent MUST use `run_in_background: true`. It writes a JSON status
-   file every {{LOG_MONITOR_POLL_INTERVAL}} seconds.
+- Headless recovery must rely on durable checkpoints and artifacts, not interactive slash commands.
+- If context overflow occurs, the runner detects it and starts a fresh continuation session from checkpoint files and durable artifacts.
+- Durable checkpoint files are the source of truth for what was completed, what remains, and which gates were already run.
 
-2. **BEFORE EACH MAJOR PHASE** (Phase 0, 1, 2, ...), read the status:
+### Interactive Claude Code Note
 
-   ```bash
-   cat {{LOG_MONITOR_STATUS_FILE}} 2>/dev/null || echo '{"status":"OK"}'
-   ```
-
-   The status file contains structured diagnostics:
-
-   ```json
-   {
-     "status": "OK | COMPACT_NEEDED",
-     "total_bytes": <current session.log size>,
-     "baseline_bytes": <size after last /compact>,
-     "effective_bytes": <total - baseline, incremental growth>,
-     "threshold_bytes": <{{MAX_LOG_SIZE}}>,
-     "overage_bytes": <effective - threshold, 0 when OK>,
-     "usage_pct": <effective / threshold * 100>
-   }
-   ```
-
-   Extract fields for decision-making:
-   ```bash
-   status=$(jq -r '.status' {{LOG_MONITOR_STATUS_FILE}})
-   effective=$(jq -r '.effective_bytes' {{LOG_MONITOR_STATUS_FILE}})
-   overage=$(jq -r '.overage_bytes' {{LOG_MONITOR_STATUS_FILE}})
-   usage=$(jq -r '.usage_pct' {{LOG_MONITOR_STATUS_FILE}})
-   ```
-
-3. **On COMPACT_NEEDED** (effective_bytes > {{MAX_LOG_SIZE}} bytes, {{MAX_LOG_SIZE_HUMAN}}):
-   - Check `overage_bytes` to decide urgency:
-     - **Minor overage** (< 512KB): complete the current sub-step, update durable workflow checkpoint artifacts, write baseline, `/compact`
-     - **Major overage** (>= 512KB): update durable workflow checkpoint artifacts, write baseline, `/compact` — do NOT start new work
-   - Write baseline before `/compact`:
-     ```bash
-     wc -c < {{SESSION_LOG_PATH}} > {{LOG_MONITOR_BASELINE_FILE}}
-     ```
-   - Execute `/compact`
-   - Continue the workflow after `/compact`; re-read this status file before the next major phase
-
-### How the Baseline Prevents Infinite Compaction Loops
-
-- Before the first `/compact`: baseline = 0, effective = full log size → triggers when log exceeds threshold
-- After `/compact`: baseline = current log size, effective ≈ 0 → status resets to OK
-- The monitor only triggers again when **new** log growth since the last compact exceeds the threshold
-- Each `/compact` resets the baseline, breaking the infinite loop
-
-### Log Growth Reduction Tips
-
-- **Re-read context-snapshot.md instead of source files** — already in context
-- **Filter command output** — pipe to `tail -20` or `grep`, never full output
-- **Limit subagent prompts** — shorter, focused prompts = shorter transcripts
-- **Checkpoint often** — update durable workflow checkpoint artifacts before `/compact`
-
-### What Survives
-
-- All git commits are permanent
-- The workflow checkpoint is preserved and auto-resumed
-- `/compact` compresses context without losing progress
+- `/compact` may help when a human is manually operating an interactive Claude Code session.
+- `/compact` is optional interactive convenience only — not required for headless recovery.

package/bundled/dev-pipeline/templates/sections/phase-context-snapshot-agent-suffix.md

@@ -1,14 +1,22 @@
    - **Section 3 — Key TRAPS & RULES**: extract only relevant TRAPS/RULES from prizm-docs. Do NOT copy full L0/L1/L2 content — the orchestrator already loaded them.
-   - **Section 4 — File Manifest**: For each file relevant to this feature, list: file path, why it's needed (modify/reference/test), key interface signatures (function names + params + return types). Do NOT include full file content — agents read files on-demand. Format:
+   - **Section 4 — File Manifest**: For each file, list: path, why needed, and a **key-content summary** so you do NOT need to re-read the file. Format depends on file type:
+     - **Code files** (JS/TS/Python/Go): function signatures. Example: `config` (Zod object), `loadConfig(path)→Config`.
+     - **Shell scripts** (`.sh`): command-line args, key behavior branches, sourced libs, critical line ranges. Example: `args: --feature-id; sources lib/common.sh; lines 120-180 worktree logic`.
+     - **Config/manifest** (`package.json`, `tsconfig.json`, `.env`): key scripts/fields/deps/env vars. Example: `scripts:{dev,test}, deps:{vitest}, env:USE_WORKTREE`.
+     - **Docs/README**: section headings + 2-3 relevant sections only.
+     - **Test files**: test names + what each tests (1 line each).
+     Format:
      ### Files to Modify
-     | File | Why Needed | Key Interfaces |
-     |------|-----------|----------------|
-     | `<source-dir>/config.js` | Add runtime config layer | `config` (Zod object), `configSchema` |
+     | File | Why Needed | Key Content Summary |
+     |------|-----------|---------------------|
+     | `<src>/config.js` | Add config layer | `config`, `configSchema`, `loadConfig(p)→Config` |
+     | `dev-pipeline/run-feature.sh` | Remove shell entry | args:--feature-id; lines 120-180 worktree |
 
      ### Files for Reference
-     | File | Why Needed | Key Interfaces |
-     |------|-----------|----------------|
-     | `<source-dir>/security/permission-guard.js` | Permission check integration | `checkCommandPermission(userId, cmd)` |
+     | File | Why Needed | Key Content Summary |
+     |------|-----------|---------------------|
+     | `<src>/permission-guard.js` | Perm check | `checkPermission(uid,cmd)→bool` |
+     | `package.json` | Test cmd+deps | scripts:{test:vitest}, deps:{vitest} |
 
      ### Known TRAPS (from .prizmkit/prizm-docs/)
      - <trap entries extracted from L1/L2 docs>

package/bundled/dev-pipeline/templates/sections/phase-implement-agent.md

@@ -1,40 +1,53 @@
-### Implement — Dev Subagent
+### Implement — Orchestrator Direct (no Dev subagent)
 
-**Protocol handoff to Dev**: The Dev prompt already carries the required subset of Context Budget Rules, the Test Failure Recovery Protocol, and Task Contract / Verification Gate constraints. Do not duplicate those rules here; verify Dev output against the gates below.
+**Rationale**: Development is deterministic plan execution — the orchestrator already built full context in Phase 1. Spawning a Dev subagent forces it to rebuild context (re-reading files the orchestrator already read), wastes context, and risks worktree double-edit. The orchestrator implements directly.
 
-**Spawn Agent**:
-| Parameter | Value |
-|-----------|-------|
-| subagent_type | prizm-dev-team-dev |
-| run_in_background | false |
-| isolation | Leave empty — Dev works directly in the repo, no worktree |
-
-**Agent spawn failure policy**:
-- If spawning Dev fails with team/config/lock errors, retry at most once.
-- If the second attempt fails, do not enter Implementation Log polling or repeated recovery spawn loops.
-- Use the documented inline/recovery fallback: write `failure-log.md` with the spawn error and last observable state, then either complete remaining tasks directly in the orchestrator or stop with a clear failure for recovery.
-- Apply the same cap to Dev re-spawns for Implementation Log repair or resume prompts; do not burn multiple minutes on identical team/config/lock failures.
-
-**Prompt**:
-> {{AGENT_PROMPT_DEV_IMPLEMENT}}
-
-Wait for Dev to return. Implementation may proceed only when tasks are complete and the Test Failure Recovery Protocol's Success Rule is satisfied.
+Before starting, check plan.md Tasks:
+```bash
+grep -c '^\- \[ \]' .prizmkit/specs/{{FEATURE_SLUG}}/plan.md 2>/dev/null || true
+```
+- If result is `0` (all tasks already `[x]`) → **SKIP to Review**.
+- If non-zero → implement directly below.
 
-**No silent artifact polling**:
-- Do NOT run a long no-output loop that only waits for `## Implementation Log` or any other file marker.
-- If you must wait for Dev after spawning or sending a status request, use short bounded checks (≤120s) that print a heartbeat line each iteration with: elapsed time, remaining unchecked task count, whether `## Implementation Log` exists, and whether `git diff --stat` changed.
-- If Dev has no transcript/file/diff progress for one bounded check, send one status request. If there is still no progress on the next bounded check, stop waiting, write `failure-log.md` with the last observable state, and follow Subagent Timeout Recovery.
-- Prefer the Agent tool's completion notification or Dev's `COMPLETION_SIGNAL`; file presence alone is not a liveness signal.
+**Build artifacts rule**: After any build/compile command, ensure output is in `.gitignore`. Never commit binaries/build output.
 
-**Gate Check — Implementation Log**:
-After Dev agent returns, verify the Implementation Log was written:
+**3a.** Detect test commands and record baseline:
 ```bash
-grep -q "## Implementation Log" .prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md && echo "GATE:PASS" || echo "GATE:MISSING"
+($TEST_CMD) 2>&1 | tee /tmp/test-baseline.txt | tail -20
 ```
-If GATE:MISSING — send message to Dev (re-spawn if needed): "Write the '## Implementation Log' section to context-snapshot.md before I can proceed to review. Include: files changed/created, key decisions, deviations from plan, notable discoveries."
 
+**3b.** Run `/prizmkit-implement` directly — you (the orchestrator) execute the full cycle:
+- Read plan.md Tasks from `.prizmkit/specs/{{FEATURE_SLUG}}/`
+- Use context-snapshot.md Section 4 File Manifest for targeted reads — do NOT re-read files already summarized there
+- Implement task-by-task with TDD, marking each `[x]` immediately
+- Creates/updates L2 `.prizm` docs when creating new modules
+- Runs tests using `TEST_CMD`
+- If plan.md has >5 tasks: update checkpoints after every 3 tasks
+
+**3c. Layered test strategy** (replaces "run full suite every 3 Edits"):
+- Debugging a single test: `npx vitest run <test-file> -t '<test name>'` (or per-stack equivalent). Capture to `/tmp/test-out.txt`, grep for failures.
+- Only when single-file is green, run ONE full `{{TEST_CMD}}` as the gate.
+- Never run full suite while a single-file test is still red.
+
+**3d. Verification Gate Self-Check (BLOCKING — before declaring implement done)**:
+For each Verification Gate from the Task Contract, write one evidence line to Implementation Log:
+```
+### Gate Evidence
+- [x] G1: <gate text> — Evidence: <test name / file:line / fixture path>
+- [ ] G3: <gate text> — BLOCKED: <reason>  ← no evidence = BLOCKED, not success
+```
+
+**3e.** Append `## Implementation Log` (with Gate Evidence) to `context-snapshot.md`:
+- files changed/created
+- key decisions
+- deviations from plan
+- test results
+- Gate Evidence section
+- unresolved blockers
+
+**CP-2**: All tasks `[x]`, Implementation Log written with Gate Evidence, Test Failure Recovery Protocol's Success Rule satisfied. Blocked gates → `failure-log.md`, not success.
 
-**Checkpoint update**: Run the update script to set step `prizmkit-implement` to `"completed"`:
+**Checkpoint update**:
 ```bash
 python3 $PIPELINE_DIR/scripts/update-checkpoint.py \
   --checkpoint-path {{CHECKPOINT_PATH}} \

package/bundled/dev-pipeline/templates/sections/phase-implement-full.md

@@ -1,52 +1,54 @@
-### Implement — Dev Agent
+### Implement — Orchestrator Direct (no Dev subagent)
 
-**Protocol handoff to Dev**: The Dev prompt already carries the required subset of Context Budget Rules, the Test Failure Recovery Protocol, and Task Contract / Verification Gate constraints. Do not duplicate those rules here; verify Dev output against the gates below.
+**Rationale**: Development is deterministic plan execution — the orchestrator already built full context in Phase 1-2. Spawning a Dev subagent forces it to rebuild context (re-reading files the orchestrator already read), wastes context, and risks worktree double-edit. The orchestrator implements directly.
 
-Before spawning Dev, check plan.md Tasks section:
+Before starting, check plan.md Tasks:
 ```bash
 grep -c '^\- \[ \]' .prizmkit/specs/{{FEATURE_SLUG}}/plan.md 2>/dev/null || true
 ```
-- If result is `0` (all tasks already `[x]`) → **SKIP this phase**, go directly to Review. Do NOT spawn Dev.
-- If result is non-zero → spawn Dev agent below.
-
-**Spawn Agent**:
-| Parameter | Value |
-|-----------|-------|
-| subagent_type | prizm-dev-team-dev |
-| run_in_background | false |
-
-**Agent spawn failure policy**:
-- If spawning Dev fails with team/config/lock errors, retry at most once.
-- If the second attempt fails, do not enter Implementation Log polling or repeated recovery spawn loops.
-- Use the documented inline/recovery fallback: write `failure-log.md` with the spawn error and last observable state, then either complete remaining tasks directly in the orchestrator or stop with a clear failure for recovery.
-- Apply the same cap to Dev re-spawns for Implementation Log repair or resume prompts; do not burn multiple minutes on identical team/config/lock failures.
-
-**Prompt**:
-> {{AGENT_PROMPT_DEV_IMPLEMENT}}
-
-**No silent artifact polling**:
-- Do NOT run a long no-output loop that only waits for `## Implementation Log` or any other file marker.
-- If you must wait for Dev after spawning or sending a status request, use short bounded checks (≤120s) that print a heartbeat line each iteration with: elapsed time, remaining unchecked task count, whether `## Implementation Log` exists, and whether `git diff --stat` changed.
-- If Dev has no transcript/file/diff progress for one bounded check, send one status request. If there is still no progress on the next bounded check, stop waiting, write `failure-log.md` with the last observable state, and follow Subagent Timeout Recovery.
-- Prefer the Agent tool's completion notification or Dev's `COMPLETION_SIGNAL`; file presence alone is not a liveness signal.
-
-**Gate Check — Implementation Log**:
-After Dev agent returns, verify the Implementation Log was written:
+- If result is `0` (all tasks already `[x]`) → **SKIP to Review**.
+- If non-zero → implement directly below.
+
+**Build artifacts rule**: After any build/compile command, ensure output is in `.gitignore`. Never commit binaries/build output.
+
+**3a.** Detect test commands and record baseline:
 ```bash
-grep -q "## Implementation Log" .prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md && echo "GATE:PASS" || echo "GATE:MISSING"
+($TEST_CMD) 2>&1 | tee /tmp/test-baseline.txt | tail -20
+```
+Save pre-existing failing tests as `BASELINE_FAILURES`.
+
+**3b.** Run `/prizmkit-implement` directly — you (the orchestrator) execute the full cycle:
+- Read plan.md Tasks from `.prizmkit/specs/{{FEATURE_SLUG}}/`
+- Use context-snapshot.md Section 4 File Manifest for targeted reads — do NOT re-read files already summarized there
+- Implement task-by-task with TDD, marking each `[x]` immediately
+- Creates/updates L2 `.prizm` docs when creating new modules
+- Runs tests using `TEST_CMD`
+- If plan.md has >5 tasks: update checkpoints after every 3 tasks
+
+**3c. Layered test strategy** (replaces "run full suite every 3 Edits"):
+- Debugging a single test: `npx vitest run <test-file> -t '<test name>'` (or per-stack equivalent). Capture to `/tmp/test-out.txt`, grep for failures.
+- Only when single-file is green, run ONE full `{{TEST_CMD}}` as the gate.
+- Never run full suite while a single-file test is still red.
+
+**3d. Verification Gate Self-Check (BLOCKING — before declaring implement done)**:
+For each Verification Gate from the Task Contract, write one evidence line to Implementation Log:
+```
+### Gate Evidence
+- [x] G1: <gate text> — Evidence: <test name / file:line / fixture path>
+- [ ] G3: <gate text> — BLOCKED: <reason>  ← no evidence = BLOCKED, not success
 ```
-If GATE:MISSING — send message to Dev (re-spawn if needed): "Write the '## Implementation Log' section to context-snapshot.md before I can proceed to review. Include: files changed/created, key decisions, deviations from plan, notable discoveries."
-
-Wait for Dev to return. **If Dev times out before all tasks are `[x]`**:
-1. Check progress: `grep -c '^\- \[ \]' .prizmkit/specs/{{FEATURE_SLUG}}/plan.md`
-2. If any tasks remain: re-spawn Dev with this recovery prompt:
-   > {{AGENT_PROMPT_DEV_RESUME}}
-3. Max 2 recovery retries. After 2 failures, orchestrator implements remaining tasks directly.
 
-Implementation phase is complete only when all tasks are `[x]` and the Test Failure Recovery Protocol's Success Rule is satisfied.
+**3e.** Append `## Implementation Log` (with Gate Evidence) to `context-snapshot.md`:
+- files changed/created
+- key decisions
+- deviations from plan
+- test results
+- Gate Evidence section
+- unresolved blockers
 
+**CP-2**: All tasks `[x]`, Implementation Log written with Gate Evidence, Test Failure Recovery Protocol's Success Rule satisfied. Blocked gates → `failure-log.md`, not success.
 
-**Checkpoint update**: Run the update script to set step `prizmkit-implement` to `"completed"`:
+**Checkpoint update**:
 ```bash
 python3 $PIPELINE_DIR/scripts/update-checkpoint.py \
   --checkpoint-path {{CHECKPOINT_PATH}} \

package/bundled/dev-pipeline/templates/sections/test-failure-recovery-agent.md

@@ -19,6 +19,10 @@ Use this protocol whenever implementation or review tests fail. Its purpose is t
 4. Stop after a plateau: same failure count and same failing tests for 3 consecutive rounds.
 5. If failures decrease, reset the plateau counter.
 
+### Hard Round Cap (BLOCKING)
+
+After **6 total test-fix rounds**, STOP trial-and-error. Write failure-log listing all hypotheses tried. Switch to: read full relevant source section ONCE (via `grep -n`+`sed -n`, never full Read), understand control flow, rewrite failing block in one shot. Do NOT exceed 7 total rounds.
+
 ### Success Rule
 
 Proceed to review only when:

package/bundled/dev-pipeline/templates/sections/test-failure-recovery-lite.md

@@ -19,6 +19,10 @@ Use this protocol whenever implementation tests fail. Its purpose is to distingu
 4. Stop after a plateau: same failure count and same failing tests for 3 consecutive rounds.
 5. If failures decrease, reset the plateau counter.
 
+### Hard Round Cap (BLOCKING)
+
+After **6 total test-fix rounds**, STOP trial-and-error. Write failure-log listing all hypotheses tried. Switch to: read full relevant source section ONCE (via `grep -n`+`sed -n`, never full Read), understand control flow, rewrite failing block in one shot. Do NOT exceed 7 total rounds.
+
 ### Success Rule
 
 Proceed only when:

package/bundled/dev-pipeline/templates/session-status-schema.json

@@ -15,7 +15,7 @@
     },
     "status": {
       "type": "string",
-      "enum": ["success", "partial", "failed", "commit_missing", "docs_missing", "merge_conflict"]
+      "enum": ["success", "partial", "failed", "commit_missing", "docs_missing", "merge_conflict", "context_overflow"]
     },
     "completed_phases": {
       "type": "array",

package/bundled/dev-pipeline/tests/conftest.py

@@ -24,5 +24,6 @@ def _load_hyphenated_module(module_name, filename):
 # Register hyphenated script files so tests can import them with underscores.
 _load_hyphenated_module("generate_bootstrap_prompt", "generate-bootstrap-prompt.py")
 _load_hyphenated_module("generate_bugfix_prompt", "generate-bugfix-prompt.py")
+_load_hyphenated_module("generate_refactor_prompt", "generate-refactor-prompt.py")
 _load_hyphenated_module("prizmkit_test_gate", "prizmkit-test-gate.py")
 _load_hyphenated_module("update_feature_status", "update-feature-status.py")