prizmkit 1.0.152 → 1.1.0

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

@@ -0,0 +1,45 @@
+### Plan Challenge — Critic Agent(s)
+
+**Guard**: Verify critic agent file exists before spawning:
+```bash
+ls {{CRITIC_SUBAGENT_PATH}} 2>/dev/null && echo "CRITIC:READY" || echo "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 Critic agent (Agent tool, subagent_type="prizm-dev-team-critic", run_in_background=false).
+
+Prompt:
+> "Read {{CRITIC_SUBAGENT_PATH}}. For feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}):
+> **MODE: Plan Challenge**
+> 1. Read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` FIRST — Section 3 has project context, Section 4 has file manifest.
+> 2. Read `.prizm-docs/root.prizm` and relevant L1/L2 docs for affected modules.
+> 3. Read existing source files in the modules this plan touches.
+> 4. Challenge plan.md against the project's existing architecture, patterns, and style.
+> Write `.prizmkit/specs/{{FEATURE_SLUG}}/challenge-report.md` with findings (or 'No significant challenges')."
+
+**If {{CRITIC_COUNT}} = 3 → Multi-Critic Voting** (skip Single Critic above):
+
+Spawn 3 Critic agents sequentially (each with 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.

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

@@ -0,0 +1,24 @@
+### Plan Challenge — Critic Agent
+
+**Guard**: Verify critic agent file exists before spawning:
+```bash
+ls {{CRITIC_SUBAGENT_PATH}} 2>/dev/null && echo "CRITIC:READY" || echo "CRITIC:MISSING"
+```
+If CRITIC:MISSING — skip this phase entirely and proceed. Log: "Critic agent not installed — skipping Plan Challenge."
+
+Spawn Critic agent (Agent tool, subagent_type="prizm-dev-team-critic", run_in_background=false).
+
+Prompt:
+> "Read {{CRITIC_SUBAGENT_PATH}}. For feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}):
+> **MODE: Plan Challenge**
+> 1. Read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` FIRST — Section 3 has project context, Section 4 has file manifest.
+> 2. Read `.prizm-docs/root.prizm` and relevant L1/L2 docs for affected modules.
+> 3. Read existing source files in the modules this plan touches.
+> 4. Challenge plan.md against the project's existing architecture, patterns, and style.
+> Write `.prizmkit/specs/{{FEATURE_SLUG}}/challenge-report.md` with findings (or 'No significant challenges')."
+
+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.

package/bundled/dev-pipeline/templates/sections/phase-deploy-verification.md

@@ -0,0 +1,36 @@
+### Local Deploy Verification
+
+You just implemented this feature — you know the project's tech stack and build tools.
+
+1. **Build**: Run the project's build/compile commands. If a required tool is missing, install it first.
+2. **Fix**: If build fails with code errors (type errors, missing imports, config issues), fix them (max 2 rounds), then re-verify.
+3. **Assess and record** — append to context-snapshot.md:
+   - **ALL builds pass** → `## Deploy Verification: PASS` — proceed to commit
+   - **Some builds fail with fixable errors** → fix and re-verify (already handled in step 2)
+   - **Cannot build locally** (missing system-level deps you cannot install) → Generate `DEPLOY.md` with:
+     ```
+     # Local Development Setup
+
+     ## Prerequisites
+     - [tool]: [install instruction]
+
+     ## Build Steps
+     1. [exact command]
+
+     ## Run / Dev Mode
+     [exact command to start the app locally]
+
+     ## Verify
+     [how to confirm the app is running correctly]
+     ```
+     Record: `## Deploy Verification: PARTIAL — see DEPLOY.md for missing prerequisites`
+
+Deploy verification does NOT block the commit, but you MUST attempt it.
+
+**Smoke test** (only if build passed and project can be started):
+1. Start the project locally (e.g., `make dev`, `npm start`, `go run .`, etc.)
+2. Verify basic functionality: hit key endpoints, check health routes, confirm the UI loads
+3. Stop the server process you started — do NOT leave it running
+4. Record smoke test results in `## Deploy Verification` section
+
+If the project cannot be started locally (e.g., requires external services, databases, credentials), skip the smoke test and note why.

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

@@ -0,0 +1,24 @@
+### 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.
+
+Spawn Dev subagent (Agent tool, subagent_type="prizm-dev-team-dev", run_in_background=false).
+
+Prompt:
+> "Read {{DEV_SUBAGENT_PATH}}. Implement feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}).
+> **IMPORTANT**: Read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` FIRST — Section 3 has Prizm Context (TRAPS/RULES), Section 4 has File Manifest with paths and interfaces.
+> ⚠️ 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. Use `TEST_CMD=<TEST_CMD>` for testing. Baseline failures: `BASELINE_FAILURES=<BASELINE_FAILURES>`.
+> 3. After implement completes, verify the '## Implementation Log' section was written to context-snapshot.md.
+> 4. 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."
+
+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:
+```bash
+grep -q "## Implementation Log" .prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md && echo "GATE:PASS" || echo "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."

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

@@ -0,0 +1,41 @@
+### 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.
+
+Before spawning Dev, check plan.md Tasks section:
+```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 Dev agent (Agent tool, subagent_type="prizm-dev-team-dev", run_in_background=false).
+
+Prompt:
+> "Read {{DEV_SUBAGENT_PATH}}. Implement feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}).
+> **IMPORTANT**: Read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` FIRST — Section 3 has Prizm Context (TRAPS/RULES), Section 4 has File Manifest with paths and interfaces.
+> ⚠️ 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. Use `TEST_CMD=<TEST_CMD>` for testing. Baseline failures: `BASELINE_FAILURES=<BASELINE_FAILURES>`.
+> 3. After implement completes, verify the '## Implementation Log' section was written to context-snapshot.md.
+> 4. 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."
+
+**Gate Check — Implementation Log**:
+After Dev agent returns, verify the Implementation Log was written:
+```bash
+grep -q "## Implementation Log" .prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md && echo "GATE:PASS" || echo "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: `grep -c '^\- \[ \]' .prizmkit/specs/{{FEATURE_SLUG}}/plan.md`
+2. If any tasks remain: re-spawn Dev with this recovery prompt:
+   > "Read {{DEV_SUBAGENT_PATH}}. You are resuming implementation of feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}).
+   > 1. Read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` — Section 4 has File Manifest, 'Implementation Log' (if present) shows what was already done.
+   > 2. Run `git diff HEAD` to see actual code changes already made.
+   > 3. Run `/prizmkit-implement` to complete the remaining `[ ]` tasks. Use `TEST_CMD=<TEST_CMD>` for testing.
+   > 4. Do NOT execute any git commands."
+3. Max 2 recovery retries. After 2 failures, orchestrator implements remaining tasks directly.
+
+All tasks `[x]`, tests pass.

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

@@ -0,0 +1,32 @@
+### 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`:
+```bash
+# Example for Go
+grep -q '^/binary-name$' .gitignore || echo '/binary-name' >> .gitignore
+```
+Never commit compiled binaries, build output, or generated artifacts.
+
+**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:
+```bash
+# Run each test command, capture output
+$TEST_CMD 2>&1 | tee /tmp/test-baseline.txt | tail -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 which modules 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 (max 2 fix rounds)
+
+**CP-2**: All acceptance criteria met, all tests pass.

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

@@ -0,0 +1,17 @@
+### Plan & Tasks
+
+```bash
+ls .prizmkit/specs/{{FEATURE_SLUG}}/plan.md 2>/dev/null
+```
+
+If missing, write it yourself:
+- `plan.md`: architecture — components, interfaces, data flow, files to create/modify, testing approach, and a Tasks section with `[ ]` checkboxes ordered by dependency
+
+**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.

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

@@ -0,0 +1,16 @@
+### Plan & Tasks
+
+```bash
+ls .prizmkit/specs/{{FEATURE_SLUG}}/ 2>/dev/null
+```
+
+If plan.md missing, write it directly:
+- `plan.md`: key components, data flow, files to create/modify, and a Tasks section with `[ ]` checkboxes (each task = one implementable unit). Keep under 80 lines.
+
+**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.

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

@@ -0,0 +1,28 @@
+### Review + Test — Reviewer Subagent
+
+Spawn Reviewer subagent (Agent tool, subagent_type="prizm-dev-team-reviewer", run_in_background=false).
+
+Prompt:
+> "Read {{REVIEWER_SUBAGENT_PATH}}. For feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}):
+> **IMPORTANT**: Read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` FIRST.
+> 1. Read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md`:
+>    - Section 3: Prizm Context (RULES, PATTERNS to check against)
+>    - Section 4: File Manifest (original file structure)
+>    - '## Implementation Log': what Dev changed, key decisions, discoveries
+> 2. Run prizmkit-code-review (both phases): Phase 1 diagnostic review (spec compliance, code quality, correctness), then Phase 2 fix strategy formulation for any findings. Read ONLY files listed in Implementation Log for diagnosis; MAY read additional files for impact analysis.
+> 3. Run the full test suite — **ONLY if the Implementation Log does not already confirm all tests passing**. If the log states tests passed, trust it and skip the re-run. When running: `$TEST_CMD 2>&1 | tee /tmp/review-test-out.txt | tail -20`, then grep the file for details — do NOT re-run the suite multiple times. Write and execute integration tests covering all user stories.
+> 4. Write structured '## Review Notes' to context-snapshot.md with Fix Instructions (Root Cause, Impact, Fix Strategy, Code Guidance, Verification for each finding) and Re-Review Expectations.
+> Report verdict: PASS, PASS_WITH_WARNINGS, or NEEDS_FIXES."
+
+Wait for Reviewer to return.
+
+**Gate Check — Review Notes**:
+After Reviewer agent returns, verify the Review Notes were written:
+```bash
+grep -q "## Review Notes" .prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md && echo "GATE:PASS" || echo "GATE:MISSING"
+```
+If GATE:MISSING — send message to Reviewer (re-spawn if needed): "Write the '## Review Notes' section to context-snapshot.md with structured Fix Instructions. Include: verdict, findings with Root Cause/Impact/Fix Strategy/Code Guidance/Verification, and Re-Review Expectations."
+
+- If NEEDS_FIXES: spawn Dev to fix (Dev reads Fix Instructions in snapshot), re-run Review (max 3 rounds)
+
+**CP-3**: Tests pass, verdict is not NEEDS_FIXES.

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

@@ -0,0 +1,36 @@
+### Review + Test — Reviewer Agent
+
+Spawn Reviewer agent (Agent tool, subagent_type="prizm-dev-team-reviewer", run_in_background=false).
+
+Prompt:
+> "Read {{REVIEWER_SUBAGENT_PATH}}. For feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}):
+> **IMPORTANT**: Read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` FIRST.
+> 1. Read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md`:
+>    - Section 3: Prizm Context (RULES, PATTERNS to check against)
+>    - Section 4: File Manifest (original file structure)
+>    - '## Implementation Log': what Dev changed, key decisions, discoveries
+> 2. Run prizmkit-code-review (both phases): Phase 1 diagnostic review (spec compliance, code quality, correctness), then Phase 2 fix strategy formulation for any findings. Read ONLY files listed in Implementation Log for diagnosis; MAY read additional files for impact analysis.
+> 3. Run the full test suite using `TEST_CMD=<TEST_CMD>` — **ONLY if the Implementation Log does not already confirm all tests passing**. If Implementation Log states tests passed, trust it and skip the re-run. When running tests: `$TEST_CMD 2>&1 | tee /tmp/review-test-out.txt | tail -20`, then grep `/tmp/review-test-out.txt` for details — do NOT re-run the suite multiple times. Write and execute integration tests covering all user stories from spec.md.
+> 4. Write structured '## Review Notes' to context-snapshot.md with Fix Instructions (Root Cause, Impact, Fix Strategy, Code Guidance, Verification for each finding) and Re-Review Expectations.
+> Report verdict: PASS, PASS_WITH_WARNINGS, or NEEDS_FIXES."
+
+Wait for Reviewer to return.
+
+**Gate Check — Review Notes**:
+After Reviewer agent returns, verify the Review Notes were written:
+```bash
+grep -q "## Review Notes" .prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md && echo "GATE:PASS" || echo "GATE:MISSING"
+```
+If GATE:MISSING — send message to Reviewer (re-spawn if needed): "Write the '## Review Notes' section to context-snapshot.md with structured Fix Instructions. Include: verdict, findings with Root Cause/Impact/Fix Strategy/Code Guidance/Verification, and Re-Review Expectations."
+
+- If NEEDS_FIXES: spawn Dev to fix with this prompt:
+  > "Read {{DEV_SUBAGENT_PATH}}. Fix NEEDS_FIXES issues for feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}).
+  > 1. Read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` — '## Review Notes' section contains structured Fix Instructions with exact steps.
+  > 2. Follow Fix Instructions in order (respect Depends On / Blocks dependencies). Each FIX-N has: Root Cause, Fix Strategy, Code Guidance, and Verification criteria.
+  > 3. After each fix, run the Verification command listed in that FIX-N to confirm it works.
+  > 4. Use `TEST_CMD=<TEST_CMD>` to verify no regressions.
+  > 5. Append fix summary to '## Implementation Log' in context-snapshot.md.
+  > 6. Do NOT execute any git commands."
+  Then re-run Review (max 3 rounds).
+
+**CP-3**: Integration tests pass, verdict is not NEEDS_FIXES.

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

@@ -0,0 +1,82 @@
+### Specify + Plan (Full Workflow)
+
+**Check for previous failure log:**
+```bash
+cat .prizmkit/specs/{{FEATURE_SLUG}}/failure-log.md 2>/dev/null || echo "NO_PREVIOUS_FAILURE"
+```
+If failure-log.md exists:
+- Read ROOT_CAUSE and SUGGESTION — adjust your approach accordingly
+- Read DISCOVERED_TRAPS — if any are genuine, inject into .prizm-docs/ during Phase 6 retrospective
+- Do NOT delete failure-log.md until this session completes all phases and commits successfully
+
+Check existing artifacts first:
+```bash
+ls .prizmkit/specs/{{FEATURE_SLUG}}/ 2>/dev/null
+```
+
+- 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
+
+Before planning, check whether feature code already exists in the project (search in source directories identified from `root.prizm` or the project tree scan):
+```bash
+grep -r "{{FEATURE_SLUG}}" . --include="*.js" --include="*.ts" --include="*.py" --include="*.go" --include="*.java" --include="*.rb" --include="*.rs" -l --exclude-dir=node_modules --exclude-dir=.git --exclude-dir=dist --exclude-dir=build --exclude-dir=vendor --exclude-dir=.prizmkit 2>/dev/null | head -20
+```
+
+Record result as `EXISTING_CODE` (list of files, or empty).
+
+If `EXISTING_CODE` is non-empty: your spec/plan/tasks must reflect this existing implementation — document what exists, identify gaps, do NOT re-implement what is already done.
+
+**Step A — Build Context Snapshot** (skip if `context-snapshot.md` already exists):
+
+1. Read `.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:
+   ```bash
+   find . -maxdepth 2 -type f \( -name "*.js" -o -name "*.ts" -o -name "*.py" -o -name "*.go" -o -name "*.java" -o -name "*.rb" -o -name "*.rs" \) -not -path '*/node_modules/*' -not -path '*/.git/*' -not -path '*/dist/*' -not -path '*/build/*' -not -path '*/vendor/*' | head -30
+   ```
+   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 — Feature Brief**: feature description + acceptance criteria (copy from above)
+   - **Section 2 — Project Structure**: run the following to get a visual directory tree, then paste output:
+     ```bash
+     find . -maxdepth 2 -type d -not -path '*/node_modules/*' -not -path '*/.git/*' -not -path '*/dist/*' -not -path '*/build/*' -not -path '*/__pycache__/*' -not -path '*/vendor/*' | sed -e 's;[^/]*/;|____;g;s;____|; |;g'
+     ```
+   - **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 .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):
+
+```bash
+ls .prizmkit/specs/{{FEATURE_SLUG}}/spec.md .prizmkit/specs/{{FEATURE_SLUG}}/plan.md 2>/dev/null
+```
+
+- spec.md missing: Run `/prizmkit-plan` → generate spec.md. Resolve any `[NEEDS CLARIFICATION]` markers using the feature description — do NOT pause for interactive input.
+- plan.md missing: Run `/prizmkit-plan` → generate plan.md (architecture, 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.

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

@@ -0,0 +1,4 @@
+### Phase 0: Project Bootstrap
+- Run `/prizmkit-init` (invoke the prizmkit-init skill)
+- Run `python3 {{INIT_SCRIPT_PATH}} --project-root {{PROJECT_ROOT}} --feature-id {{FEATURE_ID}} --feature-slug {{FEATURE_SLUG}}`
+- **CP-0**: Verify `.prizm-docs/root.prizm`, `.prizmkit/config.json` exist

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

@@ -0,0 +1,12 @@
+### 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**:
+```bash
+# Run each test command, capture output
+$TEST_CMD 2>&1 | tee /tmp/test-baseline.txt | tail -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 /tmp/test-out.txt`). Then grep the file instead of re-running the suite.

package/bundled/dev-pipeline/templates/sections/resume-header.md

@@ -0,0 +1,2 @@
+### Resume from Phase {{RESUME_PHASE}}
+Check `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` — if it exists, skip context building and use it directly.

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

@@ -0,0 +1,6 @@
+## Session Context
+
+- **Feature ID**: {{FEATURE_ID}} | **Session**: {{SESSION_ID}} | **Run**: {{RUN_ID}}
+- **Complexity**: {{COMPLEXITY}} | **Retry**: {{RETRY_COUNT}} / {{MAX_RETRIES}}
+- **Previous Status**: {{PREV_SESSION_STATUS}} | **Resume From**: {{RESUME_PHASE}}
+- **Init**: {{INIT_DONE}} | Artifacts: spec={{HAS_SPEC}} plan={{HAS_PLAN}}

package/bundled/dev-pipeline/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.