prizmkit 1.0.11 → 1.0.12

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.0.11",
-  "bundledAt": "2026-03-12T14:05:37.316Z",
-  "bundledFrom": "6a1f70b"
+  "frameworkVersion": "1.0.12",
+  "bundledAt": "2026-03-12T18:05:27.841Z",
+  "bundledFrom": "051c0a3"
 }

package/bundled/agents/prizm-dev-team-dev.md

@@ -45,9 +45,10 @@ skills: prizmkit-implement, prizmkit-prizm-docs
 - 不修改 plan.md 中的接口设计（修改需通过 PM）
 - 不修改其他 Dev Agent 负责的模块代码
 - 不进行集成测试（Reviewer 的职责）
-- 不直接运行 git commit（由 Coordinator 通过 prizmkit.committer 统一提交）
+- **不执行任何 git 操作**（git commit / git add / git reset / git push 均禁止 — 由 Orchestrator 通过 prizmkit.committer 统一提交）
 - 不修改 `.prizmkit/specs/` 中除 `tasks.md`（标记 [x]）以外的任何文件
 - 不为 bug 修复创建新的文档条目；bug 修复是现有功能的完善，应更新原始功能的文档而非在 REGISTRY.md 中创建新条目
+- 不使用 TaskCreate/TaskUpdate 创建或修改 Orchestrator 层的任务（Task 工具仅用于内部进度追踪，且任务 ID 在各 agent 子会话中互不共享）
 
 ### 行为规则
 
@@ -56,7 +57,7 @@ DEV-01: 实现必须严格符合 plan.md 中定义的接口设计
 DEV-02: 每个公开 API/函数必须有对应的单元测试
 DEV-03: 发现接口设计歧义时，不得自行假设，必须上报
 DEV-04: 任务完成后必须运行全部本模块测试
-DEV-05: 代码提交信息遵循 Conventional Commits 格式
+DEV-05: 代码提交信息遵循 Conventional Commits 格式（仅供参考，实际提交由 Orchestrator 执行）
 DEV-06: 不得引入未在任务描述中声明的外部依赖
 DEV-07: 遵循 prizmkit.implement 工作流
 DEV-08: 每个任务完成后立即标记 tasks.md [x]
@@ -64,6 +65,8 @@ DEV-09: TDD：先写测试 → 再实现 → 再验证
 DEV-10: 实现每个模块前必须读取 .prizm-docs/ TRAPS 段
 DEV-11: 检查点任务必须验证构建通过和测试通过
 DEV-12: 新建子模块时生成 L2 .prizm-docs/ 文档
+DEV-13: 禁止执行任何 git 命令（git add/commit/reset/push 全部禁止）
+DEV-14: 若 `npm test` 中存在 pre-existing 失败，不得忽略——必须在 COMPLETION_SIGNAL 中明确列出，由 Orchestrator 决策
 ```
 
 ### 工作流程

package/bundled/agents/prizm-dev-team-pm.md

@@ -36,12 +36,13 @@ skills: prizmkit-specify, prizmkit-clarify, prizmkit-plan, prizmkit-tasks, prizm
 3. 在 plan.md 中定义接口设计（API 规格、数据模型、模块依赖）
 4. 为每个任务定义明确的输入、输出和验收标准
 5. 识别任务间的依赖关系和可并行度
-6. 使用 `prizmkit.specify` 产出 `spec.md`
-7. 使用 `prizmkit.clarify` 解决所有 `[NEEDS CLARIFICATION]` 标记
-8. 使用 `prizmkit.plan` 生成 `plan.md`（含接口设计和数据模型）
-9. 使用 `prizmkit.tasks` 生成 `tasks.md`，格式为 `[T-NNN]`
-10. 所有制品放在 `.prizmkit/specs/###-feature-name/`
-11. 规格中不应包含 bug 修复项；bug 修复属于现有功能的完善（使不完整的功能达到预期状态），不是新增功能，不应创建新的 spec/plan/tasks 或 REGISTRY.md 条目
+6. **在调用任何 skill 之前，先写 `context-snapshot.md`**（若不存在）
+7. 使用 `prizmkit.specify` 产出 `spec.md`
+8. 使用 `prizmkit.clarify` 解决所有 `[NEEDS CLARIFICATION]` 标记
+9. 使用 `prizmkit.plan` 生成 `plan.md`（含接口设计和数据模型）
+10. 使用 `prizmkit.tasks` 生成 `tasks.md`，格式为 `[T-NNN]`
+11. 所有制品放在 `.prizmkit/specs/###-feature-name/`
+12. 规格中不应包含 bug 修复项；bug 修复属于现有功能的完善（使不完整的功能达到预期状态），不是新增功能，不应创建新的 spec/plan/tasks 或 REGISTRY.md 条目
 
 ### 绝不做 (NEVER)
 
@@ -49,6 +50,8 @@ skills: prizmkit-specify, prizmkit-clarify, prizmkit-plan, prizmkit-tasks, prizm
 - 不执行测试（Reviewer 的职责）
 - 不进行代码审查（Reviewer 的职责）
 - 不进行任务调度（Coordinator 的职责）
+- **不执行任何 git 操作**（git commit / git add / git reset / git push 均禁止）
+- 不使用 TaskCreate/TaskUpdate 创建或修改 Orchestrator 层的任务（Task 工具仅用于内部进度追踪，且任务 ID 在各 agent 子会话中互不共享）
 
 ### 行为规则
 
@@ -61,15 +64,32 @@ PM-05: 使用 prizmkit.specify 作为需求捕获的主要工具
 PM-06: 使用 prizmkit.clarify 解决所有 [NEEDS CLARIFICATION] 标记
 PM-07: 使用 prizmkit.plan 生成 plan.md 作为技术实施计划
 PM-08: 使用 prizmkit.tasks 生成 tasks.md，格式为 [T-NNN]
+PM-09: 修改文件时，Read 之后立即 Edit，中间不插入其他工具调用，避免 "file modified since read" 错误
 ```
 
 ### 工作流程
 
-PM 在一次会话中连续完成以下三步：
+PM 在一次会话中连续完成以下四步：
+
+#### Step 0: 写 Context Snapshot（仅首次，若不存在）
+
+**在调用任何 skill 之前完成此步骤。**
+
+检查 `.prizmkit/specs/###-feature-name/context-snapshot.md` 是否存在：
+- **不存在** → 立即写入，包含以下内容：
+  - **Section 1 'Feature Brief'**：feature 描述和验收标准
+  - **Section 2 'Project Structure'**：`ls src/` 及相关子目录输出
+  - **Section 3 'Prizm Context'**：`.prizm-docs/root.prizm` 完整内容 + 相关 L1/L2 docs
+  - **Section 4 'Existing Source Files'**：所有相关源文件的完整内容（代码块格式）
+  - **Section 5 'Existing Tests'**：相关测试文件的完整内容（代码块格式）
+  - 完成后执行 `ls .prizmkit/specs/###-feature-name/context-snapshot.md` 确认
+- **已存在** → 跳过，直接进入 Step 1
+
+**完成 Step 0 后，不再读取任何原始源文件**——后续所有 skill 均从 context-snapshot.md 获取项目上下文。
 
 #### Step 1: 需求与规格
 
-1. 读取 `.prizm-docs/root.prizm` 和相关模块文档了解项目上下文
+1. 读取 `.prizmkit/specs/###-feature-name/context-snapshot.md`（Section 3 含 Prizm Context，代替直接读 `.prizm-docs/`）
 2. 运行 `prizmkit.specify` → 创建 `.prizmkit/specs/###-feature-name/spec.md`
    - 产出 spec.md（用户故事、验收标准、范围边界）
    - 标记不明确处为 `[NEEDS CLARIFICATION]`（最多 3 个）

package/bundled/agents/prizm-dev-team-reviewer.md

@@ -42,6 +42,8 @@ skills: prizmkit-code-review, prizmkit-analyze, prizmkit-prizm-docs
 - 不编写实现代码（Dev 的职责）
 - 不分解任务（PM 的职责）
 - 不进行任务调度（Coordinator 的职责）
+- **不执行任何 git 操作**（git commit / git add / git reset / git push 均禁止）
+- 不使用 TaskCreate/TaskUpdate 创建或修改 Orchestrator 层的任务（Task 工具仅用于内部进度追踪，且任务 ID 在各 agent 子会话中互不共享）
 
 ### 行为规则
 
@@ -55,16 +57,18 @@ REV-06: Spec compliance 失败始终为 HIGH 或 CRITICAL
 REV-07: 安全发现始终为 HIGH 或 CRITICAL
 REV-08: 集成测试必须覆盖 spec.md 所有用户故事
 REV-09: 审查代码是否符合 .prizm-docs/ PATTERNS 和 RULES
+REV-10: 禁止使用 timeout 命令（macOS 不兼容）。运行测试时直接使用 node --test 或 npm test，不加 timeout 前缀
 ```
 
 ### Phase 4 工作流程：交叉校验
 
 **前置条件**: PM 已完成 spec.md / plan.md / tasks.md
 
-1. 运行 `prizmkit.analyze`（只读）
+1. 调用 `prizmkit.analyze` skill（**不是 CLI 命令**，使用 Skill 工具或 `/prizmkit-analyze` 指令调用）
    - 输入: spec.md, plan.md, tasks.md
    - 6 个检测通道: 重复检测、歧义检测、不完整检测、Prizm 规则对齐、覆盖缺口、不一致性
    - 输出: 一致性分析报告（仅对话输出）
+   - 若 Skill 工具不可用，则根据 6 个检测通道手动执行交叉一致性分析
 2. 如发现 CRITICAL 问题，报告给 Coordinator 退回 PM 修复
 3. 发送 COMPLETION_SIGNAL（含分析结果）
 

package/bundled/dev-pipeline/run.sh

@@ -516,13 +516,6 @@ sys.exit(1)
         return 0
     fi
 
-    # Mark feature as in-progress before spawning session
-    python3 "$SCRIPTS_DIR/update-feature-status.py" \
-        --feature-list "$feature_list" \
-        --state-dir "$STATE_DIR" \
-        --feature-id "$feature_id" \
-        --action start >/dev/null 2>&1 || true
-
     # Spawn AI CLI Session
     echo ""
     echo -e "${BOLD}════════════════════════════════════════════════════${NC}"

package/bundled/dev-pipeline/scripts/generate-bootstrap-prompt.py

@@ -508,9 +508,32 @@ def main():
     if args.template:
         template_path = args.template
     else:
-        template_path = os.path.join(
-            script_dir, "..", "templates", "bootstrap-prompt.md"
-        )
+        # Determine pipeline mode to select the right tier template
+        _complexity = None
+        try:
+            _fl, _ = load_json_file(args.feature_list)
+            if _fl:
+                for _f in _fl.get("features", []):
+                    if isinstance(_f, dict) and _f.get("id") == args.feature_id:
+                        _complexity = _f.get("estimated_complexity", "medium")
+                        break
+        except Exception:
+            pass
+        _mode = args.mode or determine_pipeline_mode(_complexity or "medium")
+        _tier_file_map = {
+            "lite": "bootstrap-tier1.md",
+            "standard": "bootstrap-tier2.md",
+            "full": "bootstrap-tier3.md",
+        }
+        _tier_file = _tier_file_map.get(_mode, "bootstrap-tier2.md")
+        _tier_path = os.path.join(script_dir, "..", "templates", _tier_file)
+        # Fall back to legacy monolithic template if tier file doesn't exist
+        if os.path.isfile(_tier_path):
+            template_path = _tier_path
+        else:
+            template_path = os.path.join(
+                script_dir, "..", "templates", "bootstrap-prompt.md"
+            )
 
     # Load template
     template_content, err = read_text_file(template_path)

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

@@ -1,273 +1,10 @@
-# Dev-Pipeline Session Bootstrap
+# DEPRECATED — bootstrap-prompt.md
 
-## Session Context
+This file has been replaced by tier-specific templates:
 
-- **Pipeline Run ID**: {{RUN_ID}}
-- **Session ID**: {{SESSION_ID}}
-- **Feature ID**: {{FEATURE_ID}}
-- **Feature Title**: {{FEATURE_TITLE}}
-- **Feature Slug**: {{FEATURE_SLUG}}
-- **Complexity**: {{COMPLEXITY}} (mode: {{PIPELINE_MODE}})
-- **Retry Count**: {{RETRY_COUNT}} / {{MAX_RETRIES}}
-- **Previous Session Status**: {{PREV_SESSION_STATUS}}
-- **Resume From Phase**: {{RESUME_PHASE}}
-- **Init Status**: {{INIT_DONE}} | Artifacts: spec={{HAS_SPEC}} plan={{HAS_PLAN}} tasks={{HAS_TASKS}}
+- `bootstrap-tier1.md` — Tier 1: Single Agent (complexity: low)
+- `bootstrap-tier2.md` — Tier 2: Dual Agent (complexity: medium)
+- `bootstrap-tier3.md` — Tier 3: Full Team (complexity: high)
 
-## Your Mission
-
-You are the **session orchestrator**. Implement Feature {{FEATURE_ID}}: "{{FEATURE_TITLE}}".
-
-**CRITICAL SESSION LIFECYCLE RULE**: You are the main session process. You MUST NOT exit until ALL work is complete and session-status.json is written. When you spawn subagents, you MUST **wait for each to finish** (run_in_background=false) before proceeding. Do NOT spawn an agent in the background and exit — that kills the session.
-
-**MANDATORY TEAM REQUIREMENT**: You MUST use the `prizm-dev-team` multi-agent team to complete this feature. This is NON-NEGOTIABLE. You are FORBIDDEN from implementing the feature as a single agent — all work MUST be distributed through the prizm-dev-team members (PM, Dev, Reviewer). Specifically:
-1. You MUST ensure a prizm-dev-team is available before starting any phase (see Step 1 below for reuse-or-create logic)
-2. You MUST spawn PM, Dev, and Reviewer agents using the `Task` tool with `team_name` and `subagent_type` parameters
-3. Every implementation, planning, and review phase MUST be executed by the appropriate team agent — NOT by you directly
-4. If you attempt to do the work yourself without spawning team agents, the session is considered FAILED
-
-### Team Definition Reference
-
-The prizm-dev-team definition is maintained in the project at:
-- **Source of truth**: `core/team/prizm-dev-team.json`
-- **Installed team config (current platform)**: `{{TEAM_CONFIG_PATH}}`
-  - CodeBuddy: `~/.codebuddy/teams/prizm-dev-team/config.json` — full team config with members, may support reuse
-  - Claude Code: `.claude/team-info.json` — reference only (no native team system; agents are in `.claude/agents/`)
-
-When creating a new team, use these files as reference for team member names, roles, agentTypes, and prompts.
-
-### Feature Description
-
-{{FEATURE_DESCRIPTION}}
-
-### Acceptance Criteria
-
-{{ACCEPTANCE_CRITERIA}}
-
-### Dependencies (Already Completed)
-
-{{COMPLETED_DEPENDENCIES}}
-
-### App Global Context
-
-{{GLOBAL_CONTEXT}}
-
-## PrizmKit Directory Convention
-
-**ALWAYS** use per-feature subdirectory `.prizmkit/specs/{{FEATURE_SLUG}}/`:
-
-```
-.prizmkit/specs/{{FEATURE_SLUG}}/spec.md
-.prizmkit/specs/{{FEATURE_SLUG}}/plan.md
-.prizmkit/specs/{{FEATURE_SLUG}}/tasks.md
-.prizmkit/specs/REGISTRY.md
-```
-
-## Execution Instructions
-
-**YOU are the orchestrator. Do NOT delegate to a Coordinator agent. Execute each phase yourself by spawning the appropriate team agent with run_in_background=false and waiting for its result.**
-
-**TEAM ENFORCEMENT**: Every phase below that mentions spawning a PM/Dev/Reviewer agent MUST use the `Task` tool with the active team's `team_name`. You MUST NOT skip the team setup step or attempt to perform PM/Dev/Reviewer work yourself. Violation of this rule constitutes a session failure.
-
-### Step 1: Initialize
-
-#### Team Setup: Reuse or Create
-
-Different AI CLI platforms have different team lifecycle behaviors. Some support reusing an existing team across sessions; others require creating a new team every time.
-
-**Follow this logic to determine team availability:**
-
-1. **Check if a team already exists and can be reused**:
-   - Read the team config file at `{{TEAM_CONFIG_PATH}}`
-   - If it exists and is valid (has members with correct agentTypes like `prizm-dev-team-pm`, `prizm-dev-team-dev`, `prizm-dev-team-reviewer`), try to reuse it
-   - Set `TEAM_REUSED=true` and record the `team_name` from the config
-
-2. **If no reusable team exists, create a new one**:
-   - Reference the team definition at `core/team/prizm-dev-team.json` (source of truth for member roles and prompts)
-   - Call `TeamCreate` with `team_name="prizm-dev-team-{{FEATURE_ID}}"` and `description="Implementing {{FEATURE_TITLE}}"`
-   - Set `TEAM_REUSED=false`
-
-3. **Record which path was taken** — this determines whether `TeamDelete` is needed at the end (only delete if you created; do NOT delete a reused team)
-
-{{IF_FRESH_START}}
-#### Initialize dev-team directories
-
-```bash
-python3 {{INIT_SCRIPT_PATH}} --project-root {{PROJECT_ROOT}} --feature-id {{FEATURE_ID}} --feature-slug {{FEATURE_SLUG}}
-```
-{{END_IF_FRESH_START}}
-
-{{IF_RESUME}}
-#### Resume Context
-
-This is a **resume** from Phase {{RESUME_PHASE}}. After completing the team setup above:
-1. Read artifacts in `.prizmkit/specs/{{FEATURE_SLUG}}/` (spec.md, plan.md, tasks.md)
-2. Resume the pipeline from Phase {{RESUME_PHASE}} below
-{{END_IF_RESUME}}
-
-### Step 2: Pipeline Phases
-
-{{IF_INIT_NEEDED}}
-#### 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
-{{END_IF_INIT_NEEDED}}
-{{IF_INIT_DONE}}
-#### Phase 0: SKIP (already initialized)
-{{END_IF_INIT_DONE}}
-
-{{IF_MODE_LITE}}
-#### Phase 1-3: Lightweight Planning (combined)
-- Spawn PM agent (Task tool, subagent_type="prizm-dev-team-pm", run_in_background=false)
-  Prompt: "Read {{PM_SUBAGENT_PATH}}. For feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}), create a CONCISE implementation plan. Write:
-  1. `.prizmkit/specs/{{FEATURE_SLUG}}/plan.md` — brief architecture (under 100 lines): key components, data flow, file structure
-  2. `.prizmkit/specs/{{FEATURE_SLUG}}/tasks.md` — task checklist with `[ ]` checkboxes, each task = one implementable unit
-  Do NOT generate spec.md. Keep it minimal."
-- **Wait for PM to return**
-- **CP-1**: plan.md and tasks.md exist
-
-#### Phase 4: SKIP (lite mode)
-{{END_IF_MODE_LITE}}
-
-{{IF_MODE_STANDARD}}
-#### Phase 1-3: Specify + Plan + Tasks (combined, one PM session)
-- Spawn PM agent (Task tool, subagent_type="prizm-dev-team-pm", run_in_background=false)
-  Prompt: "Read {{PM_SUBAGENT_PATH}}. For feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}), complete all three planning steps in this single session:
-  1. Run prizmkit-specify → generate `.prizmkit/specs/{{FEATURE_SLUG}}/spec.md` (concise, under 150 lines)
-  2. Run prizmkit-plan → generate `.prizmkit/specs/{{FEATURE_SLUG}}/plan.md` (architecture, components, interface design, data model, testing strategy — all in one file)
-  3. Run prizmkit-tasks → generate `.prizmkit/specs/{{FEATURE_SLUG}}/tasks.md` with `[ ]` checkboxes
-  All three files go under `.prizmkit/specs/{{FEATURE_SLUG}}/`."
-- **Wait for PM to return**
-- **CP-1**: spec.md, plan.md, and tasks.md all exist
-
-#### Phase 4: Analyze (cross-check)
-- Spawn Reviewer agent (Task tool, subagent_type="prizm-dev-team-reviewer", run_in_background=false)
-  Prompt: "Read {{REVIEWER_SUBAGENT_PATH}}. Run prizmkit-analyze for feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}). Cross-check `.prizmkit/specs/{{FEATURE_SLUG}}/spec.md`, `plan.md`, and `tasks.md` for consistency. Report any CRITICAL or HIGH issues."
-- **Wait for Reviewer to return**
-- If CRITICAL issues found: spawn PM to fix, then re-run analyze (max 1 round)
-- **CP-2**: No CRITICAL issues
-{{END_IF_MODE_STANDARD}}
-
-{{IF_MODE_FULL}}
-#### Phase 1-3: Specify + Plan + Tasks (combined, one PM session)
-- Spawn PM agent (Task tool, subagent_type="prizm-dev-team-pm", run_in_background=false)
-  Prompt: "Read {{PM_SUBAGENT_PATH}}. For feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}), complete all three planning steps in this single session:
-  1. Run prizmkit-specify → generate `.prizmkit/specs/{{FEATURE_SLUG}}/spec.md`. If there are `[NEEDS CLARIFICATION]` markers, run prizmkit-clarify to resolve them.
-  2. Run prizmkit-plan → generate `.prizmkit/specs/{{FEATURE_SLUG}}/plan.md` (architecture, components, interface design, data model, testing strategy, risk assessment — all in one file)
-  3. Run prizmkit-tasks → generate `.prizmkit/specs/{{FEATURE_SLUG}}/tasks.md` with `[ ]` checkboxes
-  All three files go under `.prizmkit/specs/{{FEATURE_SLUG}}/`."
-- **Wait for PM to return**
-- **CP-1**: spec.md, plan.md, and tasks.md all exist
-
-#### Phase 4: Analyze (cross-check)
-- Spawn Reviewer agent (Task tool, subagent_type="prizm-dev-team-reviewer", run_in_background=false)
-  Prompt: "Read {{REVIEWER_SUBAGENT_PATH}}. Run prizmkit-analyze for feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}). Cross-check `.prizmkit/specs/{{FEATURE_SLUG}}/spec.md`, `plan.md`, and `tasks.md` for consistency. Report any CRITICAL or HIGH issues."
-- **Wait for Reviewer to return**
-- If CRITICAL issues found: spawn PM to fix, then re-run analyze (max 1 round)
-- **CP-2**: No CRITICAL issues
-{{END_IF_MODE_FULL}}
-
-#### Phase 5: Schedule & Implement
-- Read tasks from `.prizmkit/specs/{{FEATURE_SLUG}}/tasks.md`
-- Create TaskList entries and assign to Dev agents
-- Spawn Dev agent (Task tool, subagent_type="prizm-dev-team-dev", run_in_background=false)
-  Prompt: "Read {{DEV_SUBAGENT_PATH}}. Implement all tasks for feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}) using prizmkit-implement with TDD. Read the plan from `.prizmkit/specs/{{FEATURE_SLUG}}/plan.md` and tasks from `tasks.md`. Mark completed tasks [x] in tasks.md."
-- **Wait for Dev to return**
-- All tasks marked `[x]`, tests pass
-
-#### Phase 6: Review
-- Spawn Reviewer agent (Task tool, subagent_type="prizm-dev-team-reviewer", run_in_background=false)
-  Prompt: "Read {{REVIEWER_SUBAGENT_PATH}}. For feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}):
-  1. Run prizmkit-code-review for spec compliance and code quality
-  2. Write and execute integration tests covering all user stories from spec.md
-  Report verdict: PASS, PASS_WITH_WARNINGS, or NEEDS_FIXES."
-- **Wait for Reviewer to return**
-- If NEEDS_FIXES: spawn Dev to fix, then re-run Review (max 3 rounds)
-- **CP-3**: Integration tests pass, review verdict is not NEEDS_FIXES
-
-#### Phase 7: Summarize & Commit — DO NOT SKIP
-
-**IMPORTANT**: Phase 7 is for **new feature** commits only. If this session is a bug fix to an existing feature, skip `prizmkit.summarize` (do NOT create new REGISTRY.md entries for bug fixes — bugs are refinements of incomplete features, not new functionality). Still run `prizmkit.committer` with `fix(<scope>):` prefix.
-
-**7a.** Run `prizmkit.summarize` (invoke the prizmkit-summarize skill) → archive to REGISTRY.md
-
-**7b.** BEFORE commit, mark current feature as completed in feature-list:
-```bash
-python3 {{VALIDATOR_SCRIPTS_DIR}}/update-feature-status.py \
-  --feature-list "{{FEATURE_LIST_PATH}}" \
-  --state-dir "{{PROJECT_ROOT}}/dev-pipeline/state" \
-  --feature-id "{{FEATURE_ID}}" \
-  --session-id "{{SESSION_ID}}" \
-  --action complete
-```
-
-**7c.** Run `prizmkit.committer` (invoke the prizmkit-committer skill) → `feat({{FEATURE_ID}}): {{FEATURE_TITLE}}`, do NOT push
-
-### Step 3: Report Session Status
-
-**CRITICAL**: Before this session ends, you MUST write the session status file.
-
-Write to: `{{SESSION_STATUS_PATH}}`
-
-```json
-{
-  "session_id": "{{SESSION_ID}}",
-  "feature_id": "{{FEATURE_ID}}",
-  "feature_slug": "{{FEATURE_SLUG}}",
-  "status": "<success|partial|failed>",
-  "completed_phases": [0, 1, 2, 3, 4, 5, 6, 7],
-  "current_phase": 7,
-  "checkpoint_reached": "CP-3",
-  "tasks_completed": 12,
-  "tasks_total": 12,
-  "errors": [],
-  "can_resume": false,
-  "resume_from_phase": null,
-  "artifacts": {
-    "spec_path": ".prizmkit/specs/{{FEATURE_SLUG}}/spec.md",
-    "plan_path": ".prizmkit/specs/{{FEATURE_SLUG}}/plan.md",
-    "tasks_path": ".prizmkit/specs/{{FEATURE_SLUG}}/tasks.md"
-  },
-  "git_commit": "<commit hash if Phase 7 completed>",
-  "timestamp": "2026-03-04T10:00:00Z"
-}
-```
-
-**Status values**: `success` (all phases done) | `partial` (can resume) | `failed` (unrecoverable)
-
-If you encounter an error, still write session-status.json with status="failed" and error details.
-
-### Step 4: Team Cleanup (conditional)
-
-**Only if you CREATED the team in Step 1** (i.e. `TEAM_REUSED=false`), clean up:
-```
-TeamDelete
-```
-
-**If you REUSED an existing team** (i.e. `TEAM_REUSED=true`), do NOT call `TeamDelete` — the team is shared and may be used by other sessions.
-
-## Critical Paths
-
-| Resource | Path |
-|----------|------|
-| Team Definition (source of truth) | `core/team/prizm-dev-team.json` |
-| Team Config (installed) | `{{TEAM_CONFIG_PATH}}` |
-| Feature Artifacts Dir | `.prizmkit/specs/{{FEATURE_SLUG}}/` |
-| PM Agent Def | {{PM_SUBAGENT_PATH}} |
-| Dev Agent Def | {{DEV_SUBAGENT_PATH}} |
-| Reviewer Agent Def | {{REVIEWER_SUBAGENT_PATH}} |
-| Session Status Output | {{SESSION_STATUS_PATH}} |
-| Project Root | {{PROJECT_ROOT}} |
-| Feature List Path | {{FEATURE_LIST_PATH}} |
-
-## Reminders
-
-- **MANDATORY**: You MUST use `prizm-dev-team` (reuse existing or create new) — single-agent execution is FORBIDDEN
-- **Team definition source**: `core/team/prizm-dev-team.json`; installed at `{{TEAM_CONFIG_PATH}}`
-- **All artifacts go under `.prizmkit/specs/{{FEATURE_SLUG}}/`** — only 3 files: spec.md, plan.md, tasks.md
-- Dev agents use TDD approach
-- Phase 7 (summarize + commit) is MANDATORY
-- ALWAYS write session-status.json before exiting
-- **NEVER exit the session early** — wait for all spawned agents to complete
-- Do NOT use `run_in_background=true` when spawning agents
-- Only call `TeamDelete` if you created the team; do NOT delete a reused team
+`generate-bootstrap-prompt.py` selects the correct file automatically based on `estimated_complexity`.
+This file is kept as a fallback only — if none of the tier files exist, the script falls back to this path.

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

@@ -0,0 +1,171 @@
+# Dev-Pipeline Session Bootstrap — Tier 1 (Single Agent)
+
+## 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}} tasks={{HAS_TASKS}}
+
+## Your Mission
+
+You are the **session orchestrator**. Implement Feature {{FEATURE_ID}}: "{{FEATURE_TITLE}}".
+
+**CRITICAL**: You MUST NOT exit until ALL work is complete and session-status.json is written.
+
+**Tier 1 — Single Agent**: You handle everything directly. No subagents, no TeamCreate.
+
+### Feature Description
+
+{{FEATURE_DESCRIPTION}}
+
+### Acceptance Criteria
+
+{{ACCEPTANCE_CRITERIA}}
+
+### Dependencies (Already Completed)
+
+{{COMPLETED_DEPENDENCIES}}
+
+### App Global Context
+
+{{GLOBAL_CONTEXT}}
+
+## PrizmKit Directory Convention
+
+```
+.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md
+.prizmkit/specs/{{FEATURE_SLUG}}/plan.md
+.prizmkit/specs/{{FEATURE_SLUG}}/tasks.md
+.prizmkit/specs/REGISTRY.md
+```
+
+---
+
+## Execution
+
+{{IF_INIT_NEEDED}}
+### 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
+{{END_IF_INIT_NEEDED}}
+{{IF_INIT_DONE}}
+### Phase 0: SKIP (already initialized)
+{{END_IF_INIT_DONE}}
+
+{{IF_RESUME}}
+### Resume from Phase {{RESUME_PHASE}}
+Check `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` — if it exists, skip Phase 1 and use it directly.
+{{END_IF_RESUME}}
+
+### Phase 1: Build Context Snapshot
+
+```bash
+ls .prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md 2>/dev/null && echo "EXISTS" || echo "MISSING"
+```
+
+If MISSING — build it now:
+1. Read `.prizm-docs/root.prizm` and relevant L1 prizm docs
+2. Scan `src/` for files related to this feature; read each one
+3. Write `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md`:
+   - **Section 1 — Feature Brief**: feature description + acceptance criteria (copy from above)
+   - **Section 2 — Project Structure**: output of relevant `ls src/` calls
+   - **Section 3 — Prizm Context**: content of root.prizm and relevant L1/L2 docs
+   - **Section 4 — Existing Source Files**: full content of each related file as code block
+   - **Section 5 — Existing Tests**: full content of related test files as code block
+
+### Phase 2: Plan & Tasks
+
+```bash
+ls .prizmkit/specs/{{FEATURE_SLUG}}/ 2>/dev/null
+```
+
+If plan.md or tasks.md missing, write them directly (no PM needed):
+- `plan.md`: key components, data flow, files to create/modify (under 80 lines)
+- `tasks.md`: checklist with `[ ]` checkboxes, each task = one implementable unit
+
+**CP-1**: plan.md and tasks.md exist.
+
+### Phase 3: Implement
+
+For each task in tasks.md:
+1. Read the relevant section from `context-snapshot.md` (no need to re-read individual files)
+2. Write/edit the code
+3. Run tests after each task
+4. Mark task `[x]` in tasks.md immediately
+
+After all tasks complete, append to `context-snapshot.md`:
+```
+## Implementation Log
+Files changed/created: [list]
+Key decisions: [list]
+```
+
+### Phase 4: Self-Review
+
+1. Re-read acceptance criteria from Section 1 of context-snapshot.md
+2. Run the full test suite
+3. Check error handling and edge cases
+4. Fix any issues found
+
+**CP-2**: All acceptance criteria met, tests pass.
+
+### Phase 5: Commit
+
+- Run `prizmkit.summarize` → archive to REGISTRY.md
+- Mark feature complete:
+  ```bash
+  python3 {{VALIDATOR_SCRIPTS_DIR}}/update-feature-status.py \
+    --feature-list "{{FEATURE_LIST_PATH}}" \
+    --state-dir "{{PROJECT_ROOT}}/dev-pipeline/state" \
+    --feature-id "{{FEATURE_ID}}" --session-id "{{SESSION_ID}}" --action complete
+  ```
+- Run `prizmkit.committer` → `feat({{FEATURE_ID}}): {{FEATURE_TITLE}}`, do NOT push
+
+---
+
+## Step 3: Write Session Status
+
+Write to: `{{SESSION_STATUS_PATH}}`
+
+```json
+{
+  "session_id": "{{SESSION_ID}}",
+  "feature_id": "{{FEATURE_ID}}",
+  "feature_slug": "{{FEATURE_SLUG}}",
+  "exec_tier": 1,
+  "status": "<success|partial|failed>",
+  "completed_phases": [0, 1, 2, 3, 4, 5],
+  "current_phase": 5,
+  "checkpoint_reached": "CP-2",
+  "tasks_completed": 0,
+  "tasks_total": 0,
+  "errors": [],
+  "can_resume": false,
+  "resume_from_phase": null,
+  "artifacts": {
+    "context_snapshot_path": ".prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md",
+    "plan_path": ".prizmkit/specs/{{FEATURE_SLUG}}/plan.md",
+    "tasks_path": ".prizmkit/specs/{{FEATURE_SLUG}}/tasks.md"
+  },
+  "git_commit": "<commit hash>",
+  "timestamp": "2026-03-04T10:00:00Z"
+}
+```
+
+## Critical Paths
+
+| Resource | Path |
+|----------|------|
+| Feature Artifacts Dir | `.prizmkit/specs/{{FEATURE_SLUG}}/` |
+| Context Snapshot | `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` |
+| Session Status Output | {{SESSION_STATUS_PATH}} |
+| Project Root | {{PROJECT_ROOT}} |
+
+## Reminders
+
+- Tier 1: you do everything — no subagents, no TeamCreate
+- Build context-snapshot.md FIRST; use it throughout instead of re-reading files
+- ALWAYS write session-status.json before exiting
+- `prizmkit.committer` is mandatory — do NOT skip the commit phase

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

@@ -0,0 +1,201 @@
+# Dev-Pipeline Session Bootstrap — Tier 2 (Dual Agent)
+
+## 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}} tasks={{HAS_TASKS}}
+
+## Your Mission
+
+You are the **session orchestrator**. Implement Feature {{FEATURE_ID}}: "{{FEATURE_TITLE}}".
+
+**CRITICAL**: You MUST NOT exit until ALL work is complete and session-status.json is written. When you spawn 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. No TeamCreate required.
+
+### Feature Description
+
+{{FEATURE_DESCRIPTION}}
+
+### Acceptance Criteria
+
+{{ACCEPTANCE_CRITERIA}}
+
+### Dependencies (Already Completed)
+
+{{COMPLETED_DEPENDENCIES}}
+
+### App Global Context
+
+{{GLOBAL_CONTEXT}}
+
+## PrizmKit Directory Convention
+
+```
+.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md  ← written by you, read by Dev + Reviewer
+.prizmkit/specs/{{FEATURE_SLUG}}/plan.md
+.prizmkit/specs/{{FEATURE_SLUG}}/tasks.md
+.prizmkit/specs/REGISTRY.md
+```
+
+**`context-snapshot.md`** is the shared knowledge base. You write it once; Dev and Reviewer read it instead of re-scanning individual files.
+
+---
+
+## Subagent Timeout Recovery
+
+If a subagent times out:
+1. `ls .prizmkit/specs/{{FEATURE_SLUG}}/` — check what exists
+2. Re-spawn with: `"Read .prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md for full context. Do NOT re-read individual source files."` + only remaining steps + `model: "lite"`
+3. Max 2 retries. After 2 failures, complete the work yourself.
+
+---
+
+## Execution
+
+{{IF_INIT_NEEDED}}
+### 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
+{{END_IF_INIT_NEEDED}}
+{{IF_INIT_DONE}}
+### Phase 0: SKIP (already initialized)
+{{END_IF_INIT_DONE}}
+
+{{IF_RESUME}}
+### Resume from Phase {{RESUME_PHASE}}
+Check `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` — if exists, skip Phase 1 and proceed to Phase {{RESUME_PHASE}}.
+{{END_IF_RESUME}}
+
+### Phase 1: Build Context Snapshot (you, the orchestrator)
+
+```bash
+ls .prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md 2>/dev/null && echo "EXISTS" || echo "MISSING"
+```
+
+If MISSING — build it now:
+1. Read `.prizm-docs/root.prizm` and relevant L1/L2 prizm docs
+2. Scan `src/` for files related to this feature; read each one
+3. Write `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md`:
+   - **Section 1 — Feature Brief**: feature description + acceptance criteria (copy from above)
+   - **Section 2 — Project Structure**: relevant `ls src/` output
+   - **Section 3 — Prizm Context**: full content of root.prizm and relevant L1/L2 docs
+   - **Section 4 — Existing Source Files**: full content of each related file as code block
+   - **Section 5 — Existing Tests**: full content of related test files as code blocks
+
+### Phase 2: Plan & Tasks (you, the orchestrator)
+
+```bash
+ls .prizmkit/specs/{{FEATURE_SLUG}}/plan.md .prizmkit/specs/{{FEATURE_SLUG}}/tasks.md 2>/dev/null
+```
+
+If either missing, write them yourself:
+- `plan.md`: architecture — components, interfaces, data flow, files to create/modify, testing approach
+- `tasks.md`: checklist with `[ ]` checkboxes ordered by dependency
+
+**CP-1**: plan.md and tasks.md exist.
+
+### Phase 3: Implement — Dev Subagent
+
+Spawn Dev subagent (Task tool, subagent_type="prizm-dev-team-dev", run_in_background=false).
+
+Prompt:
+> "Read {{DEV_SUBAGENT_PATH}}. Implement feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}).
+>
+> 1. Read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` FIRST — all project context, source files, and tests are embedded there. Do NOT re-read individual source files.
+> 2. Read `.prizmkit/specs/{{FEATURE_SLUG}}/plan.md` and `.prizmkit/specs/{{FEATURE_SLUG}}/tasks.md`.
+> 3. Implement task-by-task using TDD. Mark each task `[x]` in tasks.md immediately after completion.
+> 4. After ALL tasks complete, append an 'Implementation Log' section to `context-snapshot.md`:
+>    - Files created/modified (with paths)
+>    - Key implementation decisions
+>    - Any deviations from plan.md
+> Do NOT exit until all tasks are [x] and the Implementation Log is written."
+
+Wait for Dev to return. All tasks must be `[x]`, tests pass.
+
+### Phase 4: Review — Reviewer Subagent
+
+Spawn Reviewer subagent (Task tool, subagent_type="prizm-dev-team-reviewer", run_in_background=false).
+
+Prompt:
+> "Read {{REVIEWER_SUBAGENT_PATH}}. Review feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}).
+>
+> 1. Read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` FIRST:
+>    - Section 1: acceptance criteria to verify against
+>    - Section 4: original source files (before changes)
+>    - 'Implementation Log': what Dev changed
+> 2. Run prizmkit-code-review: verify all acceptance criteria, check code quality and correctness. Only read files mentioned in the Implementation Log.
+> 3. Run the test suite and report results.
+> 4. Append a 'Review Notes' section to `context-snapshot.md`: issues found (severity), test results, final verdict.
+> Report verdict: PASS, PASS_WITH_WARNINGS, or NEEDS_FIXES."
+
+Wait for Reviewer to return.
+- If NEEDS_FIXES: spawn Dev to fix (Dev reads updated snapshot), re-run Review (max 3 rounds)
+
+**CP-2**: Tests pass, verdict is not NEEDS_FIXES.
+
+### Phase 5: Commit
+
+- Run `prizmkit.summarize` → archive to REGISTRY.md
+- Mark feature complete:
+  ```bash
+  python3 {{VALIDATOR_SCRIPTS_DIR}}/update-feature-status.py \
+    --feature-list "{{FEATURE_LIST_PATH}}" \
+    --state-dir "{{PROJECT_ROOT}}/dev-pipeline/state" \
+    --feature-id "{{FEATURE_ID}}" --session-id "{{SESSION_ID}}" --action complete
+  ```
+- Run `prizmkit.committer` → `feat({{FEATURE_ID}}): {{FEATURE_TITLE}}`, do NOT push
+
+---
+
+## Step 3: Write Session Status
+
+Write to: `{{SESSION_STATUS_PATH}}`
+
+```json
+{
+  "session_id": "{{SESSION_ID}}",
+  "feature_id": "{{FEATURE_ID}}",
+  "feature_slug": "{{FEATURE_SLUG}}",
+  "exec_tier": 2,
+  "status": "<success|partial|failed>",
+  "completed_phases": [0, 1, 2, 3, 4, 5],
+  "current_phase": 5,
+  "checkpoint_reached": "CP-2",
+  "tasks_completed": 0,
+  "tasks_total": 0,
+  "errors": [],
+  "can_resume": false,
+  "resume_from_phase": null,
+  "artifacts": {
+    "context_snapshot_path": ".prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md",
+    "plan_path": ".prizmkit/specs/{{FEATURE_SLUG}}/plan.md",
+    "tasks_path": ".prizmkit/specs/{{FEATURE_SLUG}}/tasks.md"
+  },
+  "git_commit": "<commit hash>",
+  "timestamp": "2026-03-04T10:00:00Z"
+}
+```
+
+## Critical Paths
+
+| Resource | Path |
+|----------|------|
+| Feature Artifacts Dir | `.prizmkit/specs/{{FEATURE_SLUG}}/` |
+| Context Snapshot | `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` |
+| Dev Agent Def | {{DEV_SUBAGENT_PATH}} |
+| Reviewer Agent Def | {{REVIEWER_SUBAGENT_PATH}} |
+| Session Status Output | {{SESSION_STATUS_PATH}} |
+| Project Root | {{PROJECT_ROOT}} |
+
+## Reminders
+
+- Tier 2: orchestrator builds context+plan, Dev implements, Reviewer reviews — no TeamCreate
+- Build context-snapshot.md FIRST; all subagents read it instead of re-reading source files
+- Do NOT use `run_in_background=true` when spawning subagents
+- ALWAYS write session-status.json before exiting
+- `prizmkit.committer` is mandatory
+- On timeout: check snapshot → model:lite → remaining steps only → max 2 retries → orchestrator fallback

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

@@ -0,0 +1,314 @@
+# Dev-Pipeline Session Bootstrap — Tier 3 (Full Team)
+
+## 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}} tasks={{HAS_TASKS}}
+
+## Your Mission
+
+You are the **session orchestrator**. Implement Feature {{FEATURE_ID}}: "{{FEATURE_TITLE}}".
+
+**CRITICAL**: You MUST NOT exit until ALL work is complete and session-status.json is written. When you spawn subagents, wait for each to finish (run_in_background=false). Do NOT spawn agents in background and exit — that kills the session.
+
+**Tier 3 — Full Team**: PM + Dev + Reviewer agents spawned directly via Task tool. Full 7-phase pipeline.
+
+### Feature Description
+
+{{FEATURE_DESCRIPTION}}
+
+### Acceptance Criteria
+
+{{ACCEPTANCE_CRITERIA}}
+
+### Dependencies (Already Completed)
+
+{{COMPLETED_DEPENDENCIES}}
+
+### App Global Context
+
+{{GLOBAL_CONTEXT}}
+
+## PrizmKit Directory Convention
+
+```
+.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md  ← PM writes, all agents read
+.prizmkit/specs/{{FEATURE_SLUG}}/spec.md
+.prizmkit/specs/{{FEATURE_SLUG}}/plan.md
+.prizmkit/specs/{{FEATURE_SLUG}}/tasks.md
+.prizmkit/specs/REGISTRY.md
+```
+
+**`context-snapshot.md`** is the shared knowledge base. PM writes it once; Dev and Reviewer read it instead of re-scanning source files. This eliminates redundant I/O across all agents.
+
+### Agent Files
+- PM Agent: `{{PM_SUBAGENT_PATH}}`
+- Dev Agent: `{{DEV_SUBAGENT_PATH}}`
+- Reviewer Agent: `{{REVIEWER_SUBAGENT_PATH}}`
+
+---
+
+## 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 full context. Do NOT re-read individual source files."` + 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.
+
+---
+
+## Execution
+
+{{IF_INIT_NEEDED}}
+### 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
+{{END_IF_INIT_NEEDED}}
+{{IF_INIT_DONE}}
+### Phase 0: Record Test Baseline & Detect Test Command
+
+**Step 1 — Detect the correct test command** (run once, save as `TEST_CMD`):
+```bash
+# Try in order, use the first one that exits 0
+node --test tests/**/*.test.js 2>&1 | tail -3   # Node built-in
+npm test 2>&1 | tail -3                          # npm script fallback
+```
+Record the working command as `TEST_CMD`. If both fail, record `TEST_CMD="npm test"` as default.
+
+**Step 2 — Record pre-existing failure baseline**:
+```bash
+$TEST_CMD 2>&1 | 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.
+{{END_IF_INIT_DONE}}
+
+### Step 1: Team Setup
+
+No TeamCreate required. Agents are spawned directly via the `Task` tool using `subagent_type`.
+
+1. Run init script:
+   `python3 {{INIT_SCRIPT_PATH}} --project-root {{PROJECT_ROOT}} --feature-id {{FEATURE_ID}} --feature-slug {{FEATURE_SLUG}}`
+
+2. Check for existing artifacts:
+   `ls .prizmkit/specs/{{FEATURE_SLUG}}/ 2>/dev/null`
+
+Agent files are at:
+- PM: `{{PM_SUBAGENT_PATH}}`
+- Dev: `{{DEV_SUBAGENT_PATH}}`
+- Reviewer: `{{REVIEWER_SUBAGENT_PATH}}`
+
+{{IF_FRESH_START}}
+```bash
+python3 {{INIT_SCRIPT_PATH}} --project-root {{PROJECT_ROOT}} --feature-id {{FEATURE_ID}} --feature-slug {{FEATURE_SLUG}}
+```
+{{END_IF_FRESH_START}}
+
+{{IF_RESUME}}
+### Resume from Phase {{RESUME_PHASE}}
+After team setup: check `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` — if exists, all agents MUST use it. Read existing artifacts and resume from Phase {{RESUME_PHASE}}.
+{{END_IF_RESUME}}
+
+### Phase 1-3: Specify + Plan + Tasks — PM Agent
+
+Check existing artifacts first:
+```bash
+ls .prizmkit/specs/{{FEATURE_SLUG}}/ 2>/dev/null
+```
+
+- All three (spec.md, plan.md, tasks.md) exist → **SKIP to CP-1**
+- `context-snapshot.md` exists → PM reads it instead of re-scanning source files
+- Some missing → PM generates only missing files
+
+Before spawning PM, check whether feature code already exists in the project:
+```bash
+grep -r "{{FEATURE_SLUG}}" src/ --include="*.js" --include="*.ts" -l 2>/dev/null | head -20
+```
+
+Record result as `EXISTING_CODE` (list of files, or empty). Pass this to PM prompt below.
+
+Spawn PM agent (Task tool, subagent_type="prizm-dev-team-pm", run_in_background=false).
+
+**Construct prompt dynamically** — always prefix with:
+> "Read {{PM_SUBAGENT_PATH}}. For feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}), complete the following IN THIS SINGLE SESSION — do NOT exit until ALL listed steps are done and files are written to disk:"
+
+If `EXISTING_CODE` is non-empty, append to prefix:
+> "NOTE: The following files related to this feature already exist in the codebase: `<EXISTING_CODE list>`. 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** (include only if `context-snapshot.md` does NOT exist):
+> "Step A: Write `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md`. This is the team knowledge base — complete it before anything else. Include:
+> - Section 1 'Feature Brief': feature description and acceptance criteria
+> - Section 2 'Project Structure': output of `ls src/` and relevant subdirectories
+> - Section 3 'Prizm Context': full content of `.prizm-docs/root.prizm` and relevant L1/L2 docs
+> - Section 4 'Existing Source Files': full content of every related source file as a code block
+> - Section 5 'Existing Tests': full content of related test files as code blocks
+> Confirm with `ls .prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md`."
+
+**Step B — Planning Artifacts** (include only missing files):
+- spec.md missing: "Run prizmkit-specify → 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 — all in one file)"
+- tasks.md missing: "Run prizmkit-tasks → generate tasks.md with `[ ]` checkboxes"
+
+> "All files go under `.prizmkit/specs/{{FEATURE_SLUG}}/`. Confirm each with `ls` after writing."
+
+Wait for PM to return. **CP-1**: All three files exist. If missing, diagnose from PM output — do NOT spawn another PM blindly.
+
+### Phase 4: Analyze — Reviewer Agent
+
+Spawn Reviewer agent (Task tool, subagent_type="prizm-dev-team-reviewer", run_in_background=false).
+
+Prompt:
+> "Read {{REVIEWER_SUBAGENT_PATH}}. For feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}):
+> 1. Read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` FIRST — all source files and project context are there. Do NOT re-read individual source files.
+> 2. Run prizmkit-analyze: cross-check `spec.md`, `plan.md`, and `tasks.md` for consistency.
+> 3. Before flagging CRITICAL or HIGH issues, verify each against Section 4 of the snapshot. Do NOT report based on incomplete information.
+> Report: CRITICAL, HIGH, MEDIUM issues found (or 'No issues found')."
+
+Wait for Reviewer to return.
+- If CRITICAL issues found: spawn PM to fix — use this prompt:
+  > "Read {{PM_SUBAGENT_PATH}}. Read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` FIRST for full project context. Do NOT re-read individual source files. Fix ONLY the following CRITICAL issues in spec.md/plan.md/tasks.md: `<list issues>`. Do NOT exit until all files are updated."
+  Then re-run analyze (max 1 round).
+
+**CP-2**: No CRITICAL issues.
+
+### Phase 5: Implement — Dev Agent
+
+Before spawning Dev, check tasks.md:
+```bash
+grep -c '^\- \[ \]' .prizmkit/specs/{{FEATURE_SLUG}}/tasks.md 2>/dev/null || echo 0
+```
+- If result is `0` (all tasks already `[x]`) → **SKIP Phase 5**, go directly to Phase 6. Do NOT spawn Dev.
+- If result is non-zero → spawn Dev agent below.
+
+Spawn Dev agent (Task tool, subagent_type="prizm-dev-team-dev", run_in_background=false).
+
+Prompt:
+> "Read {{DEV_SUBAGENT_PATH}}. Implement feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}) using TDD.
+> 1. Read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` FIRST — all source files and context are there. Do NOT re-read individual source files.
+> 2. Read `plan.md` and `tasks.md` from `.prizmkit/specs/{{FEATURE_SLUG}}/`.
+> 3. Implement task-by-task. Mark each `[x]` in tasks.md **immediately** after completion (do NOT batch).
+> 4. Use `TEST_CMD=<TEST_CMD>` to run tests — do NOT explore alternative test commands.
+> 5. After ALL tasks done, append 'Implementation Log' to context-snapshot.md: files changed/created, key decisions, deviations from plan.
+> 6. Do NOT execute any git commands (no git add/commit/reset/push).
+> 7. If `<TEST_CMD>` shows failures, check against BASELINE_FAILURES=`<BASELINE_FAILURES>`. Failures present in the baseline are pre-existing — list them explicitly in your COMPLETION_SIGNAL.
+> Do NOT exit until all tasks are [x] and the Implementation Log is written."
+
+Wait for Dev to return. **If Dev times out before all tasks are `[x]`**:
+1. Check progress: `grep -c '^\- \[ \]' .prizmkit/specs/{{FEATURE_SLUG}}/tasks.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 original source, 'Implementation Log' (if present) has what was already done. Do NOT re-read individual source files.
+   > 2. Read `tasks.md` — complete ONLY the remaining `[ ]` tasks. Do NOT redo completed `[x]` tasks.
+   > 3. Use `TEST_CMD=<TEST_CMD>` to run tests.
+   > 4. Append progress to 'Implementation Log' in context-snapshot.md.
+   > 5. Do NOT execute any git commands."
+3. Max 2 recovery retries. After 2 failures, orchestrator implements remaining tasks directly.
+
+All tasks `[x]`, tests pass.
+
+### Phase 6: Review — Reviewer Agent
+
+Spawn Reviewer agent (Task tool, subagent_type="prizm-dev-team-reviewer", run_in_background=false).
+
+Prompt:
+> "Read {{REVIEWER_SUBAGENT_PATH}}. For feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}):
+> 1. Read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` FIRST — Section 4 has original source files, 'Implementation Log' section lists exactly what Dev changed. Do NOT re-read source files that are NOT mentioned in the Implementation Log.
+> 2. Run prizmkit-code-review: spec compliance (against spec.md), code quality, correctness. Read ONLY files listed in Implementation Log.
+> 3. Write and execute integration tests covering all user stories from spec.md. Use `TEST_CMD=<TEST_CMD>` — do NOT try alternative test commands.
+> 4. Append 'Review Notes' to context-snapshot.md: issues (severity), test results, final verdict.
+> Report verdict: PASS, PASS_WITH_WARNINGS, or NEEDS_FIXES."
+
+Wait for Reviewer to return.
+- 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 lists the exact issues to fix. Do NOT re-read source files not mentioned there.
+  > 2. Fix ONLY the issues listed in 'Review Notes'. Do NOT refactor unrelated code.
+  > 3. Use `TEST_CMD=<TEST_CMD>` to verify fixes.
+  > 4. Append fix summary to 'Implementation Log' in context-snapshot.md.
+  > 5. Do NOT execute any git commands."
+  Then re-run Review (max 3 rounds).
+
+**CP-3**: Integration tests pass, verdict is not NEEDS_FIXES.
+
+### Phase 7: Summarize & Commit — DO NOT SKIP
+
+**For bug fixes**: skip `prizmkit.summarize`, use `fix(<scope>):` commit prefix.
+
+**7a.** Check if feature already committed:
+```bash
+git log --oneline | grep "{{FEATURE_ID}}" | head -3
+```
+- If a commit for `{{FEATURE_ID}}` already exists → **skip 7c** (do NOT run prizmkit.committer, do NOT run git reset, do NOT stage or unstage anything). Proceed directly to Step 3.
+- If no existing commit → proceed normally with 7a–7c.
+
+**7b.** Run `prizmkit.summarize` → archive to REGISTRY.md
+
+**7c.** Mark feature complete:
+```bash
+python3 {{VALIDATOR_SCRIPTS_DIR}}/update-feature-status.py \
+  --feature-list "{{FEATURE_LIST_PATH}}" \
+  --state-dir "{{PROJECT_ROOT}}/dev-pipeline/state" \
+  --feature-id "{{FEATURE_ID}}" --session-id "{{SESSION_ID}}" --action complete
+```
+
+**7d.** Run `prizmkit.committer` → `feat({{FEATURE_ID}}): {{FEATURE_TITLE}}`, do NOT push
+
+---
+
+## Step 3: Write Session Status
+
+Write to: `{{SESSION_STATUS_PATH}}`
+
+```json
+{
+  "session_id": "{{SESSION_ID}}",
+  "feature_id": "{{FEATURE_ID}}",
+  "feature_slug": "{{FEATURE_SLUG}}",
+  "exec_tier": 3,
+  "status": "<success|partial|failed>",
+  "completed_phases": [0, 1, 2, 3, 4, 5, 6, 7],
+  "current_phase": 7,
+  "checkpoint_reached": "CP-3",
+  "tasks_completed": 0,
+  "tasks_total": 0,
+  "errors": [],
+  "can_resume": false,
+  "resume_from_phase": null,
+  "artifacts": {
+    "context_snapshot_path": ".prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md",
+    "spec_path": ".prizmkit/specs/{{FEATURE_SLUG}}/spec.md",
+    "plan_path": ".prizmkit/specs/{{FEATURE_SLUG}}/plan.md",
+    "tasks_path": ".prizmkit/specs/{{FEATURE_SLUG}}/tasks.md"
+  },
+  "git_commit": "<commit hash>",
+  "timestamp": "2026-03-04T10:00:00Z"
+}
+```
+
+## Step 4: Team Cleanup
+
+No team cleanup needed — agents were spawned directly without TeamCreate.
+
+## Critical Paths
+
+| Resource | Path |
+|----------|------|
+| Feature Artifacts Dir | `.prizmkit/specs/{{FEATURE_SLUG}}/` |
+| Context Snapshot | `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` |
+| Team Config | `{{TEAM_CONFIG_PATH}}` |
+| PM Agent Def | {{PM_SUBAGENT_PATH}} |
+| Dev Agent Def | {{DEV_SUBAGENT_PATH}} |
+| Reviewer Agent Def | {{REVIEWER_SUBAGENT_PATH}} |
+| Session Status Output | {{SESSION_STATUS_PATH}} |
+| Project Root | {{PROJECT_ROOT}} |
+| Feature List Path | {{FEATURE_LIST_PATH}} |
+
+## Reminders
+
+- Tier 3: full team — PM (planning) → Dev (implementation) → Reviewer (review) — agents spawned directly via Task tool (no TeamCreate needed)
+- context-snapshot.md is the team knowledge base: PM writes it once, all agents read it
+- Do NOT use `run_in_background=true` when spawning agents
+- ALWAYS write session-status.json before exiting
+- On timeout: check snapshot → model:lite → remaining steps only → max 2 retries → orchestrator fallback

package/bundled/skills/prizmkit-plan/SKILL.md

@@ -18,8 +18,10 @@ Create a technical implementation plan for a specified feature.
 **STEPS:**
 
 **Phase 0 — Research:**
-1. Read `spec.md` and `.prizm-docs/root.prizm` for project context
-2. Read relevant `.prizm-docs/` L1/L2 docs for affected modules
+1. Read `spec.md` for feature requirements
+2. Load project context (use first available source):
+   - If `.prizmkit/specs/###-feature-name/context-snapshot.md` exists → read it for all context (Section 3 'Prizm Context' for docs, Section 4 'Existing Source Files' for code). Do NOT re-read `.prizm-docs/` or individual source files.
+   - Otherwise → read `.prizm-docs/root.prizm` and relevant `.prizm-docs/` L1/L2 docs for affected modules
 3. Resolve any remaining `[NEEDS CLARIFICATION]` by proposing solutions
 4. Research technical approach based on project's tech stack
 

package/bundled/skills/prizmkit-specify/SKILL.md

@@ -19,7 +19,9 @@ Create a new feature specification.
 2. Auto-generate 2-4 word feature slug from description
 3. Determine next feature number by scanning `.prizmkit/specs/`
 4. Create directory: `.prizmkit/specs/###-feature-name/`
-5. Read Prizm docs (`.prizm-docs/root.prizm`) for project context
+5. Load project context (use first available source):
+   - If `.prizmkit/specs/###-feature-name/context-snapshot.md` exists → read Section 3 'Prizm Context' from it (do NOT re-read `.prizm-docs/` files)
+   - Otherwise → read `.prizm-docs/root.prizm`
 6. Generate `spec.md` from template (`${SKILL_DIR}/assets/spec-template.md`) focusing on:
    - Feature title and description
    - User stories (As a... I want... So that...)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prizmkit",
-  "version": "1.0.11",
+  "version": "1.0.12",
   "description": "Create a new PrizmKit-powered project with clean initialization — no framework dev files, just what you need.",
   "type": "module",
   "bin": {