prizmkit 1.1.57 → 1.1.60

package/bundled/dev-pipeline-windows/templates/sections/phase-critic-plan-full.md

@@ -0,0 +1,53 @@
+### Plan Challenge — Critic Agent(s)
+
+**Guard**: Verify critic agent file exists before spawning:
+```powershell
+if (Test-Path "{{CRITIC_SUBAGENT_PATH}}") { "CRITIC:READY" } else { "CRITIC:MISSING" }
+```
+If CRITIC:MISSING — skip this phase entirely and proceed. Log: "Critic agent not installed — skipping Plan Challenge."
+
+**Choose ONE path based on `{{CRITIC_COUNT}}`:**
+
+**If {{CRITIC_COUNT}} = 1 → Single Critic** (skip to CP-2.5 after this):
+
+**Spawn Agent**:
+| Parameter | Value |
+|-----------|-------|
+| subagent_type | prizm-dev-team-critic |
+| mode | plan |
+| run_in_background | false |
+
+**Prompt**:
+> {{AGENT_PROMPT_CRITIC_PLAN_CHALLENGE}}
+
+**If {{CRITIC_COUNT}} = 3 → Multi-Critic Voting** (skip Single Critic above):
+
+Spawn 3 Critic agents sequentially (each with mode="plan", run_in_background=false), each with a different focus lens:
+
+Critic-A prompt (append to base prompt above):
+> "**Focus Lens: Architecture & Scalability.** Prioritize: architectural pattern fit, scalability implications, over-engineering risks, component boundary design.
+> Write `.prizmkit/specs/{{FEATURE_SLUG}}/challenge-report-A.md`."
+
+Critic-B prompt (append to base prompt above):
+> "**Focus Lens: Data Model & Edge Cases.** Prioritize: data model design fit, entity relationships, edge cases in business logic, missing boundary conditions.
+> Write `.prizmkit/specs/{{FEATURE_SLUG}}/challenge-report-B.md`."
+
+Critic-C prompt (append to base prompt above):
+> "**Focus Lens: Security & Performance.** Prioritize: security attack surface, authentication/authorization gaps, performance bottlenecks, resource leaks.
+> Write `.prizmkit/specs/{{FEATURE_SLUG}}/challenge-report-C.md`."
+
+After all critics return, read all 3 reports:
+- Challenge raised by **2/3 or more** critics → **must respond** (adjust plan or justify why not)
+- Challenge raised by **1/3 only** → logged in context-snapshot but not blocking
+- Max 1 plan revision round.
+
+**CP-2.5**: Plan challenges reviewed and resolved.
+
+
+**Checkpoint update**: Run the update script to set step `critic-plan-review` to `"completed"`:
+```powershell
+Invoke-PrizmPython {{PIPELINE_DIR}}\scripts\update-checkpoint.py `
+  --checkpoint-path {{CHECKPOINT_PATH}} `
+  --step critic-plan-review `
+  --status completed
+```

package/bundled/dev-pipeline-windows/templates/sections/phase-critic-plan.md

@@ -0,0 +1,32 @@
+### Plan Challenge — Critic Agent
+
+**Guard**: Verify critic agent file exists before spawning:
+```powershell
+if (Test-Path "{{CRITIC_SUBAGENT_PATH}}") { "CRITIC:READY" } else { "CRITIC:MISSING" }
+```
+If CRITIC:MISSING — skip this phase entirely and proceed. Log: "Critic agent not installed — skipping Plan Challenge."
+
+**Spawn Agent**:
+| Parameter | Value |
+|-----------|-------|
+| subagent_type | prizm-dev-team-critic |
+| mode | plan |
+| run_in_background | false |
+
+**Prompt**:
+> {{AGENT_PROMPT_CRITIC_PLAN_CHALLENGE}}
+
+Wait for Critic to return.
+- Read challenge-report.md. For items marked CRITICAL/HIGH: decide whether to adjust plan.md or document why the plan stands.
+- Max 1 plan revision round.
+
+**CP-2.5**: Plan challenges reviewed and resolved.
+
+
+**Checkpoint update**: Run the update script to set step `critic-plan-review` to `"completed"`:
+```powershell
+Invoke-PrizmPython {{PIPELINE_DIR}}\scripts\update-checkpoint.py `
+  --checkpoint-path {{CHECKPOINT_PATH}} `
+  --step critic-plan-review `
+  --status completed
+```

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

@@ -0,0 +1,37 @@
+### Implement — Dev Subagent
+
+**Build artifacts rule** (passed to Dev): After any build/compile command (`go build`, `npm run build`, `tsc`, etc.), ensure the output binary or build directory is in `.gitignore`. Never commit compiled binaries, build output, or generated artifacts.
+
+**Dependency version gate (BLOCKING — pass to Dev agent)**: Before running ANY package install command (`npm install`, `pip install`, `cargo build`, `go mod tidy`, `bundle install`, etc.):
+1. Every version number in the dependency manifest MUST be verified against the real registry (see Context Budget Rules §9)
+2. If a scaffold tool generated a `package.json` / `requirements.txt` / etc., verify the versions it wrote too — scaffold tools can emit outdated versions
+3. Do NOT proceed with install until all versions are confirmed real. Violation = wasted timeout cycles that can crash the session
+
+**Scaffold file rule (pass to Dev agent)**: After running any init/scaffold command, record generated files in context-snapshot.md under `### Scaffold Files (do not re-read)`. Never re-read these files — their content is standard boilerplate (see Context Budget Rules §8). When spawning subagents, explicitly list scaffold files so they skip reading them.
+
+**Spawn Agent**:
+| Parameter | Value |
+|-----------|-------|
+| subagent_type | prizm-dev-team-dev |
+| run_in_background | false |
+
+**Prompt**:
+> {{AGENT_PROMPT_DEV_IMPLEMENT}}
+
+Wait for Dev to return. All tasks must be `[x]`, tests pass.
+
+**Gate Check — Implementation Log**:
+After Dev agent returns, verify the Implementation Log was written:
+```powershell
+if (Select-String -Path .prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md -Pattern "## Implementation Log" -Quiet) { "GATE:PASS" } else { "GATE:MISSING" }
+```
+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."
+
+
+**Checkpoint update**: Run the update script to set step `prizmkit-implement` to `"completed"`:
+```powershell
+Invoke-PrizmPython {{PIPELINE_DIR}}\scripts\update-checkpoint.py `
+  --checkpoint-path {{CHECKPOINT_PATH}} `
+  --step prizmkit-implement `
+  --status completed
+```

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

@@ -0,0 +1,50 @@
+### Implement — Dev Agent
+
+**Build artifacts rule** (passed to Dev): After any build/compile command (`go build`, `npm run build`, `tsc`, etc.), ensure the output binary or build directory is in `.gitignore`. Never commit compiled binaries, build output, or generated artifacts.
+
+**Dependency version gate (BLOCKING — pass to Dev agent)**: Before running ANY package install command (`npm install`, `pip install`, `cargo build`, `go mod tidy`, `bundle install`, etc.):
+1. Every version number in the dependency manifest MUST be verified against the real registry (see Context Budget Rules §9)
+2. If a scaffold tool generated a `package.json` / `requirements.txt` / etc., verify the versions it wrote too — scaffold tools can emit outdated versions
+3. Do NOT proceed with install until all versions are confirmed real. Violation = wasted timeout cycles that can crash the session
+
+**Scaffold file rule (pass to Dev agent)**: After running any init/scaffold command, record generated files in context-snapshot.md under `### Scaffold Files (do not re-read)`. Never re-read these files — their content is standard boilerplate (see Context Budget Rules §8). When spawning subagents, explicitly list scaffold files so they skip reading them.
+
+Before spawning Dev, check plan.md Tasks section:
+```powershell
+Select-String -Pattern '^\- \[ \]' .prizmkit/specs/{{FEATURE_SLUG}}/plan.md 2>$null
+```
+- 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 |
+
+**Prompt**:
+> {{AGENT_PROMPT_DEV_IMPLEMENT}}
+
+**Gate Check — Implementation Log**:
+After Dev agent returns, verify the Implementation Log was written:
+```powershell
+if (Select-String -Path .prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md -Pattern "## Implementation Log" -Quiet) { "GATE:PASS" } else { "GATE:MISSING" }
+```
+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: `Select-String -Pattern '^\- \[ \]' .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.
+
+All tasks `[x]`, tests pass.
+
+
+**Checkpoint update**: Run the update script to set step `prizmkit-implement` to `"completed"`:
+```powershell
+Invoke-PrizmPython {{PIPELINE_DIR}}\scripts\update-checkpoint.py `
+  --checkpoint-path {{CHECKPOINT_PATH}} `
+  --step prizmkit-implement `
+  --status completed
+```

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

@@ -0,0 +1,52 @@
+### Implement + Test
+
+**Build artifacts**: After any build/compile command (`go build`, `npm run build`, `tsc`, etc.), ensure the output binary or build directory is in `.gitignore`:
+```powershell
+# Example for Go
+if (-not (Select-String -Path .gitignore -Pattern '^/binary-name$' -Quiet -ErrorAction SilentlyContinue)) {
+  Add-Content -Path .gitignore -Value '/binary-name'
+}
+```
+Never commit compiled binaries, build output, or generated artifacts.
+
+**Dependency version gate (BLOCKING)**: Before running ANY package install command (`npm install`, `pip install`, `cargo build`, `go mod tidy`, `bundle install`, etc.):
+1. Every version number in your dependency manifest MUST be verified against the real registry (see Context Budget Rules §9)
+2. If you used a scaffold tool that generated a `package.json` / `requirements.txt` / etc., verify the versions it wrote too — scaffold tools can emit outdated versions
+3. Do NOT proceed with install until all versions are confirmed real. Violation = wasted timeout cycles
+
+**Scaffold file rule**: After running any init/scaffold command, record generated files in context-snapshot.md under `### Scaffold Files (do not re-read)`. Never re-read these files — their content is standard boilerplate (see Context Budget Rules §8).
+
+**3a.** Detect test commands and record baseline:
+
+You know this project's tech stack. Identify ALL test commands that apply (e.g., `go test ./...`, `npm test`, `cargo test`, `pytest`, `make test`, etc.). Record them as `TEST_CMDS`. Then record baseline:
+```powershell
+# Run each test command, capture output
+& {
+  {{TEST_CMD}}
+} 2>&1 | Tee-Object (Join-Path $env:TEMP "test-baseline.txt") | Select-Object -Last 20
+```
+
+**3b.** Run `/prizmkit-implement` — this handles the full implementation cycle:
+- Reads plan.md Tasks section from `.prizmkit/specs/{{FEATURE_SLUG}}/`
+- Reads context from `context-snapshot.md` (Prizm docs, TRAPS, file manifest)
+- Implements task-by-task with TDD, marking each `[x]` immediately
+- Creates/updates L2 `.prizm` docs when creating new modules or significantly modifying existing ones — AI selectively decides the modules that warrant L2 based on complexity and importance
+- Runs tests using `TEST_CMD` after each task
+- Writes '## Implementation Log' to `context-snapshot.md`
+
+**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 (see Test Failure Recovery Protocol)
+
+**CP-2**: All acceptance criteria met, all tests pass.
+
+
+**Checkpoint update**: Run the update script to set step `prizmkit-implement` to `"completed"`:
+```powershell
+Invoke-PrizmPython {{PIPELINE_DIR}}\scripts\update-checkpoint.py `
+  --checkpoint-path {{CHECKPOINT_PATH}} `
+  --step prizmkit-implement `
+  --status completed
+```

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

@@ -0,0 +1,27 @@
+### Plan & Tasks
+
+```powershell
+Get-ChildItem .prizmkit/specs/{{FEATURE_SLUG}}/plan.md -ErrorAction SilentlyContinue
+```
+
+If missing, run `/prizmkit-plan` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/` to generate `plan.md`:
+- The plan.md should include: architecture — components, interfaces, data flow, files to create/modify, testing approach, and a Tasks section with `[ ]` checkboxes ordered by dependency.
+- Resolve any `[NEEDS CLARIFICATION]` markers using the feature description — do NOT pause for interactive input.
+
+**Database Design Gate** (if feature involves data persistence — new tables, schema changes, new entities):
+Before proceeding past CP-1, verify:
+1. Plan.md Data Model section references existing schema/model files (scan for `*.prisma`, `*.sql`, `migrations/`, `models/`, `*.entity.*` files; read them if not already in context-snapshot)
+2. All new tables/fields follow existing naming conventions, ID strategy, timestamp patterns, and constraint style
+3. No `[NEEDS CLARIFICATION]` remains in Data Model section — resolve by reading existing code and making a conservative choice that matches existing patterns. Document the resolution in plan.md.
+4. If a DB design decision genuinely cannot be resolved from existing code alone, document the assumption made and flag it in the Implementation Log for user review.
+
+**CP-1**: plan.md exists with Tasks section.
+
+
+**Checkpoint update**: Run the update script to set step `prizmkit-plan` to `"completed"`:
+```powershell
+Invoke-PrizmPython {{PIPELINE_DIR}}\scripts\update-checkpoint.py `
+  --checkpoint-path {{CHECKPOINT_PATH}} `
+  --step prizmkit-plan `
+  --status completed
+```

package/bundled/dev-pipeline-windows/templates/sections/phase-plan-lite.md

@@ -0,0 +1,27 @@
+### Plan & Tasks
+
+```powershell
+Get-ChildItem .prizmkit/specs/{{FEATURE_SLUG}}/ -ErrorAction SilentlyContinue
+```
+
+If plan.md missing, run `/prizmkit-plan` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/`:
+- Pass the feature description and acceptance criteria from the Feature Context section above as input
+- The plan.md should include: key components, data flow, files to create/modify, and a Tasks section with `[ ]` checkboxes (each task = one implementable unit). Keep under 80 lines.
+- Resolve any `[NEEDS CLARIFICATION]` markers using the feature description — do NOT pause for interactive input.
+
+**Database Design Gate** (if feature involves data persistence — new tables, schema changes, new entities):
+Before proceeding past CP-1:
+1. Scan for existing schema files (`*.prisma`, `*.sql`, `migrations/`, `models/`, `*.entity.*`) and read them
+2. Ensure new tables/fields follow existing naming conventions and constraint patterns
+3. Resolve all uncertain DB design decisions before writing Tasks — document choices in plan.md
+
+**CP-1**: plan.md exists with Tasks section.
+
+
+**Checkpoint update**: Run the update script to set step `prizmkit-plan` to `"completed"`:
+```powershell
+Invoke-PrizmPython {{PIPELINE_DIR}}\scripts\update-checkpoint.py `
+  --checkpoint-path {{CHECKPOINT_PATH}} `
+  --step prizmkit-plan `
+  --status completed
+```

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

@@ -0,0 +1,27 @@
+### Review + Test — Code Review
+
+Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/`.
+
+The skill runs an internal review-fix loop (Reviewer Agent → filter → Dev Agent fix, max 3 rounds) and writes `review-report.md` to the artifact directory.
+
+**Gate Check — Review Report**:
+After `/prizmkit-code-review` returns, verify the review report:
+```powershell
+if (Select-String -Path .prizmkit/specs/{{FEATURE_SLUG}}/review-report.md -Pattern "## Verdict" -Quiet) { "GATE:PASS" } else { "GATE:MISSING" }
+```
+If GATE:MISSING — re-run `/prizmkit-code-review`.
+
+Read `review-report.md` and check the Verdict:
+- `PASS` → proceed to next phase
+- `NEEDS_FIXES` → the skill exhausted its max rounds; log the remaining findings and proceed (do not retry externally)
+
+**CP-3**: Review complete, report written.
+
+
+**Checkpoint update**: Run the update script to set step `prizmkit-code-review` to `"completed"`:
+```powershell
+Invoke-PrizmPython {{PIPELINE_DIR}}\scripts\update-checkpoint.py `
+  --checkpoint-path {{CHECKPOINT_PATH}} `
+  --step prizmkit-code-review `
+  --status completed
+```

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

@@ -0,0 +1,29 @@
+### Review + Test — Code Review
+
+Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/`.
+
+The skill runs an internal review-fix loop (Reviewer Agent → filter → Dev Agent fix, max 3 rounds) and writes `review-report.md` to the artifact directory.
+
+**Gate Check — Review Report**:
+After `/prizmkit-code-review` returns, verify the review report:
+```powershell
+if (Select-String -Path .prizmkit/specs/{{FEATURE_SLUG}}/review-report.md -Pattern "## Verdict" -Quiet) { "GATE:PASS" } else { "GATE:MISSING" }
+```
+If GATE:MISSING — re-run `/prizmkit-code-review`.
+
+Read `review-report.md` and check the Verdict:
+- `PASS` → proceed to next phase
+- `NEEDS_FIXES` → the skill exhausted its max rounds; log the remaining findings and proceed (do not retry externally)
+
+Run the full test suite: `({{TEST_CMD}}) 2>&1 | Tee-Object (Join-Path $env:TEMP "review-test-out.txt") | Select-Object -Last 20`
+
+**CP-3**: Review complete, tests pass, report written.
+
+
+**Checkpoint update**: Run the update script to set step `prizmkit-code-review` to `"completed"`:
+```powershell
+Invoke-PrizmPython {{PIPELINE_DIR}}\scripts\update-checkpoint.py `
+  --checkpoint-path {{CHECKPOINT_PATH}} `
+  --step prizmkit-code-review `
+  --status completed
+```

package/bundled/dev-pipeline-windows/templates/sections/phase-specify-plan-full.md

@@ -0,0 +1,77 @@
+### Specify + Plan (Full Workflow)
+
+Check existing artifacts first:
+```powershell
+Get-ChildItem .prizmkit/specs/{{FEATURE_SLUG}}/ -ErrorAction SilentlyContinue
+```
+
+- Both (spec.md, plan.md) exist → **SKIP to CP-1**
+- `context-snapshot.md` exists → use it directly, skip context snapshot building
+- Some missing → generate only missing files
+
+**Step A — Build Context Snapshot** (skip if `context-snapshot.md` already exists):
+
+1. Read `.prizmkit/prizm-docs/root.prizm` and relevant L1/L2 prizm docs
+2. Detect source code directories: read KEY_FILES and STRUCTURE sections from `root.prizm` to identify where source code lives (e.g. `src/`, `app/`, `lib/`, `cmd/`, `packages/`, or project root). If `root.prizm` is missing, scan the project tree:
+   ```powershell
+	   Get-ChildItem -Path . -File -Recurse -Depth 2 -Include *.js,*.ts,*.py,*.go,*.java,*.rb,*.rs -ErrorAction SilentlyContinue |
+	     Where-Object { $_.FullName -notmatch '\\(node_modules|\.git|dist|build|vendor)(\\|$)' } |
+	     Select-Object -First 30 -ExpandProperty FullName
+   ```
+   Identify the top-level source directories from the results.
+3. Scan the detected source directories for files related to this feature; read each one
+4. Write `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md`:
+   - **Section 1 — Task Brief**: task description + acceptance criteria (copy from above)
+   - **Section 2 — Project Structure**: run the following to get a visual directory tree, then paste output:
+     ```powershell
+	     Get-ChildItem -Path . -Directory -Recurse -Depth 2 -ErrorAction SilentlyContinue |
+	       Where-Object { $_.FullName -notmatch '\\(node_modules|\.git|dist|build|__pycache__|vendor)(\\|$)' } |
+	       Select-Object -ExpandProperty FullName
+     ```
+   - **Section 3 — Prizm Context**: full content of root.prizm and relevant L1/L2 docs
+   - **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:
+     ### Files to Modify
+     | File | Why Needed | Key Interfaces |
+     |------|-----------|----------------|
+     | `<source-dir>/config.js` | Add runtime config layer | `config` (Zod object), `configSchema` |
+
+     ### Files for Reference
+     | File | Why Needed | Key Interfaces |
+     |------|-----------|----------------|
+     | `<source-dir>/security/permission-guard.js` | Permission check integration | `checkCommandPermission(userId, cmd)` |
+
+     ### Known TRAPS (from .prizmkit/prizm-docs/)
+     - <trap entries extracted from L1/L2 docs>
+   - **Section 5 — Existing Tests**: full content of related test files as code blocks
+5. Confirm: `ls .prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md`
+
+**After Step A**: Use context-snapshot.md Section 4 File Manifest to guide targeted file reads. Do NOT scan directories or read unrelated files.
+
+**Step B — Planning Artifacts** (generate only missing files):
+
+```powershell
+Get-ChildItem .prizmkit/specs/{{FEATURE_SLUG}}/spec.md .prizmkit/specs/{{FEATURE_SLUG}}/plan.md -ErrorAction SilentlyContinue
+```
+
+- spec.md missing: Run `/prizmkit-plan` → generate spec.md. Resolve any `[NEEDS CLARIFICATION]` markers using the task description — do NOT pause for interactive input.
+- plan.md missing: Run `/prizmkit-plan` → generate plan.md (change approach, components, interface design, data model, testing strategy, risk assessment, and Tasks section with `[ ]` checkboxes)
+
+> All files go under `.prizmkit/specs/{{FEATURE_SLUG}}/`. Confirm each with `ls` after writing.
+
+**Database Design Gate** (if feature involves data persistence — new tables, schema changes, new entities):
+Before proceeding past CP-1, verify:
+1. Plan.md Data Model section references existing schema/model files (scan for `*.prisma`, `*.sql`, `migrations/`, `models/`, `*.entity.*` files; read them if not already in context-snapshot)
+2. All new tables/fields follow existing naming conventions, ID strategy, timestamp patterns, and constraint style
+3. No `[NEEDS CLARIFICATION]` remains in Data Model section — resolve by reading existing code and making a conservative choice that matches existing patterns. Document the resolution in plan.md.
+4. If a DB design decision genuinely cannot be resolved from existing code alone, document the assumption made and flag it in the Implementation Log for user review.
+
+**CP-1**: Both spec.md and plan.md exist.
+
+
+**Checkpoint update**: Run the update script to set step `context-snapshot-and-plan` to `"completed"`:
+```powershell
+Invoke-PrizmPython {{PIPELINE_DIR}}\scripts\update-checkpoint.py `
+  --checkpoint-path {{CHECKPOINT_PATH}} `
+  --step context-snapshot-and-plan `
+  --status completed
+```

package/bundled/dev-pipeline-windows/templates/sections/phase0-init.md

@@ -0,0 +1,13 @@
+### Phase 0: Project Bootstrap
+- Run `/prizmkit-init` (invoke the prizmkit-init skill)
+- Run `Invoke-PrizmPython {{INIT_SCRIPT_PATH}} --project-root {{PROJECT_ROOT}} --feature-id {{FEATURE_ID}} --feature-slug {{FEATURE_SLUG}}`
+- **CP-0**: Verify `.prizmkit/prizm-docs/root.prizm`, `.prizmkit/config.json` exist
+
+
+**Checkpoint update**: Run the update script to set step `prizmkit-init` to `"completed"`:
+```powershell
+Invoke-PrizmPython {{PIPELINE_DIR}}\scripts\update-checkpoint.py `
+  --checkpoint-path {{CHECKPOINT_PATH}} `
+  --step prizmkit-init `
+  --status completed
+```

package/bundled/dev-pipeline-windows/templates/sections/phase0-test-baseline.md

@@ -0,0 +1,23 @@
+### Phase 0: Record Test Baseline & Detect Test Commands
+
+**Step 1 — Detect test commands**: You know this project's tech stack. Identify ALL test commands that apply (e.g., `go test ./...`, `npm test`, `cargo test`, `pytest`, `make test`, etc.). Record them as `TEST_CMDS`.
+
+**Step 2 — Record pre-existing failure baseline**:
+```powershell
+# Run each test command, capture output
+& {
+  {{TEST_CMD}}
+} 2>&1 | Tee-Object (Join-Path $env:TEMP "test-baseline.txt") | Select-Object -Last 20
+```
+Save the list of **pre-existing failing tests** (if any) as `BASELINE_FAILURES`. These are known failures that existed before this session — Dev must NOT be blamed for them, but must list them in COMPLETION_SIGNAL.
+
+> **Test Output Rule**: Always capture test output to a temp file (`tee $env:TEMP\test-out.txt`). Then Select-String the file instead of re-running the suite.
+
+
+**Checkpoint update**: Run the update script to set step `test-baseline` to `"completed"`:
+```powershell
+Invoke-PrizmPython {{PIPELINE_DIR}}\scripts\update-checkpoint.py `
+  --checkpoint-path {{CHECKPOINT_PATH}} `
+  --step test-baseline `
+  --status completed
+```

package/bundled/dev-pipeline-windows/templates/sections/session-context.md

@@ -0,0 +1,5 @@
+## Session Context
+
+- **Feature ID**: {{FEATURE_ID}} | **Session**: {{SESSION_ID}} | **Run**: {{RUN_ID}}
+- **Complexity**: {{COMPLEXITY}}
+- **Init**: {{INIT_DONE}} | Artifacts: spec={{HAS_SPEC}} plan={{HAS_PLAN}}

package/bundled/dev-pipeline-windows/templates/sections/subagent-timeout-recovery.md

@@ -0,0 +1,6 @@
+## Subagent Timeout Recovery
+
+If any agent times out:
+1. `ls .prizmkit/specs/{{FEATURE_SLUG}}/` — check what exists
+2. If `context-snapshot.md` exists: open recovery prompt with `"Read .prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md for project context and any Implementation Log/Review Notes from previous agents. Run git diff HEAD to see actual code changes already made. Do NOT re-read individual source files unless the File Manifest directs you to."` + only remaining steps + `model: "lite"`
+3. Max 2 retries per phase. After 2 failures, orchestrator completes the work directly and appends a Recovery Note to context-snapshot.md.

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

@@ -0,0 +1,67 @@
+## Test Failure Recovery Protocol
+
+When tests fail during implementation (Phase 3 / Phase 4), use **convergence-based recovery** — keep fixing as long as progress is being made.
+
+### Recovery Loop
+
+1. **Run tests and record results**:
+   - Count total failures and note the failed tests
+   - Compare against baseline (BASELINE_FAILURES) — exclude pre-existing failures
+
+2. **Check termination conditions** (evaluate BEFORE each fix attempt):
+   - **All tests pass** → Done. Exit recovery loop.
+   - **Plateau detected** — same failure count AND same failing tests for 3 consecutive rounds → AI cannot resolve these failures. Document and exit.
+   - **Still making progress** — failure count decreased compared to previous round → Continue fixing.
+   - **First round** — no history yet → Proceed to fix.
+
+3. **Fix and iterate**:
+   - Analyze remaining failures: root cause (code bug vs. test brittleness vs. environment issue)
+   - Categorize:
+     - **Pre-existing baseline failure**: Expected, do NOT fix
+     - **New regression**: Fix the code
+     - **Brittle test**: Fix the test or environment setup
+   - Apply fix, re-run `{{TEST_CMD}}`, go back to step 1
+
+### Convergence Tracking
+
+Track failures each round. Example: 5→3→3→3→3 = plateau at round 3, stop at round 5 (3/3).
+
+**Key rule**: If failures decrease (even by 1), the plateau counter resets to 0.
+
+### Escalation — Dev + Reviewer Workflow
+
+When the recovery loop exits with remaining failures:
+- Dev appends failure details to Implementation Log
+- Reviewer agent runs full test suite in Phase 5
+- If Reviewer confirms NEW regressions (not in baseline): mark verdict as `NEEDS_FIXES`
+- If Reviewer confirms only baseline failures remain: proceed with `PASS_WITH_WARNINGS`
+
+### Context-Aware Test Re-run (Performance Optimization)
+
+**Skip redundant re-runs**:
+- If Implementation Log section in context-snapshot.md already confirms "all tests passing"
+- → Skip Phase 5 test suite re-run (Reviewer will verify baseline log instead)
+- This avoids rebuilding/re-running tests when already verified
+
+**When to re-run**:
+- If Implementation Log is missing or incomplete
+- If any new code was added after the last test run
+- If Reviewer suspects brittleness or environment drift
+
+### Failure Capture Rules
+
+If tests remain broken after recovery:
+
+```
+## Test Failures Encountered
+
+- **Test**: [test name/path]
+  - Root Cause: [explanation]
+  - Category: [pre-existing baseline | new regression | brittle test | environment]
+  - Rounds Attempted: [N rounds, plateau at round M]
+  - Status: [still failing | requires next session | known limitation]
+
+- **Impact on Feature**: [can AC be verified despite failure | blocks AC verification]
+```
+
+**Rule**: If any AC cannot be verified due to test failure, the feature is incomplete. Document in failure-log.md for next session.

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

@@ -0,0 +1,58 @@
+## Test Failure Recovery Protocol
+
+When tests fail during implementation, use **convergence-based recovery** — keep fixing as long as progress is being made.
+
+### Recovery Loop
+
+1. **Run tests and record results**:
+   - Count total failures and note the failed tests
+   - Compare against baseline (BASELINE_FAILURES) — exclude pre-existing failures
+
+2. **Check termination conditions** (evaluate BEFORE each fix attempt):
+   - **All tests pass** → Done. Exit recovery loop.
+   - **Plateau detected** — same failure count AND same failing tests for 3 consecutive rounds → AI cannot resolve these failures. Document and exit.
+   - **Still making progress** — failure count decreased compared to previous round → Continue fixing.
+   - **First round** — no history yet → Proceed to fix.
+
+3. **Fix and iterate**:
+   - Analyze remaining failures: root cause (code bug vs. test brittleness vs. environment issue)
+   - Categorize:
+     - **Pre-existing baseline failure**: Expected, do NOT fix
+     - **New regression**: Fix the code
+     - **Brittle test**: Fix the test or environment setup
+   - Apply fix, re-run `{{TEST_CMD}}`, go back to step 1
+
+### Convergence Tracking
+
+Track failures each round. Example: 5→3→3→3→3 = plateau at round 3, stop at round 5 (3/3).
+
+**Key rule**: If failures decrease (even by 1), the plateau counter resets to 0.
+
+### Escalation — Single Agent
+
+When the recovery loop exits with remaining failures:
+- Document all remaining failures in Implementation Log with root cause analysis
+- Record PARTIAL status with known failure list
+- **Do NOT block commit** — unresolved test failures are deferred to next session
+
+### Context-Aware Optimization
+
+**Skip redundant re-runs**: If Implementation Log already confirms "all tests passing", skip full suite re-run.
+
+### Failure Capture Rules
+
+If tests remain broken after recovery:
+
+```
+## Test Failures Encountered
+
+- **Test**: [test name/path]
+  - Root Cause: [explanation]
+  - Category: [pre-existing baseline | new regression | brittle test | environment]
+  - Rounds Attempted: [N rounds, plateau at round M]
+  - Status: [still failing | requires next session | known limitation]
+
+- **Impact on Feature**: [can AC be verified despite failure | blocks AC verification]
+```
+
+**Rule**: If any AC cannot be verified due to test failure, the feature is incomplete. Document in failure-log.md for next session.