agileflow 3.3.0 → 3.4.1

package/src/core/commands/{audit → code}/completeness.md

@@ -1,15 +1,15 @@
 ---
 description: Multi-agent analysis for forgotten features, dead handlers, stub code, and incomplete implementations
-argument-hint: "[file|directory] [DEPTH=quick|deep] [FOCUS=handlers|routes|api|stubs|state|imports|conditional|all]"
+argument-hint: "[file|directory] [DEPTH=quick|deep|ultradeep|extreme] [FOCUS=handlers|routes|api|stubs|state|imports|conditional|all] [MODEL=haiku|sonnet|opus]"
 compact_context:
   priority: high
   preserve_rules:
-    - "ACTIVE COMMAND: /agileflow:audit:completeness - Multi-agent forgotten features analysis"
+    - "ACTIVE COMMAND: /agileflow:code:completeness - Multi-agent forgotten features analysis"
     - "CRITICAL: Deploy analyzers IN PARALLEL in ONE message with multiple Task calls"
     - "CRITICAL: Wait for all results before running consensus (use TaskOutput with block=true)"
     - "CRITICAL: Severity scale: BROKEN > INCOMPLETE > PLACEHOLDER > DORMANT"
     - "CRITICAL: Confidence scoring: CONFIRMED (2+ agree), LIKELY (1 with evidence), INVESTIGATE (1 weak)"
-    - "MUST parse arguments: TARGET (file/dir), DEPTH (quick/deep), FOCUS (handlers|routes|api|stubs|state|imports|conditional|all)"
+    - "MUST parse arguments: TARGET (file/dir), DEPTH (quick/deep/ultradeep), FOCUS (handlers|routes|api|stubs|state|imports|conditional|all)"
     - "Pass consensus all analyzer outputs, let it synthesize the final report"
   state_fields:
     - target_path
@@ -19,7 +19,7 @@ compact_context:
     - findings_collected
 ---
 
-# /agileflow:audit:completeness
+# /agileflow:code:completeness
 
 Deploy multiple specialized completeness analyzers in parallel to find forgotten features, dead handlers, stub code, and incomplete implementations, then synthesize results through consensus voting into a prioritized Completeness Audit Report.
 
@@ -28,11 +28,11 @@ Deploy multiple specialized completeness analyzers in parallel to find forgotten
 ## Quick Reference
 
 ```
-/agileflow:audit:completeness app/                                    # Analyze app directory (quick, core 5 analyzers)
-/agileflow:audit:completeness . DEPTH=deep                            # Deep analysis - all 7 analyzers
-/agileflow:audit:completeness src/ FOCUS=handlers,routes               # Focus on specific areas
-/agileflow:audit:completeness . DEPTH=deep FOCUS=all                   # Comprehensive full audit
-/agileflow:audit:completeness components/ FOCUS=stubs,state            # Check stubs and unused state
+/agileflow:code:completeness app/                                    # Analyze app directory (quick, core 5 analyzers)
+/agileflow:code:completeness . DEPTH=deep                            # Deep analysis - all 7 analyzers
+/agileflow:code:completeness src/ FOCUS=handlers,routes               # Focus on specific areas
+/agileflow:code:completeness . DEPTH=deep FOCUS=all                   # Comprehensive full audit
+/agileflow:code:completeness components/ FOCUS=stubs,state            # Check stubs and unused state
 ```
 
 ---
@@ -41,7 +41,7 @@ Deploy multiple specialized completeness analyzers in parallel to find forgotten
 
 ```
 ┌─────────────────────────────────────────────────────────────┐
-│              /agileflow:audit:completeness                    │
+│              /agileflow:code:completeness                    │
 │                                                              │
 │  1. Parse arguments (target, depth, focus)                   │
 │  2. Deploy analyzers IN PARALLEL                             │
@@ -74,8 +74,9 @@ Deploy multiple specialized completeness analyzers in parallel to find forgotten
 | Argument | Values | Default | Description |
 |----------|--------|---------|-------------|
 | TARGET | file/directory | `.` | What to analyze |
-| DEPTH | quick, deep | quick | quick = core 5 analyzers, deep = all 7 |
+| DEPTH | quick, deep, ultradeep | quick | quick = core 5, deep = all 7, ultradeep = separate tmux sessions |
 | FOCUS | handlers,routes,api,stubs,state,imports,conditional,all | all | Which analyzers to deploy |
+| MODEL | haiku, sonnet, opus | haiku | Model for analyzer subagents. Default preserves existing behavior. |
 
 ---
 
@@ -118,6 +119,52 @@ FOCUS = all (default) or comma-separated list
 **DEPTH behavior**:
 - `quick` (default): Deploy core 5 analyzers. Focus on BROKEN/INCOMPLETE issues only.
 - `deep`: Deploy all 7 analyzers. Include PLACEHOLDER/DORMANT findings.
+- `ultradeep`: Spawn each analyzer as a separate Claude Code session in tmux. Requires tmux. Uses model profiles from metadata. Falls back to `deep` if tmux unavailable.
+
+**ULTRADEEP mode** (DEPTH=ultradeep):
+1. Show cost estimate:
+   ```bash
+   node .agileflow/scripts/spawn-audit-sessions.js --audit=completeness --target=TARGET --focus=FOCUS --model=MODEL --dry-run
+   ```
+2. Confirm with user before launching
+3. Spawn sessions (use `--json` to capture trace ID):
+   ```bash
+   node .agileflow/scripts/spawn-audit-sessions.js --audit=completeness --target=TARGET --focus=FOCUS --model=MODEL --json
+   ```
+   Parse the JSON output to get `traceId`. Example: `{"ok":true,"traceId":"abc123ef",...}`
+4. Wait for all analyzers to complete:
+   ```bash
+   node .agileflow/scripts/lib/tmux-audit-monitor.js wait TRACE_ID --timeout=1800
+   ```
+   - Exit 0 = all complete (JSON results on stdout)
+   - Exit 1 = timeout (partial results on stdout, `missing` array shows what's left)
+   - To check progress without blocking: `node .agileflow/scripts/lib/tmux-audit-monitor.js status TRACE_ID`
+   - To retry stalled analyzers: `node .agileflow/scripts/lib/tmux-audit-monitor.js retry TRACE_ID`
+5. Parse `results` array from the JSON output. Pass all findings to consensus coordinator (same as deep mode).
+6. If tmux unavailable (spawn exits code 2), fall back to `DEPTH=deep` with warning
+
+**EXTREME mode** (DEPTH=extreme):
+Partition-based multi-agent audit. Instead of 1 analyzer per tmux window, the codebase is split into partitions and each partition runs ALL analyzers.
+1. Scan the target directory to understand the codebase structure:
+   - Use Glob to find top-level source directories
+   - Group related directories into 3-7 logical partitions (coherent domains: auth, api, ui, etc.)
+   - If user provided PARTITIONS=N (a number), split into exactly N partitions
+   - If user provided PARTITIONS=dir1,dir2,dir3, use those exact directories
+2. Show the partition plan and agent count to the user, confirm before launching:
+   Example: "5 partitions x 7 analyzers = 35 agents. Estimated cost: $X. Proceed?"
+3. Spawn sessions with partitions:
+   ```bash
+   node .agileflow/scripts/spawn-audit-sessions.js --audit=completeness --target=TARGET --depth=extreme --partitions=dir1,dir2,dir3 --model=MODEL --json
+   ```
+4. Wait and collect results (same as ultradeep - use tmux-audit-monitor.js)
+5. Run consensus on combined results from all partitions
+
+**PARTITIONS argument** (only used with DEPTH=extreme):
+| Value | Behavior |
+|-------|----------|
+| Not set | AI decides partitions (3-7 based on codebase size) |
+| `PARTITIONS=5` | AI creates exactly 5 partitions |
+| `PARTITIONS=src/auth,src/api,lib` | Use these exact directories |
 
 ### STEP 2: Deploy Analyzers in Parallel
 
@@ -377,13 +424,13 @@ Total: 10 findings (3 intentional exclusions)
 <!-- COMPACT_SUMMARY_START -->
 ## Compact Summary
 
-**Command**: `/agileflow:audit:completeness` - Multi-agent forgotten features analysis with consensus
+**Command**: `/agileflow:code:completeness` - Multi-agent forgotten features analysis with consensus
 
 **Quick Usage**:
 ```
-/agileflow:audit:completeness app/                           # Quick scan (core 5 analyzers)
-/agileflow:audit:completeness . DEPTH=deep                   # All 7 analyzers
-/agileflow:audit:completeness src/ FOCUS=handlers,routes      # Specific areas
+/agileflow:code:completeness app/                           # Quick scan (core 5 analyzers)
+/agileflow:code:completeness . DEPTH=deep                   # All 7 analyzers
+/agileflow:code:completeness src/ FOCUS=handlers,routes      # Specific areas
 ```
 
 **What It Does**: Deploy completeness analyzers in parallel -> Each finds different incomplete implementation classes -> Consensus coordinator validates, filters by project type, classifies user impact -> Actionable Completeness Audit Report
@@ -417,11 +464,11 @@ Total: 10 findings (3 intentional exclusions)
 
 ## Boundary Rules (No Overlap)
 
-- **vs audit:security**: No vulnerabilities, XSS, injection, auth bypass - those are security domain
-- **vs audit:logic**: No race conditions, type bugs, edge cases, control flow - those are logic domain
-- **vs audit:performance**: No slow queries, memory leaks, bundle size - those are performance domain
-- **vs audit:test**: No missing tests, weak assertions, test patterns - those are test domain
-- **vs audit:legal**: No compliance, GDPR, licensing - those are legal domain
+- **vs code:security**: No vulnerabilities, XSS, injection, auth bypass - those are security domain
+- **vs code:logic**: No race conditions, type bugs, edge cases, control flow - those are logic domain
+- **vs code:performance**: No slow queries, memory leaks, bundle size - those are performance domain
+- **vs code:test**: No missing tests, weak assertions, test patterns - those are test domain
+- **vs code:legal**: No compliance, GDPR, licensing - those are legal domain
 - **This audit asks**: Are features fully wired up? Do buttons work? Is stub code shipped?
 
 ---
@@ -447,10 +494,10 @@ Fix before merging? [Y/n]
 
 ## Related Commands
 
-- `/agileflow:audit:security` - Security vulnerability analysis (similar architecture)
-- `/agileflow:audit:logic` - Logic bug analysis (similar architecture)
-- `/agileflow:audit:performance` - Performance bottleneck analysis (similar architecture)
-- `/agileflow:audit:test` - Test quality analysis (similar architecture)
-- `/agileflow:audit:legal` - Legal compliance analysis (similar architecture)
+- `/agileflow:code:security` - Security vulnerability analysis (similar architecture)
+- `/agileflow:code:logic` - Logic bug analysis (similar architecture)
+- `/agileflow:code:performance` - Performance bottleneck analysis (similar architecture)
+- `/agileflow:code:test` - Test quality analysis (similar architecture)
+- `/agileflow:code:legal` - Legal compliance analysis (similar architecture)
 - `/agileflow:review` - Code review (includes some completeness checks)
 - `/agileflow:multi-expert` - General multi-expert analysis

package/src/core/commands/{audit → code}/legal.md

@@ -1,14 +1,14 @@
 ---
 description: Multi-agent legal risk analysis with consensus voting for finding compliance gaps
-argument-hint: "[file|directory] [DEPTH=quick|deep] [FOCUS=privacy|terms|a11y|licensing|consumer|security|ai|content|international|all]"
+argument-hint: "[file|directory] [DEPTH=quick|deep|ultradeep|extreme] [FOCUS=privacy|terms|a11y|licensing|consumer|security|ai|content|international|all] [MODEL=haiku|sonnet|opus]"
 compact_context:
   priority: high
   preserve_rules:
-    - "ACTIVE COMMAND: /agileflow:audit:legal - Multi-agent legal risk analysis"
+    - "ACTIVE COMMAND: /agileflow:code:legal - Multi-agent legal risk analysis"
     - "CRITICAL: Deploy analyzers IN PARALLEL in ONE message with multiple Task calls"
     - "CRITICAL: Wait for all results before running consensus (use TaskOutput with block=true)"
     - "CRITICAL: Confidence scoring: CONFIRMED (2+ agree), LIKELY (1 with evidence), INVESTIGATE (1 weak)"
-    - "MUST parse arguments: TARGET (file/dir), DEPTH (quick/deep), FOCUS (privacy|terms|a11y|licensing|consumer|security|ai|content|international|all)"
+    - "MUST parse arguments: TARGET (file/dir), DEPTH (quick/deep/ultradeep), FOCUS (privacy|terms|a11y|licensing|consumer|security|ai|content|international|all)"
     - "Pass consensus all analyzer outputs, let it synthesize the final report"
   state_fields:
     - target_path
@@ -18,7 +18,7 @@ compact_context:
     - findings_collected
 ---
 
-# /agileflow:audit:legal
+# /agileflow:code:legal
 
 Deploy multiple specialized legal risk analyzers in parallel to find compliance gaps, then synthesize results through consensus voting into a prioritized Legal Risk Report.
 
@@ -27,11 +27,11 @@ Deploy multiple specialized legal risk analyzers in parallel to find compliance
 ## Quick Reference
 
 ```
-/agileflow:audit:legal app/                                # Analyze app directory (quick, core 5 analyzers)
-/agileflow:audit:legal . DEPTH=deep                        # Deep analysis - all 9 analyzers
-/agileflow:audit:legal src/ FOCUS=privacy,a11y             # Focus on specific areas
-/agileflow:audit:legal . DEPTH=deep FOCUS=all              # Comprehensive full audit
-/agileflow:audit:legal app/page.tsx FOCUS=ai               # Check single file for AI compliance
+/agileflow:code:legal app/                                # Analyze app directory (quick, core 5 analyzers)
+/agileflow:code:legal . DEPTH=deep                        # Deep analysis - all 9 analyzers
+/agileflow:code:legal src/ FOCUS=privacy,a11y             # Focus on specific areas
+/agileflow:code:legal . DEPTH=deep FOCUS=all              # Comprehensive full audit
+/agileflow:code:legal app/page.tsx FOCUS=ai               # Check single file for AI compliance
 ```
 
 ---
@@ -40,7 +40,7 @@ Deploy multiple specialized legal risk analyzers in parallel to find compliance
 
 ```
 ┌─────────────────────────────────────────────────────────────┐
-│                 /agileflow:audit:legal                       │
+│                 /agileflow:code:legal                       │
 │                                                              │
 │  1. Parse arguments (target, depth, focus)                   │
 │  2. Deploy analyzers IN PARALLEL                             │
@@ -73,8 +73,9 @@ Deploy multiple specialized legal risk analyzers in parallel to find compliance
 | Argument | Values | Default | Description |
 |----------|--------|---------|-------------|
 | TARGET | file/directory | `.` | What to analyze |
-| DEPTH | quick, deep | quick | quick = core 5 analyzers, deep = all 9 |
+| DEPTH | quick, deep, ultradeep | quick | quick = core 5, deep = all 9, ultradeep = separate tmux sessions |
 | FOCUS | privacy,terms,a11y,licensing,consumer,security,ai,content,international,all | all | Which analyzers to deploy |
+| MODEL | haiku, sonnet, opus | haiku | Model for analyzer subagents. Default preserves existing behavior. |
 
 ---
 
@@ -108,6 +109,52 @@ FOCUS = all (default) or comma-separated list
 **DEPTH behavior**:
 - `quick` (default): Deploy core 5 analyzers. Focus on CRITICAL/HIGH issues only.
 - `deep`: Deploy all 9 analyzers. Include MEDIUM/LOW findings.
+- `ultradeep`: Spawn each analyzer as a separate Claude Code session in tmux. Requires tmux. Uses model profiles from metadata. Falls back to `deep` if tmux unavailable.
+
+**ULTRADEEP mode** (DEPTH=ultradeep):
+1. Show cost estimate:
+   ```bash
+   node .agileflow/scripts/spawn-audit-sessions.js --audit=legal --target=TARGET --focus=FOCUS --model=MODEL --dry-run
+   ```
+2. Confirm with user before launching
+3. Spawn sessions (use `--json` to capture trace ID):
+   ```bash
+   node .agileflow/scripts/spawn-audit-sessions.js --audit=legal --target=TARGET --focus=FOCUS --model=MODEL --json
+   ```
+   Parse the JSON output to get `traceId`. Example: `{"ok":true,"traceId":"abc123ef",...}`
+4. Wait for all analyzers to complete:
+   ```bash
+   node .agileflow/scripts/lib/tmux-audit-monitor.js wait TRACE_ID --timeout=1800
+   ```
+   - Exit 0 = all complete (JSON results on stdout)
+   - Exit 1 = timeout (partial results on stdout, `missing` array shows what's left)
+   - To check progress without blocking: `node .agileflow/scripts/lib/tmux-audit-monitor.js status TRACE_ID`
+   - To retry stalled analyzers: `node .agileflow/scripts/lib/tmux-audit-monitor.js retry TRACE_ID`
+5. Parse `results` array from the JSON output. Pass all findings to consensus coordinator (same as deep mode).
+6. If tmux unavailable (spawn exits code 2), fall back to `DEPTH=deep` with warning
+
+**EXTREME mode** (DEPTH=extreme):
+Partition-based multi-agent audit. Instead of 1 analyzer per tmux window, the codebase is split into partitions and each partition runs ALL analyzers.
+1. Scan the target directory to understand the codebase structure:
+   - Use Glob to find top-level source directories
+   - Group related directories into 3-7 logical partitions (coherent domains: auth, api, ui, etc.)
+   - If user provided PARTITIONS=N (a number), split into exactly N partitions
+   - If user provided PARTITIONS=dir1,dir2,dir3, use those exact directories
+2. Show the partition plan and agent count to the user, confirm before launching:
+   Example: "5 partitions x 9 analyzers = 45 agents. Estimated cost: $X. Proceed?"
+3. Spawn sessions with partitions:
+   ```bash
+   node .agileflow/scripts/spawn-audit-sessions.js --audit=legal --target=TARGET --depth=extreme --partitions=dir1,dir2,dir3 --model=MODEL --json
+   ```
+4. Wait and collect results (same as ultradeep - use tmux-audit-monitor.js)
+5. Run consensus on combined results from all partitions
+
+**PARTITIONS argument** (only used with DEPTH=extreme):
+| Value | Behavior |
+|-------|----------|
+| Not set | AI decides partitions (3-7 based on codebase size) |
+| `PARTITIONS=5` | AI creates exactly 5 partitions |
+| `PARTITIONS=src/auth,src/api,lib` | Use these exact directories |
 
 ### STEP 2: Deploy Analyzers in Parallel
 
@@ -379,13 +426,13 @@ Total: 10 findings (3 false positives excluded)
 <!-- COMPACT_SUMMARY_START -->
 ## Compact Summary
 
-**Command**: `/agileflow:audit:legal` - Multi-agent legal risk analysis with consensus
+**Command**: `/agileflow:code:legal` - Multi-agent legal risk analysis with consensus
 
 **Quick Usage**:
 ```
-/agileflow:audit:legal app/                        # Quick scan (core 5 analyzers)
-/agileflow:audit:legal . DEPTH=deep                # All 9 analyzers
-/agileflow:audit:legal src/ FOCUS=privacy,a11y     # Specific areas
+/agileflow:code:legal app/                        # Quick scan (core 5 analyzers)
+/agileflow:code:legal . DEPTH=deep                # All 9 analyzers
+/agileflow:code:legal src/ FOCUS=privacy,a11y     # Specific areas
 ```
 
 **What It Does**: Deploy legal analyzers in parallel → Each finds different compliance gaps → Consensus coordinator validates, filters by project type, prioritizes → Actionable Legal Risk Report
@@ -440,7 +487,7 @@ Fix before launch? [Y/n]
 
 ## Related Commands
 
-- `/agileflow:audit:logic` - Logic bug analysis (similar architecture)
+- `/agileflow:code:logic` - Logic bug analysis (similar architecture)
 - `/agileflow:review` - Code review (includes some compliance checks)
 - `/agileflow:multi-expert` - General multi-expert analysis
 - `/agileflow:verify` - Run tests

package/src/core/commands/{audit → code}/logic.md

@@ -1,14 +1,14 @@
 ---
 description: Multi-agent logic analysis with consensus voting for finding logic bugs
-argument-hint: "[file|directory] [DEPTH=quick|deep] [FOCUS=edge|invariant|flow|type|race|all]"
+argument-hint: "[file|directory] [DEPTH=quick|deep|ultradeep|extreme] [FOCUS=edge|invariant|flow|type|race|all] [MODEL=haiku|sonnet|opus]"
 compact_context:
   priority: high
   preserve_rules:
-    - "ACTIVE COMMAND: /agileflow:audit:logic - Multi-agent logic analysis"
+    - "ACTIVE COMMAND: /agileflow:code:logic - Multi-agent logic analysis"
     - "CRITICAL: Deploy analyzers IN PARALLEL in ONE message with multiple Task calls"
     - "CRITICAL: Wait for all results before running consensus (use TaskOutput with block=true)"
     - "CRITICAL: Confidence scoring: CONFIRMED (2+ agree), LIKELY (1 with evidence), INVESTIGATE (1 weak)"
-    - "MUST parse arguments: TARGET (file/dir), DEPTH (quick/deep), FOCUS (edge/invariant/flow/type/race/all)"
+    - "MUST parse arguments: TARGET (file/dir), DEPTH (quick/deep/ultradeep), FOCUS (edge/invariant/flow/type/race/all)"
     - "Pass consensus all analyzer outputs, let it synthesize the final report"
   state_fields:
     - target_path
@@ -18,7 +18,7 @@ compact_context:
     - findings_collected
 ---
 
-# /agileflow:audit:logic
+# /agileflow:code:logic
 
 Deploy multiple specialized logic analyzers in parallel to find bugs, then synthesize results through consensus voting.
 
@@ -27,10 +27,12 @@ Deploy multiple specialized logic analyzers in parallel to find bugs, then synth
 ## Quick Reference
 
 ```
-/agileflow:audit:logic src/utils.js                    # Analyze single file
-/agileflow:audit:logic src/ DEPTH=deep                 # Deep analysis of directory
-/agileflow:audit:logic . FOCUS=race,type               # Focus on race conditions and type issues
-/agileflow:audit:logic src/cart.js DEPTH=quick         # Quick scan of specific file
+/agileflow:code:logic src/utils.js                    # Analyze single file
+/agileflow:code:logic src/ DEPTH=deep                 # Deep analysis of directory
+/agileflow:code:logic . FOCUS=race,type               # Focus on race conditions and type issues
+/agileflow:code:logic src/cart.js DEPTH=quick         # Quick scan of specific file
+/agileflow:code:logic . DEPTH=ultradeep               # Each analyzer in its own tmux session
+/agileflow:code:logic src/ MODEL=sonnet               # Use Sonnet for all analyzers
 ```
 
 ---
@@ -39,7 +41,7 @@ Deploy multiple specialized logic analyzers in parallel to find bugs, then synth
 
 ```
 ┌─────────────────────────────────────────────────────────────┐
-│                 /agileflow:audit:logic                       │
+│                 /agileflow:code:logic                       │
 │                                                              │
 │  1. Parse arguments (target, depth, focus)                   │
 │  2. Deploy 5 analyzers IN PARALLEL                           │
@@ -69,8 +71,9 @@ Deploy multiple specialized logic analyzers in parallel to find bugs, then synth
 | Argument | Values | Default | Description |
 |----------|--------|---------|-------------|
 | TARGET | file/directory | `.` | What to analyze |
-| DEPTH | quick, deep | quick | quick = high-impact only, deep = comprehensive |
+| DEPTH | quick, deep, ultradeep | quick | quick = high-impact only, deep = comprehensive, ultradeep = separate tmux sessions |
 | FOCUS | edge,invariant,flow,type,race,all | all | Which analyzers to deploy |
+| MODEL | haiku, sonnet, opus | haiku | Model for analyzer subagents. Default preserves existing behavior. |
 
 ---
 
@@ -80,10 +83,55 @@ Deploy multiple specialized logic analyzers in parallel to find bugs, then synth
 
 ```
 TARGET = first argument or current directory
-DEPTH = quick (default) or deep
+DEPTH = quick (default), deep, or ultradeep
 FOCUS = all (default) or comma-separated list
 ```
 
+**ULTRADEEP mode** (DEPTH=ultradeep):
+1. Show cost estimate:
+   ```bash
+   node .agileflow/scripts/spawn-audit-sessions.js --audit=logic --target=TARGET --focus=FOCUS --model=MODEL --dry-run
+   ```
+2. Confirm with user before launching
+3. Spawn sessions (use `--json` to capture trace ID):
+   ```bash
+   node .agileflow/scripts/spawn-audit-sessions.js --audit=logic --target=TARGET --focus=FOCUS --model=MODEL --json
+   ```
+   Parse the JSON output to get `traceId`. Example: `{"ok":true,"traceId":"abc123ef",...}`
+4. Wait for all analyzers to complete:
+   ```bash
+   node .agileflow/scripts/lib/tmux-audit-monitor.js wait TRACE_ID --timeout=1800
+   ```
+   - Exit 0 = all complete (JSON results on stdout)
+   - Exit 1 = timeout (partial results on stdout, `missing` array shows what's left)
+   - To check progress without blocking: `node .agileflow/scripts/lib/tmux-audit-monitor.js status TRACE_ID`
+   - To retry stalled analyzers: `node .agileflow/scripts/lib/tmux-audit-monitor.js retry TRACE_ID`
+5. Parse `results` array from the JSON output. Pass all findings to consensus coordinator (same as deep mode).
+6. If tmux unavailable (spawn exits code 2), fall back to `DEPTH=deep` with warning
+
+**EXTREME mode** (DEPTH=extreme):
+Partition-based multi-agent audit. Instead of 1 analyzer per tmux window, the codebase is split into partitions and each partition runs ALL analyzers.
+1. Scan the target directory to understand the codebase structure:
+   - Use Glob to find top-level source directories
+   - Group related directories into 3-7 logical partitions (coherent domains: auth, api, ui, etc.)
+   - If user provided PARTITIONS=N (a number), split into exactly N partitions
+   - If user provided PARTITIONS=dir1,dir2,dir3, use those exact directories
+2. Show the partition plan and agent count to the user, confirm before launching:
+   Example: "5 partitions x 5 analyzers = 25 agents. Estimated cost: $X. Proceed?"
+3. Spawn sessions with partitions:
+   ```bash
+   node .agileflow/scripts/spawn-audit-sessions.js --audit=logic --target=TARGET --depth=extreme --partitions=dir1,dir2,dir3 --model=MODEL --json
+   ```
+4. Wait and collect results (same as ultradeep - use tmux-audit-monitor.js)
+5. Run consensus on combined results from all partitions
+
+**PARTITIONS argument** (only used with DEPTH=extreme):
+| Value | Behavior |
+|-------|----------|
+| Not set | AI decides partitions (3-7 based on codebase size) |
+| `PARTITIONS=5` | AI creates exactly 5 partitions |
+| `PARTITIONS=src/auth,src/api,lib` | Use these exact directories |
+
 **Analyzer Selection by FOCUS**:
 
 | FOCUS | Analyzers |
@@ -307,13 +355,13 @@ Total: 7 findings (2 false positives excluded)
 <!-- COMPACT_SUMMARY_START -->
 ## Compact Summary
 
-**Command**: `/agileflow:audit:logic` - Multi-agent logic analysis with consensus
+**Command**: `/agileflow:code:logic` - Multi-agent logic analysis with consensus
 
 **Quick Usage**:
 ```
-/agileflow:audit:logic src/utils.js                # Single file
-/agileflow:audit:logic src/ DEPTH=deep            # Deep analysis
-/agileflow:audit:logic . FOCUS=race,type          # Specific analyzers
+/agileflow:code:logic src/utils.js                # Single file
+/agileflow:code:logic src/ DEPTH=deep            # Deep analysis
+/agileflow:code:logic . FOCUS=race,type          # Specific analyzers
 ```
 
 **What It Does**: Deploy 5 logic analyzers in parallel → Each finds different bug classes → Consensus coordinator validates and prioritizes → Actionable report
@@ -354,7 +402,7 @@ Proceed with tests? [Y/n]
 
 To integrate with babysit, add to implementation workflow:
 1. Complete implementation
-2. Run `/agileflow:audit:logic {changed_files} DEPTH=quick`
+2. Run `/agileflow:code:logic {changed_files} DEPTH=quick`
 3. If critical issues → block, show findings
 4. If no critical → proceed to tests
 

package/src/core/commands/{audit → code}/performance.md

@@ -1,14 +1,14 @@
 ---
 description: Multi-agent performance bottleneck analysis with consensus voting for finding optimization opportunities
-argument-hint: "[file|directory] [DEPTH=quick|deep] [FOCUS=queries|rendering|memory|bundle|compute|network|caching|assets|all]"
+argument-hint: "[file|directory] [DEPTH=quick|deep|ultradeep|extreme] [FOCUS=queries|rendering|memory|bundle|compute|network|caching|assets|all] [MODEL=haiku|sonnet|opus]"
 compact_context:
   priority: high
   preserve_rules:
-    - "ACTIVE COMMAND: /agileflow:audit:performance - Multi-agent performance bottleneck analysis"
+    - "ACTIVE COMMAND: /agileflow:code:performance - Multi-agent performance bottleneck analysis"
     - "CRITICAL: Deploy analyzers IN PARALLEL in ONE message with multiple Task calls"
     - "CRITICAL: Wait for all results before running consensus (use TaskOutput with block=true)"
     - "CRITICAL: Confidence scoring: CONFIRMED (2+ agree), LIKELY (1 with evidence), INVESTIGATE (1 weak)"
-    - "MUST parse arguments: TARGET (file/dir), DEPTH (quick/deep), FOCUS (queries|rendering|memory|bundle|compute|network|caching|assets|all)"
+    - "MUST parse arguments: TARGET (file/dir), DEPTH (quick/deep/ultradeep), FOCUS (queries|rendering|memory|bundle|compute|network|caching|assets|all)"
     - "Pass consensus all analyzer outputs, let it synthesize the final report"
   state_fields:
     - target_path
@@ -18,7 +18,7 @@ compact_context:
     - findings_collected
 ---
 
-# /agileflow:audit:performance
+# /agileflow:code:performance
 
 Deploy multiple specialized performance analyzers in parallel to find bottlenecks and optimization opportunities, then synthesize results through consensus voting into a prioritized Performance Audit Report.
 
@@ -27,11 +27,11 @@ Deploy multiple specialized performance analyzers in parallel to find bottleneck
 ## Quick Reference
 
 ```
-/agileflow:audit:performance app/                                # Analyze app directory (quick, core 5 analyzers)
-/agileflow:audit:performance . DEPTH=deep                        # Deep analysis - all 8 analyzers
-/agileflow:audit:performance src/ FOCUS=queries,memory            # Focus on specific areas
-/agileflow:audit:performance . DEPTH=deep FOCUS=all               # Comprehensive full audit
-/agileflow:audit:performance app/api/ FOCUS=queries               # Check API queries specifically
+/agileflow:code:performance app/                                # Analyze app directory (quick, core 5 analyzers)
+/agileflow:code:performance . DEPTH=deep                        # Deep analysis - all 8 analyzers
+/agileflow:code:performance src/ FOCUS=queries,memory            # Focus on specific areas
+/agileflow:code:performance . DEPTH=deep FOCUS=all               # Comprehensive full audit
+/agileflow:code:performance app/api/ FOCUS=queries               # Check API queries specifically
 ```
 
 ---
@@ -40,7 +40,7 @@ Deploy multiple specialized performance analyzers in parallel to find bottleneck
 
 ```
 +-------------------------------------------------------------+
-|                 /agileflow:audit:performance                  |
+|                 /agileflow:code:performance                  |
 |                                                               |
 |  1. Parse arguments (target, depth, focus)                    |
 |  2. Deploy analyzers IN PARALLEL                              |
@@ -73,8 +73,9 @@ Deploy multiple specialized performance analyzers in parallel to find bottleneck
 | Argument | Values | Default | Description |
 |----------|--------|---------|-------------|
 | TARGET | file/directory | `.` | What to analyze |
-| DEPTH | quick, deep | quick | quick = core 5 analyzers, deep = all 8 |
+| DEPTH | quick, deep, ultradeep | quick | quick = core 5, deep = all 8, ultradeep = separate tmux sessions |
 | FOCUS | queries,rendering,memory,bundle,compute,network,caching,assets,all | all | Which analyzers to deploy |
+| MODEL | haiku, sonnet, opus | haiku | Model for analyzer subagents. Default preserves existing behavior. |
 
 ---
 
@@ -107,6 +108,52 @@ FOCUS = all (default) or comma-separated list
 **DEPTH behavior**:
 - `quick` (default): Deploy core 5 analyzers. Focus on CRITICAL/HIGH issues only.
 - `deep`: Deploy all 8 analyzers. Include MEDIUM/LOW findings.
+- `ultradeep`: Spawn each analyzer as a separate Claude Code session in tmux. Requires tmux. Uses model profiles from metadata. Falls back to `deep` if tmux unavailable.
+
+**ULTRADEEP mode** (DEPTH=ultradeep):
+1. Show cost estimate:
+   ```bash
+   node .agileflow/scripts/spawn-audit-sessions.js --audit=performance --target=TARGET --focus=FOCUS --model=MODEL --dry-run
+   ```
+2. Confirm with user before launching
+3. Spawn sessions (use `--json` to capture trace ID):
+   ```bash
+   node .agileflow/scripts/spawn-audit-sessions.js --audit=performance --target=TARGET --focus=FOCUS --model=MODEL --json
+   ```
+   Parse the JSON output to get `traceId`. Example: `{"ok":true,"traceId":"abc123ef",...}`
+4. Wait for all analyzers to complete:
+   ```bash
+   node .agileflow/scripts/lib/tmux-audit-monitor.js wait TRACE_ID --timeout=1800
+   ```
+   - Exit 0 = all complete (JSON results on stdout)
+   - Exit 1 = timeout (partial results on stdout, `missing` array shows what's left)
+   - To check progress without blocking: `node .agileflow/scripts/lib/tmux-audit-monitor.js status TRACE_ID`
+   - To retry stalled analyzers: `node .agileflow/scripts/lib/tmux-audit-monitor.js retry TRACE_ID`
+5. Parse `results` array from the JSON output. Pass all findings to consensus coordinator (same as deep mode).
+6. If tmux unavailable (spawn exits code 2), fall back to `DEPTH=deep` with warning
+
+**EXTREME mode** (DEPTH=extreme):
+Partition-based multi-agent audit. Instead of 1 analyzer per tmux window, the codebase is split into partitions and each partition runs ALL analyzers.
+1. Scan the target directory to understand the codebase structure:
+   - Use Glob to find top-level source directories
+   - Group related directories into 3-7 logical partitions (coherent domains: auth, api, ui, etc.)
+   - If user provided PARTITIONS=N (a number), split into exactly N partitions
+   - If user provided PARTITIONS=dir1,dir2,dir3, use those exact directories
+2. Show the partition plan and agent count to the user, confirm before launching:
+   Example: "5 partitions x 8 analyzers = 40 agents. Estimated cost: $X. Proceed?"
+3. Spawn sessions with partitions:
+   ```bash
+   node .agileflow/scripts/spawn-audit-sessions.js --audit=performance --target=TARGET --depth=extreme --partitions=dir1,dir2,dir3 --model=MODEL --json
+   ```
+4. Wait and collect results (same as ultradeep - use tmux-audit-monitor.js)
+5. Run consensus on combined results from all partitions
+
+**PARTITIONS argument** (only used with DEPTH=extreme):
+| Value | Behavior |
+|-------|----------|
+| Not set | AI decides partitions (3-7 based on codebase size) |
+| `PARTITIONS=5` | AI creates exactly 5 partitions |
+| `PARTITIONS=src/auth,src/api,lib` | Use these exact directories |
 
 ### STEP 2: Deploy Analyzers in Parallel
 
@@ -368,13 +415,13 @@ FIX THIS SPRINT
 <!-- COMPACT_SUMMARY_START -->
 ## Compact Summary
 
-**Command**: `/agileflow:audit:performance` - Multi-agent performance bottleneck analysis with consensus
+**Command**: `/agileflow:code:performance` - Multi-agent performance bottleneck analysis with consensus
 
 **Quick Usage**:
 ```
-/agileflow:audit:performance app/                        # Quick scan (core 5 analyzers)
-/agileflow:audit:performance . DEPTH=deep                # All 8 analyzers
-/agileflow:audit:performance src/ FOCUS=queries,memory    # Specific areas
+/agileflow:code:performance app/                        # Quick scan (core 5 analyzers)
+/agileflow:code:performance . DEPTH=deep                # All 8 analyzers
+/agileflow:code:performance src/ FOCUS=queries,memory    # Specific areas
 ```
 
 **What It Does**: Deploy performance analyzers in parallel -> Each finds different bottleneck classes -> Consensus coordinator validates, filters by project type, estimates impact -> Actionable Performance Audit Report
@@ -409,8 +456,8 @@ FIX THIS SPRINT
 
 ## Boundary Rules (No Overlap)
 
-- **vs audit:logic**: No correctness bugs — only performance implications
-- **vs audit:security**: No vulnerability analysis — only efficiency
+- **vs code:logic**: No correctness bugs — only performance implications
+- **vs code:security**: No vulnerability analysis — only efficiency
 - **vs performance agent**: The `performance.md` agent is a team member for story work. This is an on-demand analysis tool
 
 ---
@@ -436,8 +483,8 @@ Fix before merging? [Y/n]
 
 ## Related Commands
 
-- `/agileflow:audit:logic` - Logic bug analysis (similar architecture)
-- `/agileflow:audit:security` - Security vulnerability analysis (similar architecture)
-- `/agileflow:audit:legal` - Legal compliance analysis (similar architecture)
+- `/agileflow:code:logic` - Logic bug analysis (similar architecture)
+- `/agileflow:code:security` - Security vulnerability analysis (similar architecture)
+- `/agileflow:code:legal` - Legal compliance analysis (similar architecture)
 - `/agileflow:multi-expert` - General multi-expert analysis
 - `/agileflow:verify` - Run tests