@bhargavvc/sdd-cc 1.30.1 → 1.42.3

package/bin/sdd-sdk.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+/**
+ * bin/sdd-sdk.js — back-compat shim for external callers of `sdd-sdk`.
+ *
+ * When the parent package is installed globally (`npm install -g @bhargavvc/sdd-cc`)
+ * npm creates a `sdd-sdk` symlink in the global bin directory pointing at this
+ * file. npm correctly chmods bin entries from a tarball, so the execute-bit
+ * problem that afflicted the sub-install approach (issue #2453) cannot occur here.
+ *
+ * NOTE (#2775): `npx @bhargavvc/sdd-cc` does NOT link this shim — npx only
+ * exposes the package's primary bin (`@bhargavvc/sdd-cc`). For npx-based usage,
+ * the installer (`bin/install.js#installSdkIfNeeded`) self-symlinks `sdd-sdk`
+ * into `~/.local/bin` when needed and verifies PATH callability before
+ * reporting `✓ SDD SDK ready`.
+ *
+ * This shim resolves sdk/dist/cli.js relative to its own location and delegates
+ * to it via `node`, so `sdd-sdk <args>` behaves identically to
+ * `node <packageDir>/sdk/dist/cli.js <args>`.
+ *
+ * Call sites (slash commands, agent prompts, hook scripts) continue to work without
+ * changes because `sdd-sdk` still resolves on PATH — it just comes from this shim
+ * in the parent package rather than from a separately installed @bhargavvc/sdk.
+ */
+
+'use strict';
+
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const cliPath = path.resolve(__dirname, '..', 'sdk', 'dist', 'cli.js');
+
+const result = spawnSync(process.execPath, [cliPath, ...process.argv.slice(2)], {
+  stdio: 'inherit',
+  env: process.env,
+});
+
+process.exit(result.status ?? 1);

package/commands/sdd/add-tests.md

@@ -9,12 +9,13 @@ allowed-tools:
   - Bash
   - Glob
   - Grep
-  - Task
+  - Agent
   - AskUserQuestion
 argument-instructions: |
   Parse the argument as a phase number (integer, decimal, or letter-suffix), plus optional free-text instructions.
   Example: /sdd:add-tests 12
   Example: /sdd:add-tests 12 focus on edge cases in the pricing module
+requires: [phase]
 ---
 <objective>
 Generate unit and E2E tests for a completed phase, using its SUMMARY.md, CONTEXT.md, and VERIFICATION.md as specifications.
@@ -36,6 +37,6 @@ Phase: $ARGUMENTS
 </context>
 
 <process>
-Execute the add-tests workflow from @~/.claude/sdd/workflows/add-tests.md end-to-end.
+Execute end-to-end.
 Preserve all workflow gates (classification approval, test plan approval, RED-GREEN verification, gap reporting).
 </process>

package/commands/sdd/ai-integration-phase.md

@@ -0,0 +1,37 @@
+---
+name: sdd:ai-integration-phase
+description: Generate an AI-SPEC.md design contract for phases that involve building AI systems.
+argument-hint: "[phase number]"
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - Grep
+  - Agent
+  - WebFetch
+  - WebSearch
+  - AskUserQuestion
+  - mcp__context7__*
+requires: [phase]
+---
+<objective>
+Create an AI design contract (AI-SPEC.md) for a phase involving AI system development.
+Orchestrates sdd-framework-selector → sdd-ai-researcher → sdd-domain-researcher → sdd-eval-planner.
+Flow: Select Framework → Research Docs → Research Domain → Design Eval Strategy → Done
+</objective>
+
+<execution_context>
+@~/.claude/sdd/workflows/ai-integration-phase.md
+@~/.claude/sdd/references/ai-frameworks.md
+@~/.claude/sdd/references/ai-evals.md
+</execution_context>
+
+<context>
+Phase number: $ARGUMENTS — optional, auto-detects next unplanned phase if omitted.
+</context>
+
+<process>
+Execute end-to-end.
+Preserve all workflow gates.
+</process>

package/commands/sdd/audit-fix.md

@@ -0,0 +1,34 @@
+---
+type: prompt
+name: sdd:audit-fix
+description: Autonomous audit-to-fix pipeline — find issues, classify, fix, test, commit
+argument-hint: "--source <audit-uat> [--severity <medium|high|all>] [--max N] [--dry-run]"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Grep
+  - Glob
+  - Agent
+  - AskUserQuestion
+requires: [audit-uat]
+---
+<objective>
+Run an audit, classify findings as auto-fixable vs manual-only, then autonomously fix
+auto-fixable issues with test verification and atomic commits.
+
+Flags:
+- `--max N` — maximum findings to fix (default: 5)
+- `--severity high|medium|all` — minimum severity to process (default: medium)
+- `--dry-run` — classify findings without fixing (shows classification table)
+- `--source <audit>` — which audit to run (default: audit-uat)
+</objective>
+
+<execution_context>
+@~/.claude/sdd/workflows/audit-fix.md
+</execution_context>
+
+<process>
+Execute end-to-end.
+</process>

package/commands/sdd/audit-milestone.md

@@ -7,8 +7,9 @@ allowed-tools:
   - Glob
   - Grep
   - Bash
-  - Task
+  - Agent
   - Write
+requires: [execute-phase]
 ---
 <objective>
 Verify milestone achieved its definition of done. Check requirements coverage, cross-phase integration, and end-to-end flows.
@@ -31,6 +32,6 @@ Glob: .planning/phases/*/*-VERIFICATION.md
 </context>
 
 <process>
-Execute the audit-milestone workflow from @~/.claude/sdd/workflows/audit-milestone.md end-to-end.
+Execute end-to-end.
 Preserve all workflow gates (scope determination, verification reading, integration check, requirements coverage, routing).
 </process>

package/commands/sdd/autonomous.md

@@ -1,7 +1,7 @@
 ---
 name: sdd:autonomous
 description: Run all remaining phases autonomously — discuss→plan→execute per phase
-argument-hint: "[--from N]"
+argument-hint: "[--from N] [--to N] [--only N] [--interactive]"
 allowed-tools:
   - Read
   - Write
@@ -9,7 +9,8 @@ allowed-tools:
   - Glob
   - Grep
   - AskUserQuestion
-  - Task
+  - Agent
+requires: [cleanup, phase, progress]
 ---
 <objective>
 Execute all remaining milestone phases autonomously. For each phase: discuss → plan → execute. Pauses only for user decisions (grey area acceptance, blockers, validation requests).
@@ -30,12 +31,16 @@ Uses ROADMAP.md phase discovery and Skill() flat invocations for each phase comm
 </execution_context>
 
 <context>
-Optional flag: `--from N` — start from phase N instead of the first incomplete phase.
+Optional flags:
+- `--from N` — start from phase N instead of the first incomplete phase.
+- `--to N` — stop after phase N completes (halt instead of advancing to next phase).
+- `--only N` — execute only phase N (single-phase mode).
+- `--interactive` — run discuss inline with questions (not auto-answered), then dispatch plan→execute as background agents. Keeps the main context lean while preserving user input on decisions.
 
-Project context, phase list, and state are resolved inside the workflow using init commands (`sdd-tools.cjs init milestone-op`, `sdd-tools.cjs roadmap analyze`). No upfront context loading needed.
+Project context, phase list, and state are resolved inside the workflow using init commands (`sdd-sdk query init.milestone-op`, `sdd-sdk query roadmap.analyze`). No upfront context loading needed.
 </context>
 
 <process>
-Execute the autonomous workflow from @~/.claude/sdd/workflows/autonomous.md end-to-end.
+Execute end-to-end.
 Preserve all workflow gates (phase discovery, per-phase execution, blocker handling, progress display).
 </process>

package/commands/sdd/capture.md

@@ -0,0 +1,62 @@
+---
+name: sdd:capture
+description: Capture ideas, tasks, notes, and seeds to their destination
+argument-hint: "[--note | --backlog | --seed | --list] [text]"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Glob
+  - Grep
+  - AskUserQuestion
+---
+
+<objective>
+Capture ideas, tasks, notes, and seeds to their appropriate destination in the SDD system.
+
+Mode routing:
+- **default** (no flag): Capture as a structured todo for later work → add-todo workflow
+- **--note**: Zero-friction idea capture (append/list/promote) → note workflow
+- **--backlog**: Add an idea to the backlog parking lot (999.x numbering) → add-backlog workflow
+- **--seed**: Capture a forward-looking idea with trigger conditions → plant-seed workflow
+- **--list**: List pending todos and select one to work on → check-todos workflow
+</objective>
+
+<routing>
+
+| Flag | Destination | Workflow |
+|------|-------------|----------|
+| (none) | Structured todo in .planning/todos/ | add-todo |
+| --note | Timestamped note file, list, or promote | note |
+| --backlog | ROADMAP.md backlog section (999.x) | add-backlog |
+| --seed | .planning/seeds/SEED-NNN-slug.md | plant-seed |
+| --list | Interactive todo browser + action router | check-todos |
+
+</routing>
+
+<execution_context>
+@~/.claude/sdd/workflows/add-todo.md
+@~/.claude/sdd/workflows/note.md
+@~/.claude/sdd/workflows/add-backlog.md
+@~/.claude/sdd/workflows/plant-seed.md
+@~/.claude/sdd/workflows/check-todos.md
+@~/.claude/sdd/references/ui-brand.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS
+
+Parse the first token of $ARGUMENTS:
+- If it is `--note`: strip the flag, pass remainder to note workflow
+- If it is `--backlog`: strip the flag, pass remainder to add-backlog workflow
+- If it is `--seed`: strip the flag, pass remainder to plant-seed workflow
+- If it is `--list`: pass remainder (optional area filter) to check-todos workflow
+- Otherwise: pass all of $ARGUMENTS to add-todo workflow
+</context>
+
+<process>
+1. Parse the leading flag (if any) from $ARGUMENTS.
+2. Load and execute the appropriate workflow end-to-end based on the routing table above.
+3. Preserve all workflow gates from the target workflow (directory structure, duplicate detection, commits, etc.).
+</process>

package/commands/sdd/cleanup.md

@@ -1,6 +1,12 @@
 ---
 name: sdd:cleanup
 description: Archive accumulated phase directories from completed milestones
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - AskUserQuestion
+requires: [phase]
 ---
 <objective>
 Archive phase directories from completed milestones into `.planning/milestones/v{X.Y}-phases/`.
@@ -13,6 +19,6 @@ Use when `.planning/phases/` has accumulated directories from past milestones.
 </execution_context>
 
 <process>
-Follow the cleanup workflow at @~/.claude/sdd/workflows/cleanup.md.
+Execute end-to-end.
 Identify completed milestones, show a dry-run summary, and archive on confirmation.
 </process>

package/commands/sdd/code-review.md

@@ -0,0 +1,59 @@
+---
+name: sdd:code-review
+description: Review source files changed during a phase for bugs, security issues, and code quality problems
+argument-hint: "<phase-number> [--depth=quick|standard|deep] [--files file1,file2,...] [--fix [--all] [--auto]]"
+allowed-tools:
+  - Read
+  - Bash
+  - Glob
+  - Grep
+  - Write
+  - Agent
+requires: [config, import, phase, quick, review]
+---
+<objective>
+Review source files changed during a phase for bugs, security vulnerabilities, and code quality problems.
+
+Spawns the sdd-code-reviewer agent to analyze code at the specified depth level. Produces REVIEW.md artifact in the phase directory with severity-classified findings.
+
+Arguments:
+- Phase number (required) — which phase's changes to review (e.g., "2" or "02")
+- `--depth=quick|standard|deep` (optional) — review depth level, overrides workflow.code_review_depth config
+  - quick: Pattern-matching only (~2 min)
+  - standard: Per-file analysis with language-specific checks (~5-15 min, default)
+  - deep: Cross-file analysis including import graphs and call chains (~15-30 min)
+- `--files file1,file2,...` (optional) — explicit comma-separated file list, skips SUMMARY/git scoping (highest precedence for scoping)
+- `--fix` (optional) — after review completes (or if REVIEW.md already exists), auto-apply fixes found. Spawns sdd-code-fixer agent. Accepts sub-flags:
+  - `--all` — include Info findings in fix scope (default: Critical + Warning only)
+  - `--auto` — enable fix + re-review iteration loop, capped at 3 iterations
+
+Output: {padded_phase}-REVIEW.md in phase directory + inline summary of findings
+</objective>
+
+<execution_context>
+@~/.claude/sdd/workflows/code-review.md
+</execution_context>
+
+<context>
+Phase: $ARGUMENTS (first positional argument is phase number)
+
+Optional flags parsed from $ARGUMENTS:
+- `--depth=VALUE` — Depth override (quick|standard|deep). If provided, overrides workflow.code_review_depth config.
+- `--files=file1,file2,...` — Explicit file list override. Has highest precedence for file scoping per D-08. When provided, workflow skips SUMMARY.md extraction and git diff fallback entirely.
+
+Context files (CLAUDE.md, SUMMARY.md, phase state) are resolved inside the workflow via `sdd-sdk query init.phase-op` and delegated to agent via `<files_to_read>` blocks.
+</context>
+
+<process>
+This command is a thin dispatch layer. It parses arguments and delegates to the workflow.
+
+Execute end-to-end.
+
+The workflow (not this command) enforces these gates:
+- Phase validation (before config gate)
+- Config gate check (workflow.code_review)
+- File scoping (--files override > SUMMARY.md > git diff fallback)
+- Empty scope check (skip if no files)
+- Agent spawning (sdd-code-reviewer)
+- Result presentation (inline summary + next steps)
+</process>

package/commands/sdd/complete-milestone.md

@@ -7,6 +7,7 @@ allowed-tools:
   - Read
   - Write
   - Bash
+requires: [audit-milestone, discuss-phase, execute-phase, new-milestone, phase, plan-phase, stats, update]
 ---
 
 <objective>
@@ -43,7 +44,10 @@ Output: Milestone archived (roadmap + requirements), PROJECT.md evolved, git tag
 
    - Look for `.planning/v{{version}}-MILESTONE-AUDIT.md`
    - If missing or stale: recommend `/sdd:audit-milestone` first
-   - If audit status is `gaps_found`: recommend `/sdd:plan-milestone-gaps` first
+   - If audit status is `gaps_found`: recommend closing the gaps inline
+     (the audit output already enumerates them — insert closure phases
+     via `/sdd:phase --insert <N>` plus the standard
+     discuss/plan/execute chain) before proceeding.
    - If audit status is `passed`: proceed to step 1
 
    ```markdown
@@ -54,8 +58,11 @@ Output: Milestone archived (roadmap + requirements), PROJECT.md evolved, git tag
    requirements coverage, cross-phase integration, and E2E flows.
 
    {If audit has gaps:}
-   ⚠ Milestone audit found gaps. Run `/sdd:plan-milestone-gaps` to create
-   phases that close the gaps, or proceed anyway to accept as tech debt.
+   ⚠ Milestone audit found gaps. The audit output already enumerates the
+   unsatisfied requirements, cross-phase issues, and broken flows — insert
+   a closure phase per gap with `/sdd:phase --insert <N>` and run the
+   standard `/sdd:discuss-phase` → `/sdd:plan-phase` → `/sdd:execute-phase`
+   chain. Or proceed anyway to accept the gaps as tech debt.
 
    {If audit passed:}
    ✓ Milestone audit passed. Proceeding with completion.
@@ -119,7 +126,7 @@ Output: Milestone archived (roadmap + requirements), PROJECT.md evolved, git tag
 - `.planning/REQUIREMENTS.md` deleted (fresh for next milestone)
 - ROADMAP.md collapsed to one-line entry
 - PROJECT.md updated with current state
-- Git tag v{{version}} created
+- Git tag v{{version}} created (if `git.create_tag` enabled)
 - Commit successful
 - User knows next steps (including need for fresh requirements)
   </success_criteria>

package/commands/sdd/config.md

@@ -0,0 +1,58 @@
+---
+name: sdd:config
+description: Configure SDD settings — workflow toggles, advanced knobs, integrations, and model profile
+argument-hint: "[--advanced | --integrations | --profile <name>]"
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - AskUserQuestion
+requires: [code-review, review, settings]
+---
+
+<objective>
+Configure SDD settings interactively with a single consolidated command.
+
+Mode routing:
+- **default** (no flag): Common-case toggles (model, research, plan_check, verifier, branching) → settings workflow
+- **--advanced**: Power-user knobs (planning tuning, timeouts, branch templates, cross-AI execution) → settings-advanced workflow
+- **--integrations**: Third-party API keys, code-review CLI routing, agent-skill injection → settings-integrations workflow
+- **--profile <name>**: Switch model profile (quality|balanced|budget|inherit) → set-profile (inline)
+</objective>
+
+<routing>
+
+| Flag | Action | Workflow |
+|------|--------|----------|
+| (none) | Interactive 5-question common-case config prompt | settings |
+| --advanced | Power-user knobs: planning, execution, discussion, cross-AI, git, runtime | settings-advanced |
+| --integrations | API keys (Brave/Firecrawl/Exa), review CLI routing, agent skills | settings-integrations |
+| --profile &lt;name&gt; | Switch model profile without interactive prompt | sdd-sdk config-set-model-profile |
+
+</routing>
+
+<execution_context>
+@~/.claude/sdd/workflows/settings.md
+@~/.claude/sdd/workflows/settings-advanced.md
+@~/.claude/sdd/workflows/settings-integrations.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS
+
+Parse the first token of $ARGUMENTS:
+- If it is `--advanced`: strip the flag, execute settings-advanced workflow
+- If it is `--integrations`: strip the flag, execute settings-integrations workflow
+- If it starts with `--profile`: extract the profile name (remainder after `--profile`), then:
+  1. **Pre-flight check (#2439):** verify `sdd-sdk` is on PATH via `command -v sdd-sdk`.
+     If absent, emit the install hint `Install SDD via 'npm i -g sdd'` and stop —
+     do NOT invoke `sdd-sdk` directly (avoids the opaque `command not found: sdd-sdk` failure).
+  2. Run: `sdd-sdk query config-set-model-profile <profile-name> --raw` and display the output verbatim.
+- Otherwise: execute settings workflow (no argument needed)
+</context>
+
+<process>
+1. Parse the leading flag (if any) from $ARGUMENTS.
+2. Load and execute the appropriate workflow end-to-end, or run the inline SDK command for --profile.
+3. Preserve all workflow gates from the target workflow.
+</process>

package/commands/sdd/debug.md

@@ -1,11 +1,12 @@
 ---
 name: sdd:debug
 description: Systematic debugging with persistent state across context resets
-argument-hint: [issue description]
+argument-hint: "[list | status <slug> | continue <slug> | --diagnose] [issue description]"
 allowed-tools:
   - Read
+  - Write
   - Bash
-  - Task
+  - Agent
   - AskUserQuestion
 ---
 
@@ -14,160 +15,38 @@ Debug issues using scientific method with subagent isolation.
 
 **Orchestrator role:** Gather symptoms, spawn sdd-debugger agent, handle checkpoints, spawn continuations.
 
-**Why subagent:** Investigation burns context fast (reading files, forming hypotheses, testing). Fresh 200k context per investigation. Main context stays lean for user interaction.
+**Flags:**
+- `--diagnose` — Diagnose only. Returns a Root Cause Report without applying a fix.
+
+**Subcommands:** `list` · `status <slug>` · `continue <slug>`
 </objective>
 
 <available_agent_types>
 Valid SDD subagent types (use exact names — do not fall back to 'general-purpose'):
-- sdd-debugger — Diagnoses and fixes issues
+- sdd-debug-session-manager — manages debug checkpoint/continuation loop in isolated context
+- sdd-debugger — investigates bugs using scientific method
 </available_agent_types>
 
+<execution_context>
+@~/.claude/sdd/workflows/debug.md
+</execution_context>
+
 <context>
-User's issue: $ARGUMENTS
+User's input: $ARGUMENTS
+
+Parse subcommands and flags from $ARGUMENTS BEFORE the active-session check:
+- If $ARGUMENTS starts with "list": SUBCMD=list, no further args
+- If $ARGUMENTS starts with "status ": SUBCMD=status, SLUG=remainder (trim whitespace)
+- If $ARGUMENTS starts with "continue ": SUBCMD=continue, SLUG=remainder (trim whitespace)
+- If $ARGUMENTS contains `--diagnose`: SUBCMD=debug, diagnose_only=true, strip `--diagnose` from description
+- Otherwise: SUBCMD=debug, diagnose_only=false
 
-Check for active sessions:
+Check for active sessions (used for non-list/status/continue flows):
 ```bash
 ls .planning/debug/*.md 2>/dev/null | grep -v resolved | head -5
 ```
 </context>
 
 <process>
-
-## 0. Initialize Context
-
-```bash
-INIT=$(node "$HOME/.claude/sdd/bin/sdd-tools.cjs" state load)
-if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
-```
-
-Extract `commit_docs` from init JSON. Resolve debugger model:
-```bash
-debugger_model=$(node "$HOME/.claude/sdd/bin/sdd-tools.cjs" resolve-model sdd-debugger --raw)
-```
-
-## 1. Check Active Sessions
-
-If active sessions exist AND no $ARGUMENTS:
-- List sessions with status, hypothesis, next action
-- User picks number to resume OR describes new issue
-
-If $ARGUMENTS provided OR user describes new issue:
-- Continue to symptom gathering
-
-## 2. Gather Symptoms (if new issue)
-
-Use AskUserQuestion for each:
-
-1. **Expected behavior** - What should happen?
-2. **Actual behavior** - What happens instead?
-3. **Error messages** - Any errors? (paste or describe)
-4. **Timeline** - When did this start? Ever worked?
-5. **Reproduction** - How do you trigger it?
-
-After all gathered, confirm ready to investigate.
-
-## 3. Spawn sdd-debugger Agent
-
-Fill prompt and spawn:
-
-```markdown
-<objective>
-Investigate issue: {slug}
-
-**Summary:** {trigger}
-</objective>
-
-<symptoms>
-expected: {expected}
-actual: {actual}
-errors: {errors}
-reproduction: {reproduction}
-timeline: {timeline}
-</symptoms>
-
-<mode>
-symptoms_prefilled: true
-goal: find_and_fix
-</mode>
-
-<debug_file>
-Create: .planning/debug/{slug}.md
-</debug_file>
-```
-
-```
-Task(
-  prompt=filled_prompt,
-  subagent_type="sdd-debugger",
-  model="{debugger_model}",
-  description="Debug {slug}"
-)
-```
-
-## 4. Handle Agent Return
-
-**If `## ROOT CAUSE FOUND`:**
-- Display root cause and evidence summary
-- Offer options:
-  - "Fix now" - spawn fix subagent
-  - "Plan fix" - suggest /sdd:plan-phase --gaps
-  - "Manual fix" - done
-
-**If `## CHECKPOINT REACHED`:**
-- Present checkpoint details to user
-- Get user response
-- If checkpoint type is `human-verify`:
-  - If user confirms fixed: continue so agent can finalize/resolve/archive
-  - If user reports issues: continue so agent returns to investigation/fixing
-- Spawn continuation agent (see step 5)
-
-**If `## INVESTIGATION INCONCLUSIVE`:**
-- Show what was checked and eliminated
-- Offer options:
-  - "Continue investigating" - spawn new agent with additional context
-  - "Manual investigation" - done
-  - "Add more context" - gather more symptoms, spawn again
-
-## 5. Spawn Continuation Agent (After Checkpoint)
-
-When user responds to checkpoint, spawn fresh agent:
-
-```markdown
-<objective>
-Continue debugging {slug}. Evidence is in the debug file.
-</objective>
-
-<prior_state>
-<files_to_read>
-- .planning/debug/{slug}.md (Debug session state)
-</files_to_read>
-</prior_state>
-
-<checkpoint_response>
-**Type:** {checkpoint_type}
-**Response:** {user_response}
-</checkpoint_response>
-
-<mode>
-goal: find_and_fix
-</mode>
-```
-
-```
-Task(
-  prompt=continuation_prompt,
-  subagent_type="sdd-debugger",
-  model="{debugger_model}",
-  description="Continue debug {slug}"
-)
-```
-
+Execute end-to-end.
 </process>
-
-<success_criteria>
-- [ ] Active sessions checked
-- [ ] Symptoms gathered (if new)
-- [ ] sdd-debugger spawned with context
-- [ ] Checkpoints handled correctly
-- [ ] Root cause confirmed before fixing
-</success_criteria>