prizmkit 1.1.74 → 1.1.77

package/bundled/dev-pipeline-windows/scripts/parse-stream-progress.py

@@ -137,7 +137,10 @@ class ProgressTracker:
         self.event_format = ""
         self.active_subagent_count = 0
         self.subagent_status_counts = Counter()
+        self._subagent_spawn_count = 0
         self.codex_child_thread_ids = set()
+        self.cb_session_id = ""
+        self.cb_cwd = ""
         self.claude_session_id = ""
         self.claude_cwd = ""
         self.claude_task_states = {}
@@ -147,6 +150,7 @@ class ProgressTracker:
         self.last_child_activity_at = ""
         self._codex_child_session_paths = {}
         self._claude_child_session_files = []
+        self._cb_child_session_files = []
         self._last_child_scan_at = 0.0
         self._last_claude_fallback_scan_at = 0.0
         self._last_claude_fallback_scan_key = ""
@@ -158,10 +162,13 @@ class ProgressTracker:
     def process_event(self, event):
         """Process a single stream-json event and update state.
 
-        Supports two formats:
+        Supports three formats:
         1. Claude API raw stream: message_start, content_block_start, content_block_delta, etc.
         2. Claude Code verbose stream-json: assistant, user, tool_result, system, etc.
            (produced by claude/claude-internal --verbose --output-format stream-json)
+        3. CodeBuddy stream-json: message/function_call/function_call_result events
+           (produced by cbc --print -y --output-format stream-json — message type
+           with sessionId/cwd metadata, function_call for tool invocations).
         """
         event_type = event.get("type", "")
 
@@ -233,6 +240,93 @@ class ProgressTracker:
 
             return
 
+        # ── CodeBuddy stream-json format ──────────────────────────────
+        # cbc --print -y --output-format stream-json emits:
+        #   message (role=user/assistant), function_call, function_call_result,
+        #   file-history-snapshot, error.  The first user message carries
+        #   sessionId and cwd metadata; later function_call items carry the
+        #   same fields.
+        # NOTE: cbc emits tool invocations as EITHER tool_use blocks inside a
+        # message (role=assistant) event OR as standalone function_call events,
+        # but not both for the same invocation.  The two handlers are
+        # complementary rather than redundant, so no deduplication is needed.
+        # Detect via event_type=="message" with a "sessionId" field.
+        # Must run before the Claude Code assistant / tool_result branches
+        # because those also accept those types but use different internals.
+        if event_type == "message" and isinstance(event.get("sessionId"), str):
+            self.event_format = self.event_format or "stream-json"
+            role = event.get("role", "")
+            sid = event.get("sessionId", "")
+            cwd = event.get("cwd", "")
+            if sid and not self.cb_session_id:
+                self.cb_session_id = sid.strip()
+            if cwd and not self.cb_cwd:
+                self.cb_cwd = cwd.strip()
+            if role == "assistant":
+                self.message_count += 1
+                self.is_active = True
+                content = event.get("content", [])
+                if isinstance(content, list):
+                    for block in content:
+                        block_type = block.get("type", "")
+                        if block_type == "tool_use":
+                            tool_name = block.get("name", "unknown")
+                            self.current_tool = tool_name
+                            self.tool_call_counts[tool_name] += 1
+                            self.total_tool_calls += 1
+                            tool_input = block.get("input", {})
+                            if isinstance(tool_input, dict):
+                                self._extract_tool_summary_from_dict(tool_input)
+                            self._detect_phase(
+                                json.dumps(tool_input, ensure_ascii=False)[:500]
+                            )
+                            # Track CodeBuddy Agent/Task tool invocations as
+                            # potential sub-agent spawns (Gap 3 fix).
+                            self._record_cb_agent_tool_call(tool_name, tool_input)
+                        elif block_type == "text":
+                            text = block.get("text", "")
+                            if text.strip():
+                                self.last_text_snippet = text.strip()[:120]
+                            self._detect_phase(text)
+                            self._detect_terminal_error(
+                                text, require_error_context=True
+                            )
+            return
+
+        # CodeBuddy function_call / function_call_result in stream-json
+        if event_type in ("function_call", "function_call_result"):
+            self.event_format = self.event_format or "stream-json"
+            sid = event.get("sessionId", "")
+            cwd = event.get("cwd", "")
+            if sid and not self.cb_session_id:
+                self.cb_session_id = sid.strip()
+            if cwd and not self.cb_cwd:
+                self.cb_cwd = cwd.strip()
+            if event_type == "function_call":
+                tool_name = event.get("name", "unknown")
+                self.current_tool = tool_name
+                self.tool_call_counts[tool_name] += 1
+                self.total_tool_calls += 1
+                self.is_active = True
+                # Extract summary from arguments
+                raw_args = event.get("arguments", "")
+                if isinstance(raw_args, str) and raw_args.strip():
+                    self._extract_tool_summary(raw_args)
+                    self._detect_phase(raw_args[:500])
+                    # Track Agent/Task tool invocations as sub-agent spawns
+                    self._record_cb_agent_tool_call(tool_name, raw_args)
+            elif event_type == "function_call_result":
+                self.current_tool = None
+                # Check result text for phase / error hints
+                result_text = event.get("output") or ""
+                if result_text and isinstance(result_text, str):
+                    stripped = result_text.strip()
+                    if stripped:
+                        self.last_text_snippet = stripped[:120]
+                    self._detect_phase(stripped)
+                    self._detect_terminal_error(stripped, require_error_context=True)
+            return
+
         # ── Claude Code verbose format ──────────────────────────────
         if event_type == "assistant":
             self.event_format = self.event_format or "stream-json"
@@ -259,7 +353,10 @@ class ProgressTracker:
                     self._detect_phase(text)
                     self._detect_terminal_error(text, require_error_context=True)
 
-        elif event_type == "tool_result" or event_type == "user":
+        elif event_type == "tool_result" or (
+            event_type == "user"
+            and not isinstance(event.get("sessionId"), str)
+        ):
             # tool_result contains output from tool execution
             self.event_format = self.event_format or "stream-json"
             self.is_active = True
@@ -269,11 +366,11 @@ class ProgressTracker:
             # B) Nested user events: event["message"]["content"][] has type=="tool_result" items
             content_candidates = []
 
-            # Format A: top-level tool_result
+            # Format A: top-level tool_result (Claude Code)
             if event_type == "tool_result":
                 content_candidates.append(str(event.get("content", "")))
 
-            # Format B: nested inside user event
+            # Format B: nested inside user event (Claude Code, NOT CodeBuddy)
             if event_type == "user":
                 message = event.get("message", {})
                 content_list = message.get("content", [])
@@ -465,15 +562,60 @@ class ProgressTracker:
             self._current_tool_input_parts = []
 
         elif event_type == "error":
+            self.event_format = self.event_format or "stream-json"
             error_msg = event.get("error", {}).get("message", "Unknown error")
+            errors = event.get("errors") or []
+            if isinstance(errors, list) and errors:
+                error_msg = "; ".join(str(e) for e in errors[:3])
             self.errors.append(error_msg)
             self._detect_terminal_error(str(error_msg))
 
+        # ── CodeBuddy file-history-snapshot (ignore) ─────────────────
+        elif event_type == "file-history-snapshot":
+            return
+
         # Check for subagent indicator
         if event.get("parent_tool_use_id"):
             # This is a sub-agent event; tool name is still tracked normally
             pass
 
+    def _record_cb_agent_tool_call(self, tool_name, raw_args):
+        """Record a CodeBuddy Agent/Task* tool invocation for sub-agent tracking.
+
+        CodeBuddy spawns sub-agents via:
+        - Agent(prompt=..., run_in_background=True/False) — synchronous or bg fork
+        - TaskCreate(subject=..., description=...) — scheduled task
+
+        (TaskUpdate/TaskOutput exist but are lifecycle-only — they track
+        existing tasks rather than creating new sub-agents, so we don't
+        count them as spawns.)
+
+        We don't get child session ids from these tool calls in the stream,
+        but recording the count lets the heartbeat code in heartbeat.sh apply
+        an extended stale-kill window just as it does for Codex spawn_agent.
+        """
+        if tool_name not in ("Agent", "TaskCreate"):
+            return
+        # Both dict (from message events) and str/JSON (from function_call events)
+        # are supported.
+        if isinstance(raw_args, dict):
+            args = raw_args
+        elif isinstance(raw_args, str):
+            try:
+                args = json.loads(raw_args)
+            except (json.JSONDecodeError, TypeError):
+                return
+        else:
+            return
+        # For Agent tool, subagent_type or run_in_background hints at delegation
+        if tool_name == "Agent":
+            subagent_type = args.get("subagent_type", "")
+            prompt = args.get("prompt", "")
+            if subagent_type or prompt:
+                self._subagent_spawn_count += 1
+        elif tool_name == "TaskCreate":
+            self._subagent_spawn_count += 1
+
     def _record_terminal_result(self, text="", is_error=False, api_error_status=None, api_error_code=""):
         """Record a Claude Code terminal result event."""
         terminal_text = str(text or "")
@@ -757,17 +899,85 @@ class ProgressTracker:
             return []
         return matches
 
+    def _cb_projects_dir(self):
+        """Return the CodeBuddy projects directory for transcript lookup.
+
+        CodeBuddy stores per-project session transcripts and sub-agent data
+        under ~/.codebuddy/projects/{projectDir}/{sessionId}/.
+        """
+        cb_config = os.environ.get("CODEBUDDY_CONFIG_DIR")
+        if cb_config:
+            return Path(cb_config).expanduser() / "projects"
+        cb_home = os.environ.get("CODEBUDDY_HOME")
+        if cb_home:
+            return Path(cb_home).expanduser() / "projects"
+        return Path.home() / ".codebuddy" / "projects"
+
+    def _cb_project_key(self):
+        """Encode cwd the same way CodeBuddy stores project subdirs.
+
+        CodeBuddy uses the same sanitisation as Claude Code (\, /, : → -)
+        but strips the leading '-' so "/Users/test/MyProject" becomes
+        "Users-test-MyProject".
+        """
+        cwd = self.cb_cwd
+        if not cwd:
+            return ""
+        return cwd.replace("\\", "-").replace("/", "-").replace(":", "").lstrip("-")
+
+    def _find_cb_child_session_files(self):
+        """Find CodeBuddy subagent transcript data for this parent session.
+
+        CodeBuddy sub-agents store tool-results/{callId}.txt files; conversation
+        transcripts are not (as of 2026) written as agent-*.jsonl files in the
+        subagents/ directory.  We track the tool-results .txt files as a proxy
+        for child activity so the heartbeat monitor can extend the stale-kill
+        window while sub-agents are running.
+        """
+        if not self.cb_session_id:
+            return []
+
+        projects_dir = self._cb_projects_dir()
+        if not projects_dir.exists():
+            return []
+
+        project_key = self._cb_project_key()
+        if not project_key:
+            return []
+
+        subagents_dir = (
+            projects_dir / project_key / self.cb_session_id / "subagents"
+        )
+        if not subagents_dir.exists():
+            return []
+
+        # Collect all files under each agent-{id} subdirectory. These are
+        # currently tool-results/{callId}.txt files, but the glob also picks
+        # up future agent-*.jsonl transcripts should CodeBuddy add them.
+        try:
+            return sorted(
+                p for p in subagents_dir.glob("**/*")
+                if p.is_file()
+            )
+        except OSError:
+            return []
+
     def refresh_child_session_activity(self, force=False):
         """Refresh child transcript file stats.
 
         The heartbeat monitor uses this activity signature to treat subagent
         transcript growth as real progress while the parent session is blocked
-        waiting for a child agent/tool result. Supports Codex child threads and
-        Claude Code in-process teammate transcripts.
+        waiting for a child agent/tool result. Supports Codex child threads,
+        Claude Code in-process teammate transcripts, and CodeBuddy sub-agent
+        file activity under subagents/.
         """
         previous_signature = self.child_activity_signature
 
-        if not self.codex_child_thread_ids and not self.claude_session_id:
+        if (
+            not self.codex_child_thread_ids
+            and not self.claude_session_id
+            and not self.cb_session_id
+        ):
             self.child_session_files = []
             self.child_total_bytes = 0
             self.child_activity_signature = ""
@@ -788,6 +998,7 @@ class ProgressTracker:
                     if found:
                         self._codex_child_session_paths[thread_id] = found
             self._claude_child_session_files = self._find_claude_child_session_files()
+            self._cb_child_session_files = self._find_cb_child_session_files()
             self._last_child_scan_at = now
 
         files = []
@@ -826,6 +1037,14 @@ class ProgressTracker:
         for path in self._claude_child_session_files:
             add_file("claude", path.stem, path)
 
+        for path in self._cb_child_session_files:
+            # Identifier for CodeBuddy sub-agent files: use the parent
+            # directory name (agent-{id}) so heartbeat can distinguish
+            # activity across different sub-agent instances.
+            parent_name = path.parent.name if hasattr(path, "parent") else ""
+            identifier = parent_name if parent_name.startswith("agent-") else path.name
+            add_file("codebuddy", identifier, path)
+
         self.child_session_files = files
         self.child_total_bytes = total_bytes
         self.child_activity_signature = "|".join(signature_parts)
@@ -861,11 +1080,14 @@ class ProgressTracker:
             "total_tool_calls": self.total_tool_calls,
             "active_subagent_count": self.active_subagent_count,
             "subagent_states": subagent_states,
+            "subagent_spawn_count": self._subagent_spawn_count,
             "child_thread_ids": sorted(self.codex_child_thread_ids),
             "child_session_files": self.child_session_files,
             "child_total_bytes": self.child_total_bytes,
             "child_activity_signature": self.child_activity_signature,
             "last_child_activity_at": self.last_child_activity_at,
+            "cb_session_id": self.cb_session_id,
+            "cb_cwd": self.cb_cwd,
             "last_text_snippet": self.last_text_snippet,
             "last_result_is_error": self.last_result_is_error,
             "api_error_status": self.api_error_status,

package/bundled/skills/_metadata.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1.74",
+  "version": "1.1.77",
   "skills": {
     "prizm-kit": {
       "description": "Full-lifecycle dev toolkit. Covers spec-driven development, Prizm context docs, code quality, debugging, deployment, and knowledge management.",

package/bundled/skills/app-planner/SKILL.md

@@ -332,22 +332,23 @@ For each selected layer, run the rules Q&A workflow. This follows the 4-phase ru
 
 **Phase A — Load layer resources:**
 - Read `${SKILL_DIR}/references/rules/<layer>/fixed-rules.md` — industry-consensus rules injected without asking
-- Read `${SKILL_DIR}/references/rules/<layer>/question-bank.md` — interactive questions organized in groups (G1→G10)
+- Read `${SKILL_DIR}/references/rules/<layer>/question-bank.md` — interactive questions organized in groups (G1→G10): authoritative source for question text, options, "Recommended" markers, and Notes
+- Read `${SKILL_DIR}/references/rules/<layer>/question-manifest.json` — machine-readable structure for this layer. **This is your asking checklist.** It lists, per question: `group`, `required`, `maps_to` (which template placeholders the answer fills), and conditional fields (`required_if`, `auto_derived_when`, `options_vary_by`). Its `groups[]` carries each group's `quick_mode` flag, and `template_placeholders` is the expected-set for the Phase D self-check. Use the manifest to track coverage; use question-bank.md for the actual wording you present to the user. If a question id in one file is absent from the other, trust question-bank.md for content and note the drift.
 
 **Phase B — Interactive Q&A:**
 - Ask questions one group at a time (max 3 questions per message), as defined in question-bank.md
 - Each question shows a "Recommended" option to reduce decision cost
-- **Quick mode**: ask only the following groups per layer. All other groups adopt recommended defaults silently.
-  - **Frontend**: G1 (Tech Stack), G2 (Styling), G3 (State & Data Fetching), G7 (Testing & Quality). Skip: G4 (Design System), G5 (Responsive), G6 (i18n), G8 (AI Vibecoding), G9 (Performance).
-  - **Backend**: G1 (Language & Runtime), G2 (Framework & Architecture), G3 (API Style), G4 (Data Layer), G7 (Testing & Quality). Skip: G5 (Auth), G6 (Infrastructure), G8 (Observability), G9 (AI Constraints).
-  - **Database**: G1 (Database Selection), G2 (Data Modeling), G3 (Migration), G7 (AI Constraints). Skip: G4 (Index & Performance), G5 (Security & Compliance), G6 (High Availability & Ops).
-  - **Mobile**: G1 (Platform & Language), G2 (Architecture), G3 (UI Framework), G4 (Navigation & State), G7 (Testing). Skip: G5 (Networking & Data), G6 (Platform Features), G8 (App Distribution), G9 (Performance & Accessibility), G10 (AI Constraints).
-- **Full mode**: ask all groups in order (G1→G9 for frontend/backend, G1→G7 for database, G1→G10 for mobile)
+- **Quick mode**: ask only the groups whose `quick_mode` is `true` in `question-manifest.json`. All other groups adopt recommended defaults silently. (The manifest is the single source of truth for quick-mode membership — do not hardcode group lists here.)
+- **Full mode**: ask all groups in manifest order (`groups[]`).
+- **Conditional questions** (driven by the manifest's per-question fields):
+  - `required_if: "<expr>"` — ask this question only when the expression over prior answers holds (e.g. Q14 `required_if: Q13 != D`). If the condition is false, the question is legitimately skipped — not a coverage gap.
+  - `auto_derived_when: "<expr>"` — when this holds, fill the mapped placeholder(s) from the prior answer without asking (e.g. backend Q6 `auto_derived_when: Q5 in [GraphQL, gRPC]`). Count as satisfied, not skipped.
+  - `options_vary_by: "<Qid>"` — the question is still asked; only its option list depends on that prior answer (e.g. framework/ORM options vary by language). Never affects whether the question is required.
 - Shortcut commands work at any point:
   - `recommended` / `default` → adopt all recommended for current group
   - `all recommended` → adopt all recommended for all remaining groups
   - `skip` → mark current group as "Not required at this stage"
-- Record answers in memory after each group.
+- Record answers in memory after each group. Track which manifest questions are answered, auto-derived, or conditionally skipped so Phase D can verify coverage.
 
 **Phase C — Auto-derivation:**
 - Read `${SKILL_DIR}/references/rules/<layer>/derivation-rules.md`
@@ -357,8 +358,10 @@ For each selected layer, run the rules Q&A workflow. This follows the 4-phase ru
 **Phase D — Render and write:**
 - Read `${SKILL_DIR}/references/rules/<layer>/template.md`
 - Fill all template placeholders with accumulated content from Phases A+B+C
-- **Post-render self-check**: scan for residual `{{ ` or ` }}` — count must be 0 before writing
-- Generate Appendix A (Deny List) and Appendix B (Recommended Tools) per template instructions
+- **Post-render self-check** (driven by `question-manifest.json` → `template_placeholders`):
+  1. **Coverage pass** — for every placeholder in `from_questions`, confirm it traces to an answered question OR an `auto_derived_when` path OR a conditionally-skipped question (`required_if` false). If a `from_questions` placeholder has no source, you skipped a required question — go back and ask it before writing.
+  2. **Residual pass** — scan the rendered document for any residual `{{ ` or ` }}`; count must be 0. Placeholders in `from_fixed_rules` / `auto_generated` / `metadata` are filled from fixed-rules.md, Phase D generation, and project metadata respectively — they are NOT expected to come from Q&A, but they MUST still be rendered (no residual braces).
+- Generate Appendix A (Deny List) and Appendix B (Recommended Tools) per template instructions — these fill the `auto_generated` placeholders
 - Create `.prizmkit/rules/` directory if it doesn't exist
 - Write `.prizmkit/rules/<layer>-rules.md`
 

package/bundled/skills/app-planner/references/rules/backend/question-manifest.json

@@ -0,0 +1,46 @@
+{
+  "schema_version": "app-planner-question-manifest-v1",
+  "layer": "backend",
+  "total_questions": 20,
+  "_doc": "Machine-readable structure for backend question-bank.md. Question TEXT/options/Recommended/Notes are authoritative in question-bank.md; this file carries ONLY structure: group membership, quick-mode, question->placeholder mapping, and conditional logic. Keep Qids and group ids in sync with question-bank.md. The AI reads this as its asking checklist (Phase A) and self-check expected-set (Phase D).",
+  "_conditions": "required_if / auto_derived_when use simple expressions over recorded answers, e.g. 'Q5 == RESTful', 'Q13 != D', 'Q5 in [GraphQL, gRPC]'. options_vary_by names a prior answer that changes the OPTION LIST only (question is still asked; never affects required).",
+  "groups": [
+    { "id": "G1", "topic": "Language & Runtime", "quick_mode": true },
+    { "id": "G2", "topic": "Framework & Architecture", "quick_mode": true },
+    { "id": "G3", "topic": "API Style", "quick_mode": true },
+    { "id": "G4", "topic": "Data Layer", "quick_mode": true },
+    { "id": "G5", "topic": "Auth", "quick_mode": false },
+    { "id": "G6", "topic": "Infrastructure", "quick_mode": false },
+    { "id": "G7", "topic": "Testing & Quality", "quick_mode": true },
+    { "id": "G8", "topic": "Observability", "quick_mode": false },
+    { "id": "G9", "topic": "AI Constraints", "quick_mode": false }
+  ],
+  "questions": [
+    { "id": "Q1", "group": "G1", "topic": "Programming Language", "maps_to": ["language", "tech_stack_rules"], "required": true },
+    { "id": "Q2", "group": "G1", "topic": "Runtime Version", "maps_to": ["runtime_version"], "required": true },
+    { "id": "Q3", "group": "G2", "topic": "Web Framework", "maps_to": ["framework", "tech_stack_rules"], "required": true, "options_vary_by": "Q1", "note_open_ended_when": "Q1 == Custom" },
+    { "id": "Q4", "group": "G2", "topic": "Architecture Pattern", "maps_to": ["architecture", "arch_rules"], "required": true },
+    { "id": "Q5", "group": "G3", "topic": "API Style", "maps_to": ["api_style", "api_rules"], "required": true },
+    { "id": "Q6", "group": "G3", "topic": "API Documentation", "maps_to": ["api_docs"], "required": true, "required_if": "Q5 == RESTful", "auto_derived_when": "Q5 in [GraphQL, gRPC]" },
+    { "id": "Q7", "group": "G4", "topic": "ORM / Data Access", "maps_to": ["orm", "data_rules"], "required": true, "options_vary_by": "Q1", "note_open_ended_when": "Q1 == Custom" },
+    { "id": "Q8", "group": "G4", "topic": "Database", "maps_to": ["database"], "required": true },
+    { "id": "Q9", "group": "G5", "topic": "Authentication Scheme", "maps_to": ["auth_scheme", "auth_rules"], "required": true },
+    { "id": "Q10", "group": "G6", "topic": "Caching", "maps_to": ["cache", "cache_rules"], "required": true },
+    { "id": "Q11", "group": "G6", "topic": "Message Queue", "maps_to": ["mq", "mq_rules"], "required": true },
+    { "id": "Q12", "group": "G6", "topic": "Containerization & Deployment", "maps_to": ["container", "deploy_rules"], "required": true },
+    { "id": "Q13", "group": "G7", "topic": "Test Coverage Requirements", "maps_to": ["test_requirement", "test_rules"], "required": true },
+    { "id": "Q14", "group": "G7", "topic": "Test Framework", "maps_to": ["test_framework"], "required": true, "required_if": "Q13 != D", "options_vary_by": "Q1" },
+    { "id": "Q15", "group": "G7", "topic": "Mock Strategy", "maps_to": ["mock_strategy", "test_rules"], "required": true },
+    { "id": "Q16", "group": "G8", "topic": "Logging", "maps_to": ["logging", "observability_rules"], "required": true },
+    { "id": "Q17", "group": "G8", "topic": "Monitoring & Tracing", "maps_to": ["monitoring", "observability_rules"], "required": true },
+    { "id": "Q18", "group": "G9", "topic": "AI Permission to Add Dependencies", "maps_to": ["ai_dependency_rule"], "required": true },
+    { "id": "Q19", "group": "G9", "topic": "AI Modifying Shared Modules", "maps_to": ["ai_breaking_change_rule"], "required": true },
+    { "id": "Q20", "group": "G9", "topic": "AI Modifying Configuration", "maps_to": ["ai_config_rule"], "required": true }
+  ],
+  "template_placeholders": {
+    "from_questions": ["language", "runtime_version", "framework", "architecture", "api_style", "api_docs", "orm", "database", "auth_scheme", "cache", "mq", "container", "test_requirement", "test_framework", "mock_strategy", "logging", "monitoring", "ai_dependency_rule", "ai_breaking_change_rule", "ai_config_rule", "tech_stack_rules", "arch_rules", "api_rules", "auth_rules", "data_rules", "cache_rules", "mq_rules", "deploy_rules", "observability_rules", "test_rules"],
+    "from_fixed_rules": ["FIXED_RULES_STRUCTURE", "FIXED_RULES_API", "FIXED_RULES_ERROR", "FIXED_RULES_SECURITY", "FIXED_RULES_RATE_LIMITING", "FIXED_RULES_DATABASE", "FIXED_RULES_OBSERVABILITY", "FIXED_RULES_TRACING", "FIXED_RULES_CONFIG", "FIXED_RULES_ASYNC", "FIXED_RULES_MESSAGE_DELIVERY", "FIXED_RULES_GRACEFUL_SHUTDOWN", "FIXED_RULES_TEST", "FIXED_RULES_AI_BASE"],
+    "auto_generated": ["deny_list_summary", "recommended_libs"],
+    "metadata": ["project_name", "generated_at"]
+  }
+}

package/bundled/skills/app-planner/references/rules/database/question-manifest.json

@@ -0,0 +1,39 @@
+{
+  "schema_version": "app-planner-question-manifest-v1",
+  "layer": "database",
+  "total_questions": 15,
+  "_doc": "Machine-readable structure for database question-bank.md. Question TEXT/options/Recommended/Notes are authoritative in question-bank.md; this file carries ONLY structure: group membership, quick-mode, question->placeholder mapping, and conditional logic. Keep Qids and group ids in sync with question-bank.md. The AI reads this as its asking checklist (Phase A) and self-check expected-set (Phase D).",
+  "_conditions": "required_if / auto_derived_when use simple expressions over recorded answers. options_vary_by names a prior answer that changes the OPTION LIST only (question is still asked; never affects required). A single answer may fill more than one placeholder (a TL;DR value + a rules-block), both listed in maps_to.",
+  "groups": [
+    { "id": "G1", "topic": "Database Selection", "quick_mode": true },
+    { "id": "G2", "topic": "Data Modeling", "quick_mode": true },
+    { "id": "G3", "topic": "Migration", "quick_mode": true },
+    { "id": "G4", "topic": "Index & Performance", "quick_mode": false },
+    { "id": "G5", "topic": "Security & Compliance", "quick_mode": false },
+    { "id": "G6", "topic": "High Availability & Ops", "quick_mode": false },
+    { "id": "G7", "topic": "AI Constraints", "quick_mode": true }
+  ],
+  "questions": [
+    { "id": "Q1", "group": "G1", "topic": "Primary Database", "maps_to": ["database", "tech_rules"], "required": true },
+    { "id": "Q2", "group": "G1", "topic": "Cache Layer", "maps_to": ["cache", "cache_rules"], "required": true },
+    { "id": "Q3", "group": "G2", "topic": "Primary Key Strategy", "maps_to": ["pk_strategy", "schema_rules"], "required": true },
+    { "id": "Q4", "group": "G2", "topic": "Soft Delete", "maps_to": ["soft_delete", "schema_rules"], "required": true },
+    { "id": "Q5", "group": "G2", "topic": "Normalization Level", "maps_to": ["normalization", "schema_rules"], "required": true },
+    { "id": "Q6", "group": "G3", "topic": "Migration Tool", "maps_to": ["migration_tool", "migration_rules"], "required": true },
+    { "id": "Q7", "group": "G4", "topic": "Query Complexity", "maps_to": ["workload_type", "performance_rules"], "required": true },
+    { "id": "Q8", "group": "G4", "topic": "Estimated Data Volume", "maps_to": ["data_scale", "performance_rules"], "required": true },
+    { "id": "Q9", "group": "G5", "topic": "Data Sensitivity Level", "maps_to": ["data_sensitivity", "security_rules"], "required": true },
+    { "id": "Q10", "group": "G5", "topic": "Audit Requirements", "maps_to": ["audit", "audit_rules"], "required": true, "multi_select": true },
+    { "id": "Q11", "group": "G6", "topic": "Deployment Method", "maps_to": ["deployment", "ops_rules"], "required": true },
+    { "id": "Q12", "group": "G6", "topic": "Backup Strategy", "maps_to": ["backup", "ops_rules"], "required": true },
+    { "id": "Q13", "group": "G6", "topic": "High Availability Requirements", "maps_to": ["ha", "ops_rules"], "required": true },
+    { "id": "Q14", "group": "G7", "topic": "AI Permission to Modify Database Structure", "maps_to": ["ai_ddl_rule", "ai_ddl_permission"], "required": true },
+    { "id": "Q15", "group": "G7", "topic": "AI Safety Constraints", "maps_to": ["ai_safety_rule", "ai_safety_constraint"], "required": true }
+  ],
+  "template_placeholders": {
+    "from_questions": ["database", "tech_rules", "cache", "cache_rules", "pk_strategy", "schema_rules", "soft_delete", "normalization", "migration_tool", "migration_rules", "workload_type", "performance_rules", "data_scale", "data_sensitivity", "security_rules", "audit", "audit_rules", "deployment", "ops_rules", "backup", "ha", "ai_ddl_rule", "ai_ddl_permission", "ai_safety_rule", "ai_safety_constraint"],
+    "from_fixed_rules": ["FIXED_RULES_AI_BASE", "FIXED_RULES_BACKUP", "FIXED_RULES_CONNECTION", "FIXED_RULES_INDEX", "FIXED_RULES_MIGRATION", "FIXED_RULES_PERFORMANCE", "FIXED_RULES_QUERY", "FIXED_RULES_SCHEMA", "FIXED_RULES_SECURITY", "FIXED_RULES_TRANSACTION", "FIXED_RULES_TYPES"],
+    "auto_generated": ["deny_list_summary", "recommended_libs"],
+    "metadata": ["project_name", "generated_at"]
+  }
+}

package/bundled/skills/app-planner/references/rules/frontend/question-manifest.json

@@ -0,0 +1,51 @@
+{
+  "schema_version": "app-planner-question-manifest-v1",
+  "layer": "frontend",
+  "total_questions": 25,
+  "_doc": "Machine-readable structure for frontend question-bank.md. Question TEXT/options/Recommended/Notes are authoritative in question-bank.md; this file carries ONLY structure: group membership, quick-mode, question->placeholder mapping, and conditional logic. Keep Qids and group ids in sync with question-bank.md. The AI reads this as its asking checklist (Phase A) and self-check expected-set (Phase D).",
+  "_conditions": "required_if / auto_derived_when use simple expressions over recorded answers, e.g. 'Q15 in [A, B]'. options_vary_by names a prior answer that changes the OPTION LIST/recommendation only (question is still asked; never affects required).",
+  "groups": [
+    { "id": "G1", "topic": "Tech Stack", "quick_mode": true },
+    { "id": "G2", "topic": "Styling", "quick_mode": true },
+    { "id": "G3", "topic": "State & Data Fetching", "quick_mode": true },
+    { "id": "G4", "topic": "Design System", "quick_mode": false },
+    { "id": "G5", "topic": "Responsive & Adaptation", "quick_mode": false },
+    { "id": "G6", "topic": "i18n & Accessibility", "quick_mode": false },
+    { "id": "G7", "topic": "Testing & Quality", "quick_mode": true },
+    { "id": "G8", "topic": "AI Vibecoding Constraints", "quick_mode": false },
+    { "id": "G9", "topic": "Performance Baseline", "quick_mode": false }
+  ],
+  "questions": [
+    { "id": "Q1", "group": "G1", "topic": "Frontend Framework", "maps_to": ["framework", "tech_stack_rules"], "required": true },
+    { "id": "Q2", "group": "G1", "topic": "Meta-Framework", "maps_to": ["meta_framework", "tech_stack_rules"], "required": true, "options_vary_by": "Q1" },
+    { "id": "Q3", "group": "G1", "topic": "Package Manager", "maps_to": ["package_manager", "tech_stack_rules"], "required": true },
+    { "id": "Q4", "group": "G2", "topic": "Styling Solution", "maps_to": ["style_solution", "style_specific_rules"], "required": true },
+    { "id": "Q4b", "group": "G2", "topic": "Font Loading Strategy", "maps_to": ["font_strategy", "performance_rules"], "required": true },
+    { "id": "Q5", "group": "G3", "topic": "Global State Library", "maps_to": ["state_lib", "state_rules"], "required": true, "options_vary_by": "Q1" },
+    { "id": "Q6", "group": "G3", "topic": "Server State Library", "maps_to": ["server_state_lib", "server_state_rules"], "required": true },
+    { "id": "Q7", "group": "G3", "topic": "API Type Source", "maps_to": ["api_type_source", "server_state_rules"], "required": true },
+    { "id": "Q8", "group": "G4", "topic": "Primary Design/Mockup Source", "maps_to": ["design_source"], "required": true },
+    { "id": "Q9", "group": "G4", "topic": "Token Naming Layers", "maps_to": ["token_layering", "token_layering_rules"], "required": true },
+    { "id": "Q10", "group": "G4", "topic": "Dark Mode", "maps_to": ["dark_mode", "dark_mode_rules"], "required": true },
+    { "id": "Q11", "group": "G5", "topic": "Adaptation Strategy", "maps_to": ["responsive_strategy", "breakpoint_rules"], "required": true },
+    { "id": "Q12", "group": "G5", "topic": "Breakpoint Scheme", "maps_to": ["breakpoint_scheme", "breakpoint_rules"], "required": true },
+    { "id": "Q13", "group": "G6", "topic": "Internationalization", "maps_to": ["i18n", "i18n_rules"], "required": true },
+    { "id": "Q14", "group": "G6", "topic": "Accessibility Target", "maps_to": ["a11y_level", "a11y_extra_rules"], "required": true },
+    { "id": "Q15", "group": "G7", "topic": "Test Coverage Requirements", "maps_to": ["test_coverage", "test_rules"], "required": true },
+    { "id": "Q16", "group": "G7", "topic": "Unit Test Framework", "maps_to": ["unit_test_framework", "test_rules"], "required": true, "required_if": "Q15 in [A, B]" },
+    { "id": "Q17", "group": "G7", "topic": "E2E Framework", "maps_to": ["e2e_framework", "test_rules"], "required": true, "required_if": "Q15 in [A, C]" },
+    { "id": "Q18", "group": "G8", "topic": "AI Component Index Sync", "maps_to": ["ai_index_rule"], "required": true },
+    { "id": "Q19", "group": "G8", "topic": "AI Permission to Add Dependencies", "maps_to": ["ai_dependency_rule"], "required": true },
+    { "id": "Q20", "group": "G8", "topic": "AI Impact Analysis Before Modifying Shared Components", "maps_to": ["ai_breaking_change_rule"], "required": true },
+    { "id": "Q21", "group": "G8", "topic": "AI Permission to Modify Config Files", "maps_to": ["ai_config_rule"], "required": true },
+    { "id": "Q22", "group": "G8", "topic": "AI Single File Generation Limit", "maps_to": ["ai_max_lines"], "required": true },
+    { "id": "Q23", "group": "G9", "topic": "First Screen LCP Target", "maps_to": ["lcp_target", "performance_rules"], "required": true },
+    { "id": "Q24", "group": "G9", "topic": "Single Chunk Size Limit", "maps_to": ["bundle_size", "performance_rules"], "required": true }
+  ],
+  "template_placeholders": {
+    "from_questions": ["framework", "meta_framework", "package_manager", "style_solution", "style_specific_rules", "font_strategy", "performance_rules", "state_lib", "state_rules", "server_state_lib", "server_state_rules", "api_type_source", "design_source", "token_layering", "token_layering_rules", "dark_mode", "dark_mode_rules", "responsive_strategy", "breakpoint_rules", "breakpoint_scheme", "i18n", "i18n_rules", "a11y_level", "a11y_extra_rules", "test_coverage", "test_rules", "unit_test_framework", "e2e_framework", "ai_index_rule", "ai_dependency_rule", "ai_breaking_change_rule", "ai_config_rule", "ai_max_lines", "lcp_target", "bundle_size", "tech_stack_rules"],
+    "from_fixed_rules": ["FIXED_RULES_A11Y", "FIXED_RULES_AI_BASE", "FIXED_RULES_COMPONENT_CONTRACT", "FIXED_RULES_DENY_LIST", "FIXED_RULES_ERROR_HANDLING", "FIXED_RULES_GIT", "FIXED_RULES_I18N_BASELINE", "FIXED_RULES_NAMING", "FIXED_RULES_PERFORMANCE", "FIXED_RULES_SECURITY", "FIXED_RULES_TYPESCRIPT"],
+    "auto_generated": ["deny_list_summary", "recommended_libs"],
+    "metadata": ["project_name", "generated_at", "project_scope"]
+  }
+}

package/bundled/skills/app-planner/references/rules/mobile/question-manifest.json

@@ -0,0 +1,47 @@
+{
+  "schema_version": "app-planner-question-manifest-v1",
+  "layer": "mobile",
+  "total_questions": 20,
+  "_doc": "Machine-readable structure for mobile question-bank.md. Question TEXT/options/Recommended/Notes are authoritative in question-bank.md; this file carries ONLY structure: group membership, quick-mode, question->placeholder mapping, and conditional logic. Keep Qids and group ids in sync with question-bank.md. The AI reads this as its asking checklist (Phase A) and self-check expected-set (Phase D).",
+  "_conditions": "required_if / auto_derived_when use simple expressions over recorded answers, e.g. 'Q12 in [A, B]'. options_vary_by names a prior answer that changes the OPTION LIST only (question is still asked; never affects required). dual_native_repeat_when notes Q1=E (both native) repeats the question per platform.",
+  "groups": [
+    { "id": "G1", "topic": "Platform & Language", "quick_mode": true },
+    { "id": "G2", "topic": "Architecture", "quick_mode": true },
+    { "id": "G3", "topic": "UI Framework", "quick_mode": true },
+    { "id": "G4", "topic": "Navigation & State", "quick_mode": true },
+    { "id": "G5", "topic": "Networking & Data", "quick_mode": false },
+    { "id": "G6", "topic": "Platform Features", "quick_mode": false },
+    { "id": "G7", "topic": "Testing", "quick_mode": true },
+    { "id": "G8", "topic": "App Distribution", "quick_mode": false },
+    { "id": "G9", "topic": "Performance & Accessibility", "quick_mode": false },
+    { "id": "G10", "topic": "AI Constraints", "quick_mode": false }
+  ],
+  "questions": [
+    { "id": "Q1", "group": "G1", "topic": "Target Platform", "maps_to": ["platform", "tech_stack_rules"], "required": true },
+    { "id": "Q2", "group": "G1", "topic": "Minimum OS Version", "maps_to": ["min_os_version", "tech_stack_rules"], "required": true },
+    { "id": "Q3", "group": "G2", "topic": "Architecture Pattern", "maps_to": ["architecture", "arch_rules"], "required": true },
+    { "id": "Q4", "group": "G3", "topic": "UI Framework", "maps_to": ["ui_framework", "ui_rules"], "required": true, "options_vary_by": "Q1", "dual_native_repeat_when": "Q1 == E" },
+    { "id": "Q5", "group": "G4", "topic": "Navigation Strategy", "maps_to": ["navigation", "navigation_rules"], "required": true },
+    { "id": "Q6", "group": "G4", "topic": "State Management", "maps_to": ["state_management", "state_rules"], "required": true, "options_vary_by": "Q1", "dual_native_repeat_when": "Q1 == E" },
+    { "id": "Q7", "group": "G5", "topic": "Networking Library", "maps_to": ["networking", "networking_rules"], "required": true, "options_vary_by": "Q1", "dual_native_repeat_when": "Q1 == E" },
+    { "id": "Q8", "group": "G5", "topic": "Local Persistence", "maps_to": ["persistence", "persistence_rules"], "required": true, "options_vary_by": "Q1", "dual_native_repeat_when": "Q1 == E" },
+    { "id": "Q9", "group": "G6", "topic": "Push Notifications", "maps_to": ["push_notifications", "platform_features_rules"], "required": true },
+    { "id": "Q10", "group": "G6", "topic": "Background Tasks", "maps_to": ["background_tasks", "platform_features_rules"], "required": true },
+    { "id": "Q11", "group": "G6", "topic": "Permissions Strategy", "maps_to": ["permissions_strategy"], "required": true },
+    { "id": "Q12", "group": "G7", "topic": "Test Coverage Requirements", "maps_to": ["test_coverage", "test_rules"], "required": true },
+    { "id": "Q13", "group": "G7", "topic": "Unit Test Framework", "maps_to": ["unit_test_framework"], "required": true, "required_if": "Q12 in [A, B]", "options_vary_by": "Q1", "dual_native_repeat_when": "Q1 == E" },
+    { "id": "Q14", "group": "G7", "topic": "UI/E2E Test Framework", "maps_to": ["e2e_framework"], "required": true, "required_if": "Q12 in [A, C]", "options_vary_by": "Q1", "dual_native_repeat_when": "Q1 == E" },
+    { "id": "Q15", "group": "G8", "topic": "Distribution Method", "maps_to": ["distribution", "distribution_rules"], "required": true },
+    { "id": "Q16", "group": "G9", "topic": "Performance Targets", "maps_to": ["performance_target", "performance_rules"], "required": true },
+    { "id": "Q17", "group": "G9", "topic": "Accessibility Targets", "maps_to": ["a11y_target", "a11y_rules"], "required": true },
+    { "id": "Q18", "group": "G10", "topic": "AI Permission to Add Dependencies", "maps_to": ["ai_dependency_rule"], "required": true },
+    { "id": "Q19", "group": "G10", "topic": "AI Impact Analysis Before Modifying Shared Code", "maps_to": ["ai_breaking_change_rule"], "required": true },
+    { "id": "Q20", "group": "G10", "topic": "AI Platform-Specific Code Generation", "maps_to": ["ai_platform_rule"], "required": true }
+  ],
+  "template_placeholders": {
+    "from_questions": ["platform", "tech_stack_rules", "min_os_version", "architecture", "arch_rules", "ui_framework", "ui_rules", "navigation", "navigation_rules", "state_management", "state_rules", "networking", "networking_rules", "persistence", "persistence_rules", "push_notifications", "platform_features_rules", "background_tasks", "permissions_strategy", "test_coverage", "test_rules", "unit_test_framework", "e2e_framework", "distribution", "distribution_rules", "performance_target", "performance_rules", "a11y_target", "a11y_rules", "ai_dependency_rule", "ai_breaking_change_rule", "ai_platform_rule"],
+    "from_fixed_rules": ["FIXED_RULES_A11Y", "FIXED_RULES_AI_BASE", "FIXED_RULES_DISTRIBUTION", "FIXED_RULES_NAVIGATION", "FIXED_RULES_NETWORKING", "FIXED_RULES_PERFORMANCE", "FIXED_RULES_PERSISTENCE", "FIXED_RULES_PLATFORM_FEATURES", "FIXED_RULES_SECURITY", "FIXED_RULES_STATE", "FIXED_RULES_STRUCTURE", "FIXED_RULES_TEST", "FIXED_RULES_UI"],
+    "auto_generated": ["deny_list_summary", "recommended_libs"],
+    "metadata": ["project_name", "generated_at"]
+  }
+}

package/bundled/skills/bugfix-pipeline-launcher/SKILL.md

@@ -189,6 +189,7 @@ Detect user intent from their message, then follow the corresponding workflow:
    | Variable | Default | Purpose |
    |----------|---------|---------|
    | `MODEL` | (none) | AI model override (e.g. `claude-opus-4.6`) |
+   | `PRIZMKIT_EFFORT` | (none) | AI reasoning effort: `low`\|`medium`\|`high`\|`xhigh`\|`max` (max = Claude Code only) |
    | `AUTO_PUSH` | `0` | Auto-push to remote after successful bug fix (`1` to enable) |
    | `DEV_BRANCH` | auto-generated | Custom dev branch name (default: `bugfix/pipeline-{run_id}`) |
    | `HEARTBEAT_INTERVAL` | `30` | Heartbeat log interval in seconds |