agileflow 3.0.0 → 3.0.1

package/CHANGELOG.md

@@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.0.1] - 2026-02-13
+
+### Fixed
+- Configure writes directly to Claude Code settings.json for Agent Teams and permissions
+
 ## [3.0.0] - 2026-02-13
 
 ### Added

package/README.md

@@ -3,7 +3,7 @@
 </p>
 
 [![npm version](https://img.shields.io/npm/v/agileflow?color=brightgreen)](https://www.npmjs.com/package/agileflow)
-[![Commands](https://img.shields.io/badge/commands-91-blue)](docs/04-architecture/commands.md)
+[![Commands](https://img.shields.io/badge/commands-93-blue)](docs/04-architecture/commands.md)
 [![Agents/Experts](https://img.shields.io/badge/agents%2Fexperts-47-orange)](docs/04-architecture/subagents.md)
 [![Skills](https://img.shields.io/badge/skills-dynamic-purple)](docs/04-architecture/skills.md)
 
@@ -65,7 +65,7 @@ AgileFlow combines three proven methodologies:
 
 | Component | Count | Description |
 |-----------|-------|-------------|
-| [Commands](docs/04-architecture/commands.md) | 91 | Slash commands for agile workflows |
+| [Commands](docs/04-architecture/commands.md) | 93 | Slash commands for agile workflows |
 | [Agents/Experts](docs/04-architecture/subagents.md) | 47 | Specialized agents with self-improving knowledge bases |
 | [Skills](docs/04-architecture/skills.md) | Dynamic | Generated on-demand with `/agileflow:skill:create` |
 
@@ -76,7 +76,7 @@ AgileFlow combines three proven methodologies:
 Full documentation lives in [`docs/04-architecture/`](docs/04-architecture/):
 
 ### Reference
-- [Commands](docs/04-architecture/commands.md) - All 91 slash commands
+- [Commands](docs/04-architecture/commands.md) - All 93 slash commands
 - [Agents/Experts](docs/04-architecture/subagents.md) - 47 specialized agents with self-improving knowledge
 - [Skills](docs/04-architecture/skills.md) - Dynamic skill generator with MCP integration
 

package/lib/dashboard-server.js

@@ -26,12 +26,30 @@ const { EventEmitter } = require('events');
 // Lazy-loaded dependencies - deferred until first use
 let _http, _crypto, _protocol, _paths, _validatePaths, _childProcess;
 
-function getHttp() { if (!_http) _http = require('http'); return _http; }
-function getCrypto() { if (!_crypto) _crypto = require('crypto'); return _crypto; }
-function getProtocol() { if (!_protocol) _protocol = require('./dashboard-protocol'); return _protocol; }
-function getPaths() { if (!_paths) _paths = require('./paths'); return _paths; }
-function getValidatePaths() { if (!_validatePaths) _validatePaths = require('./validate-paths'); return _validatePaths; }
-function getChildProcess() { if (!_childProcess) _childProcess = require('child_process'); return _childProcess; }
+function getHttp() {
+  if (!_http) _http = require('http');
+  return _http;
+}
+function getCrypto() {
+  if (!_crypto) _crypto = require('crypto');
+  return _crypto;
+}
+function getProtocol() {
+  if (!_protocol) _protocol = require('./dashboard-protocol');
+  return _protocol;
+}
+function getPaths() {
+  if (!_paths) _paths = require('./paths');
+  return _paths;
+}
+function getValidatePaths() {
+  if (!_validatePaths) _validatePaths = require('./validate-paths');
+  return _validatePaths;
+}
+function getChildProcess() {
+  if (!_childProcess) _childProcess = require('child_process');
+  return _childProcess;
+}
 
 // Lazy-load automation modules to avoid circular dependencies
 let AutomationRegistry = null;
@@ -294,7 +312,9 @@ class TerminalInstance {
       this.pty.on('error', error => {
         console.error('[Terminal] Shell error:', error.message);
         if (!this.closed) {
-          this.session.send(getProtocol().createTerminalOutput(this.id, `\r\nError: ${error.message}\r\n`));
+          this.session.send(
+            getProtocol().createTerminalOutput(this.id, `\r\nError: ${error.message}\r\n`)
+          );
         }
       });
 
@@ -558,7 +578,9 @@ class DashboardServer extends EventEmitter {
 
       this._automationRunner.on('failed', ({ automationId, result }) => {
         this._runningAutomations.delete(automationId);
-        this.broadcast(getProtocol().createAutomationStatus(automationId, 'error', { error: result.error }));
+        this.broadcast(
+          getProtocol().createAutomationStatus(automationId, 'error', { error: result.error })
+        );
 
         // Add failure to inbox
         this._addToInbox(automationId, result);
@@ -732,7 +754,7 @@ class DashboardServer extends EventEmitter {
 
     // Complete WebSocket handshake
     const key = req.headers['sec-websocket-key'];
-    const acceptKey = crypto
+    const acceptKey = getCrypto()
       .createHash('sha1')
       .update(key + WS_GUID)
       .digest('base64');
@@ -865,7 +887,9 @@ class DashboardServer extends EventEmitter {
   handleMessage(session, data) {
     // Rate limit incoming messages
     if (!session.checkRateLimit()) {
-      session.send(getProtocol().createError('RATE_LIMITED', 'Too many messages, please slow down'));
+      session.send(
+        getProtocol().createError('RATE_LIMITED', 'Too many messages, please slow down')
+      );
       return;
     }
 
@@ -1059,7 +1083,9 @@ class DashboardServer extends EventEmitter {
       switch (type) {
         case getProtocol().InboundMessageType.GIT_STAGE:
           if (fileArgs) {
-            getChildProcess().execFileSync('git', ['add', '--', ...fileArgs], { cwd: this.projectRoot });
+            getChildProcess().execFileSync('git', ['add', '--', ...fileArgs], {
+              cwd: this.projectRoot,
+            });
           } else {
             getChildProcess().execFileSync('git', ['add', '-A'], { cwd: this.projectRoot });
           }
@@ -1070,24 +1096,32 @@ class DashboardServer extends EventEmitter {
               cwd: this.projectRoot,
             });
           } else {
-            getChildProcess().execFileSync('git', ['restore', '--staged', '.'], { cwd: this.projectRoot });
+            getChildProcess().execFileSync('git', ['restore', '--staged', '.'], {
+              cwd: this.projectRoot,
+            });
           }
           break;
         case getProtocol().InboundMessageType.GIT_REVERT:
           if (fileArgs) {
-            getChildProcess().execFileSync('git', ['checkout', '--', ...fileArgs], { cwd: this.projectRoot });
+            getChildProcess().execFileSync('git', ['checkout', '--', ...fileArgs], {
+              cwd: this.projectRoot,
+            });
           }
           break;
         case getProtocol().InboundMessageType.GIT_COMMIT:
           if (commitMessage) {
-            getChildProcess().execFileSync('git', ['commit', '-m', commitMessage], { cwd: this.projectRoot });
+            getChildProcess().execFileSync('git', ['commit', '-m', commitMessage], {
+              cwd: this.projectRoot,
+            });
           }
           break;
       }
 
       // Send updated git status
       this.sendGitStatus(session);
-      session.send(getProtocol().createNotification('success', 'Git', `${type.replace('git_', '')} completed`));
+      session.send(
+        getProtocol().createNotification('success', 'Git', `${type.replace('git_', '')} completed`)
+      );
     } catch (error) {
       console.error('[Git Error]', error.message);
       session.send(getProtocol().createError('GIT_ERROR', 'Git operation failed'));
@@ -1115,11 +1149,13 @@ class DashboardServer extends EventEmitter {
    */
   getGitStatus() {
     try {
-      const branch = getChildProcess().execFileSync('git', ['branch', '--show-current'], {
-        cwd: this.projectRoot,
-        encoding: 'utf8',
-        stdio: ['pipe', 'pipe', 'pipe'],
-      }).trim();
+      const branch = getChildProcess()
+        .execFileSync('git', ['branch', '--show-current'], {
+          cwd: this.projectRoot,
+          encoding: 'utf8',
+          stdio: ['pipe', 'pipe', 'pipe'],
+        })
+        .trim();
 
       const statusOutput = getChildProcess().execFileSync('git', ['status', '--porcelain'], {
         cwd: this.projectRoot,
@@ -1209,7 +1245,9 @@ class DashboardServer extends EventEmitter {
    */
   getFileDiff(filePath, staged = false) {
     // Validate filePath stays within project root
-    const pathResult = getValidatePaths().validatePath(filePath, this.projectRoot, { allowSymlinks: true });
+    const pathResult = getValidatePaths().validatePath(filePath, this.projectRoot, {
+      allowSymlinks: true,
+    });
     if (!pathResult.ok) {
       return '';
     }
@@ -1224,10 +1262,12 @@ class DashboardServer extends EventEmitter {
 
       // If no diff, file might be untracked - show entire file content as addition
       if (!diff && !staged) {
-        const statusOutput = getChildProcess().execFileSync('git', ['status', '--porcelain', '--', filePath], {
-          cwd: this.projectRoot,
-          encoding: 'utf8',
-        }).trim();
+        const statusOutput = getChildProcess()
+          .execFileSync('git', ['status', '--porcelain', '--', filePath], {
+            cwd: this.projectRoot,
+            encoding: 'utf8',
+          })
+          .trim();
 
         // Check if file is untracked
         if (statusOutput.startsWith('??')) {
@@ -1398,23 +1438,23 @@ class DashboardServer extends EventEmitter {
       // Get branch and sync status via git
       try {
         const cwd = s.metadata.worktreePath || this.projectRoot;
-        entry.branch = getChildProcess().execFileSync('git', ['branch', '--show-current'], {
-          cwd,
-          encoding: 'utf8',
-          stdio: ['pipe', 'pipe', 'pipe'],
-        }).trim();
+        entry.branch = getChildProcess()
+          .execFileSync('git', ['branch', '--show-current'], {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+          })
+          .trim();
 
         // Get ahead/behind counts relative to upstream
         try {
-          const counts = getChildProcess().execFileSync(
-            'git',
-            ['rev-list', '--left-right', '--count', 'HEAD...@{u}'],
-            {
+          const counts = getChildProcess()
+            .execFileSync('git', ['rev-list', '--left-right', '--count', 'HEAD...@{u}'], {
               cwd,
               encoding: 'utf8',
               stdio: ['pipe', 'pipe', 'pipe'],
-            }
-          ).trim();
+            })
+            .trim();
           const [ahead, behind] = counts.split(/\s+/).map(Number);
           entry.ahead = ahead || 0;
           entry.behind = behind || 0;
@@ -1454,7 +1494,9 @@ class DashboardServer extends EventEmitter {
     }
 
     // Validate the path stays within project root
-    const pathResult = getValidatePaths().validatePath(filePath, this.projectRoot, { allowSymlinks: true });
+    const pathResult = getValidatePaths().validatePath(filePath, this.projectRoot, {
+      allowSymlinks: true,
+    });
     if (!pathResult.ok) {
       session.send(getProtocol().createError('OPEN_FILE_ERROR', 'File path outside project'));
       return;
@@ -1474,7 +1516,9 @@ class DashboardServer extends EventEmitter {
         case 'cursor':
         case 'windsurf': {
           const gotoArg = lineNum ? `${fullPath}:${lineNum}` : fullPath;
-          getChildProcess().spawn(editor, ['--goto', gotoArg], { detached: true, stdio: 'ignore' }).unref();
+          getChildProcess()
+            .spawn(editor, ['--goto', gotoArg], { detached: true, stdio: 'ignore' })
+            .unref();
           break;
         }
         case 'subl':
@@ -1491,11 +1535,17 @@ class DashboardServer extends EventEmitter {
       }
 
       session.send(
-        getProtocol().createNotification('info', 'Editor', `Opened ${require('path').basename(fullPath)}`)
+        getProtocol().createNotification(
+          'info',
+          'Editor',
+          `Opened ${require('path').basename(fullPath)}`
+        )
       );
     } catch (error) {
       console.error('[Open File Error]', error.message);
-      session.send(getProtocol().createError('OPEN_FILE_ERROR', `Failed to open file: ${error.message}`));
+      session.send(
+        getProtocol().createError('OPEN_FILE_ERROR', `Failed to open file: ${error.message}`)
+      );
     }
   }
 
@@ -1508,10 +1558,15 @@ class DashboardServer extends EventEmitter {
     // Validate cwd stays within project root
     let safeCwd = this.projectRoot;
     if (cwd) {
-      const cwdResult = getValidatePaths().validatePath(cwd, this.projectRoot, { allowSymlinks: true });
+      const cwdResult = getValidatePaths().validatePath(cwd, this.projectRoot, {
+        allowSymlinks: true,
+      });
       if (!cwdResult.ok) {
         session.send(
-          getProtocol().createError('TERMINAL_ERROR', 'Working directory must be within project root')
+          getProtocol().createError(
+            'TERMINAL_ERROR',
+            'Working directory must be within project root'
+          )
         );
         return;
       }
@@ -1684,7 +1739,9 @@ class DashboardServer extends EventEmitter {
     }
 
     if (!this._automationRunner) {
-      session.send(getProtocol().createError('AUTOMATION_ERROR', 'Automation runner not initialized'));
+      session.send(
+        getProtocol().createError('AUTOMATION_ERROR', 'Automation runner not initialized')
+      );
       return;
     }
 
@@ -1692,12 +1749,18 @@ class DashboardServer extends EventEmitter {
       // Check if already running
       if (this._runningAutomations.has(automationId)) {
         session.send(
-          getProtocol().createNotification('warning', 'Automation', `${automationId} is already running`)
+          getProtocol().createNotification(
+            'warning',
+            'Automation',
+            `${automationId} is already running`
+          )
         );
         return;
       }
 
-      session.send(getProtocol().createNotification('info', 'Automation', `Starting ${automationId}...`));
+      session.send(
+        getProtocol().createNotification('info', 'Automation', `Starting ${automationId}...`)
+      );
 
       // Run the automation (async)
       const result = await this._automationRunner.run(automationId);
@@ -1705,23 +1768,39 @@ class DashboardServer extends EventEmitter {
       // Send result notification
       if (result.success) {
         session.send(
-          getProtocol().createNotification('success', 'Automation', `${automationId} completed successfully`)
+          getProtocol().createNotification(
+            'success',
+            'Automation',
+            `${automationId} completed successfully`
+          )
         );
       } else {
         session.send(
-          getProtocol().createNotification('error', 'Automation', `${automationId} failed: ${result.error}`)
+          getProtocol().createNotification(
+            'error',
+            'Automation',
+            `${automationId} failed: ${result.error}`
+          )
         );
       }
 
       // Send final status
-      session.send(getProtocol().createAutomationStatus(automationId, result.success ? 'idle' : 'error', result));
+      session.send(
+        getProtocol().createAutomationStatus(
+          automationId,
+          result.success ? 'idle' : 'error',
+          result
+        )
+      );
 
       // Refresh the list
       this.sendAutomationList(session);
     } catch (error) {
       console.error('[Automation Error]', error.message);
       session.send(getProtocol().createError('AUTOMATION_ERROR', 'Automation execution failed'));
-      session.send(getProtocol().createAutomationStatus(automationId, 'error', { error: 'Execution failed' }));
+      session.send(
+        getProtocol().createAutomationStatus(automationId, 'error', { error: 'Execution failed' })
+      );
     }
   }
 
@@ -1782,7 +1861,9 @@ class DashboardServer extends EventEmitter {
       case 'accept':
         // Mark as accepted and remove
         item.status = 'accepted';
-        session.send(getProtocol().createNotification('success', 'Inbox', `Accepted: ${item.title}`));
+        session.send(
+          getProtocol().createNotification('success', 'Inbox', `Accepted: ${item.title}`)
+        );
         this._inbox.delete(itemId);
         break;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agileflow",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "AI-driven agile development system for Claude Code, Cursor, Windsurf, and more",
   "keywords": [
     "agile",

package/scripts/archive-completed-stories.sh

@@ -7,6 +7,8 @@ set -e
 
 # Track start time for hook metrics
 HOOK_START_TIME=$(date +%s%3N 2>/dev/null || date +%s)
+# macOS date doesn't support %N - outputs literal "3N" instead of millis
+[[ ! "$HOOK_START_TIME" =~ ^[0-9]+$ ]] && HOOK_START_TIME="$(date +%s)000"
 
 # Source shared utilities
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
@@ -286,6 +288,7 @@ fi
 # Record hook metrics
 if command -v node &> /dev/null && [[ -f "$SCRIPT_DIR/lib/hook-metrics.js" ]]; then
   HOOK_END_TIME=$(date +%s%3N 2>/dev/null || date +%s)
+  [[ ! "$HOOK_END_TIME" =~ ^[0-9]+$ ]] && HOOK_END_TIME="$(date +%s)000"
   HOOK_DURATION=$((HOOK_END_TIME - HOOK_START_TIME))
   PROJECT_ROOT="$PROJECT_ROOT" HOOK_DURATION="$HOOK_DURATION" node -e '
     try {

package/scripts/ci-summary.js

@@ -0,0 +1,294 @@
+#!/usr/bin/env node
+
+/**
+ * AgileFlow CLI - CI Summary Script
+ *
+ * Summarizes CI/CD workflow failures from the past 24 hours.
+ * Uses GitHub CLI (gh) to fetch workflow run data.
+ *
+ * Usage:
+ *   node scripts/ci-summary.js [options]
+ *
+ * Options:
+ *   --json         Output results as JSON
+ *   --hours=N      Look back N hours (default: 24)
+ *   --quiet        Only show failures
+ *   --help         Show help
+ */
+
+const { execFileSync } = require('child_process');
+const path = require('path');
+
+// ANSI colors
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+};
+
+/**
+ * Parse command line arguments
+ */
+function parseArgs(args) {
+  const options = {
+    json: false,
+    hours: 24,
+    quiet: false,
+    help: false,
+  };
+
+  for (const arg of args) {
+    if (arg === '--json') options.json = true;
+    else if (arg === '--quiet') options.quiet = true;
+    else if (arg === '--help' || arg === '-h') options.help = true;
+    else if (arg.startsWith('--hours=')) {
+      const hours = parseInt(arg.split('=')[1], 10);
+      if (!isNaN(hours) && hours > 0) {
+        options.hours = hours;
+      }
+    }
+  }
+
+  return options;
+}
+
+/**
+ * Show help message
+ */
+function showHelp() {
+  console.log(`
+${c.bold}AgileFlow CI Summary${c.reset}
+
+${c.cyan}Usage:${c.reset}
+  node scripts/ci-summary.js [options]
+
+${c.cyan}Options:${c.reset}
+  --json         Output results as JSON
+  --hours=N      Look back N hours (default: 24)
+  --quiet        Only show failures
+  --help, -h     Show this help message
+`);
+}
+
+/**
+ * Check if gh CLI is available
+ */
+function hasGhCli() {
+  try {
+    execFileSync('gh', ['--version'], { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if we're in a git repo with a GitHub remote
+ */
+function hasGitHubRemote() {
+  try {
+    const remote = execFileSync('git', ['remote', 'get-url', 'origin'], {
+      stdio: 'pipe',
+      encoding: 'utf8',
+    }).trim();
+    return remote.includes('github.com');
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Fetch workflow runs from GitHub
+ */
+function fetchWorkflowRuns(hours) {
+  try {
+    const output = execFileSync(
+      'gh',
+      [
+        'run',
+        'list',
+        '--limit',
+        '50',
+        '--json',
+        'databaseId,name,status,conclusion,createdAt,headBranch,event,url',
+      ],
+      { stdio: 'pipe', encoding: 'utf8', timeout: 30000 }
+    );
+
+    const runs = JSON.parse(output);
+    const cutoff = new Date(Date.now() - hours * 60 * 60 * 1000);
+
+    return runs.filter(run => new Date(run.createdAt) >= cutoff);
+  } catch (e) {
+    throw new Error(`Failed to fetch workflow runs: ${e.message}`);
+  }
+}
+
+/**
+ * Generate summary from runs
+ */
+function generateSummary(runs, hours) {
+  const summary = {
+    period_hours: hours,
+    total: runs.length,
+    successful: 0,
+    failed: 0,
+    cancelled: 0,
+    in_progress: 0,
+    failures: [],
+    workflows: {},
+  };
+
+  for (const run of runs) {
+    const workflowName = run.name || 'Unknown';
+
+    if (!summary.workflows[workflowName]) {
+      summary.workflows[workflowName] = { total: 0, passed: 0, failed: 0 };
+    }
+    summary.workflows[workflowName].total++;
+
+    if (run.conclusion === 'success') {
+      summary.successful++;
+      summary.workflows[workflowName].passed++;
+    } else if (run.conclusion === 'failure') {
+      summary.failed++;
+      summary.workflows[workflowName].failed++;
+      summary.failures.push({
+        workflow: workflowName,
+        branch: run.headBranch,
+        event: run.event,
+        created: run.createdAt,
+        url: run.url,
+      });
+    } else if (run.conclusion === 'cancelled') {
+      summary.cancelled++;
+    } else if (run.status === 'in_progress' || run.status === 'queued') {
+      summary.in_progress++;
+    }
+  }
+
+  return summary;
+}
+
+/**
+ * Format summary for console output
+ */
+function formatSummary(summary, quiet) {
+  const lines = [];
+
+  if (!quiet) {
+    lines.push(`${c.bold}CI Summary (last ${summary.period_hours}h)${c.reset}`);
+    lines.push('');
+  }
+
+  if (summary.total === 0) {
+    lines.push(`${c.dim}No workflow runs in the past ${summary.period_hours} hours.${c.reset}`);
+    return lines.join('\n');
+  }
+
+  if (!quiet) {
+    lines.push(`  Total runs:   ${summary.total}`);
+    lines.push(`  ${c.green}Successful:${c.reset}  ${summary.successful}`);
+    if (summary.failed > 0) {
+      lines.push(`  ${c.red}Failed:${c.reset}      ${summary.failed}`);
+    }
+    if (summary.cancelled > 0) {
+      lines.push(`  ${c.yellow}Cancelled:${c.reset}   ${summary.cancelled}`);
+    }
+    if (summary.in_progress > 0) {
+      lines.push(`  ${c.cyan}In progress:${c.reset} ${summary.in_progress}`);
+    }
+    lines.push('');
+  }
+
+  // Show failures
+  if (summary.failures.length > 0) {
+    lines.push(`${c.red}${c.bold}Failures:${c.reset}`);
+    for (const failure of summary.failures) {
+      lines.push(
+        `  ${c.red}x${c.reset} ${failure.workflow} ${c.dim}(${failure.branch}, ${failure.event})${c.reset}`
+      );
+      if (failure.url) {
+        lines.push(`    ${c.dim}${failure.url}${c.reset}`);
+      }
+    }
+    lines.push('');
+  }
+
+  // Workflow breakdown (non-quiet)
+  if (!quiet) {
+    const workflowNames = Object.keys(summary.workflows);
+    if (workflowNames.length > 0) {
+      lines.push(`${c.bold}Workflows:${c.reset}`);
+      for (const name of workflowNames) {
+        const w = summary.workflows[name];
+        const status = w.failed > 0 ? c.red : c.green;
+        lines.push(`  ${status}${name}${c.reset}: ${w.passed}/${w.total} passed`);
+      }
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Main entry point
+ */
+function main() {
+  const options = parseArgs(process.argv.slice(2));
+
+  if (options.help) {
+    showHelp();
+    process.exit(0);
+  }
+
+  // Pre-flight checks
+  if (!hasGhCli()) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: 'GitHub CLI (gh) not installed', runs: [] }));
+    } else {
+      console.log(
+        `${c.dim}CI Summary: GitHub CLI (gh) not available. Install from https://cli.github.com/${c.reset}`
+      );
+    }
+    process.exit(0);
+  }
+
+  if (!hasGitHubRemote()) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: 'No GitHub remote found', runs: [] }));
+    } else {
+      console.log(`${c.dim}CI Summary: No GitHub remote detected. Skipping.${c.reset}`);
+    }
+    process.exit(0);
+  }
+
+  // Fetch and summarize
+  try {
+    const runs = fetchWorkflowRuns(options.hours);
+    const summary = generateSummary(runs, options.hours);
+
+    if (options.json) {
+      console.log(JSON.stringify(summary, null, 2));
+    } else {
+      console.log(formatSummary(summary, options.quiet));
+    }
+
+    // Always exit 0 when summary was generated successfully.
+    // The automation runner treats non-zero as script failure.
+    process.exit(0);
+  } catch (e) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: e.message, runs: [] }));
+    } else {
+      console.error(`${c.red}CI Summary error:${c.reset} ${e.message}`);
+    }
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/claude-smart.sh

@@ -50,6 +50,24 @@ CMD+=("${ARGS[@]}")
 "${CMD[@]}"
 EXIT_CODE=$?
 
+# ── Auto-retry on expired session ────────────────────────────────────────
+# Exit code 1 with a stored UUID means Claude couldn't find the session
+# in its internal index (even though the .jsonl file exists on disk).
+if [ $EXIT_CODE -eq 1 ] && [ -n "$STORED_UUID" ]; then
+  echo ""
+  echo "Session expired. Starting fresh..."
+  echo ""
+  # Clear stale UUID from tmux pane
+  if [ -n "$TMUX" ]; then
+    tmux set-option -p -u @claude_uuid 2>/dev/null || true
+  fi
+  # Retry without --resume
+  STORED_UUID=""
+  CMD=(claude "${ARGS[@]}")
+  "${CMD[@]}"
+  EXIT_CODE=$?
+fi
+
 # ── Capture UUID after exit ────────────────────────────────────────────────
 # Store the most recent non-agent .jsonl as the pane's conversation UUID
 if [ -n "$TMUX" ]; then

package/scripts/claude-tmux.sh

@@ -252,32 +252,32 @@ configure_tmux_session() {
   tmux bind-key -n M-k run-shell "tmux send-keys C-c; sleep 0.5; tmux send-keys C-c"
 
   # ─── Help Panel ──────────────────────────────────────────────────────────
-  # Alt+h to show keybind cheat sheet in a popup
-  tmux bind-key -n M-h display-popup -E -w 52 -h 24 "\
+  # Alt+h to show all Alt keybindings in a popup
+  tmux bind-key -n M-h display-popup -E -w 52 -h 26 "\
     printf '\\n';\
     printf '  \\033[1;38;5;208mSESSIONS\\033[0m\\n';\
-    printf '  Alt+s   New Claude window\\n';\
-    printf '  Alt+l   Switch session\\n';\
-    printf '  Alt+q   Detach (af to resume)\\n';\
+    printf '  Alt+s      New Claude session\\n';\
+    printf '  Alt+l      Switch session (picker)\\n';\
+    printf '  Alt+q      Detach (af to resume)\\n';\
     printf '\\n';\
     printf '  \\033[1;38;5;208mWINDOWS\\033[0m\\n';\
-    printf '  Alt+1-9 Switch to window\\n';\
-    printf '  Alt+c   New empty window\\n';\
-    printf '  Alt+n/p Next / previous\\n';\
-    printf '  Alt+r   Rename window\\n';\
-    printf '  Alt+w   Close window\\n';\
+    printf '  Alt+c      New empty window\\n';\
+    printf '  Alt+1-9    Switch to window N\\n';\
+    printf '  Alt+n/p    Next / previous window\\n';\
+    printf '  Alt+r      Rename window\\n';\
+    printf '  Alt+w      Close window\\n';\
     printf '\\n';\
     printf '  \\033[1;38;5;208mPANES\\033[0m\\n';\
-    printf '  Alt+d   Split side by side\\n';\
-    printf '  Alt+v   Split top / bottom\\n';\
-    printf '  Alt+←→↑↓  Navigate\\n';\
-    printf '  Alt+z   Zoom / unzoom\\n';\
-    printf '  Alt+x   Close pane\\n';\
+    printf '  Alt+d      Split side by side\\n';\
+    printf '  Alt+v      Split top / bottom\\n';\
+    printf '  Alt+arrows Navigate panes\\n';\
+    printf '  Alt+z      Zoom / unzoom\\n';\
+    printf '  Alt+x      Close pane\\n';\
     printf '\\n';\
     printf '  \\033[1;38;5;208mOTHER\\033[0m\\n';\
-    printf '  Alt+[   Scroll mode\\n';\
-    printf '  Alt+k   Unfreeze (Ctrl+C×2)\\n';\
-    printf '  Alt+h   This help\\n';\
+    printf '  Alt+[      Scroll mode\\n';\
+    printf '  Alt+k      Unfreeze (Ctrl+C x2)\\n';\
+    printf '  Alt+h      This help\\n';\
     printf '\\n';\
     read -n 1 -s -r -p '  Press any key to close'"
 }
@@ -402,7 +402,31 @@ if [ "$FORCE_NEW" = false ]; then
   fi
 fi
 
-# No detached session found — create a new one
+# ── Reuse existing attached session ──────────────────────────────────────
+# If a session exists but is attached in another terminal, attach to it
+# as a second client rather than creating a duplicate session (e.g. -2).
+# Use --new to force creating a separate session.
+if [ "$FORCE_NEW" = false ]; then
+  EXISTING=()
+  while IFS= read -r sid; do
+    [ -n "$sid" ] && EXISTING+=("$sid")
+  done < <(tmux list-sessions -F '#{session_name}' 2>/dev/null | grep "^${SESSION_BASE}\(\$\|-[0-9]*\$\)")
+
+  if [ "${#EXISTING[@]}" -gt 0 ]; then
+    # Prefer the base session, otherwise pick the first one
+    TARGET="${EXISTING[0]}"
+    for sid in "${EXISTING[@]}"; do
+      if [ "$sid" = "$SESSION_BASE" ]; then
+        TARGET="$sid"
+        break
+      fi
+    done
+    echo "Attaching to existing session: $TARGET"
+    exec tmux attach-session -t "$TARGET"
+  fi
+fi
+
+# No existing session found — create a new one
 SESSION_NAME="$SESSION_BASE"
 SESSION_NUM=1
 while tmux has-session -t "$SESSION_NAME" 2>/dev/null; do

package/scripts/lib/configure-detect.js

@@ -6,9 +6,51 @@
 
 const fs = require('fs');
 const path = require('path');
+const crypto = require('crypto');
 const { execFileSync } = require('child_process');
 const { c, log, header, readJSON } = require('./configure-utils');
 const { tryOptional } = require('../../lib/errors');
+const { FEATURES } = require('./configure-features');
+
+// ============================================================================
+// CONTENT HASH HELPERS
+// ============================================================================
+
+/**
+ * Hash a file's content using SHA-256 (first 16 hex chars)
+ * @param {string} filePath - Path to the file
+ * @returns {string|null} 16-char hex hash, or null if file can't be read
+ */
+function hashFile(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    return crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Find the directory containing package source scripts.
+ * Checks require.resolve first, then common fallback locations.
+ * @returns {string|null} Path to the scripts directory, or null
+ */
+function findPackageScriptDir() {
+  try {
+    const pkgPath = require.resolve('agileflow/package.json');
+    return path.join(path.dirname(pkgPath), 'scripts');
+  } catch {
+    // Fallback: check common locations
+    const candidates = [
+      path.join(process.cwd(), 'node_modules', 'agileflow', 'scripts'),
+      path.join(process.cwd(), 'packages', 'cli', 'scripts'), // monorepo dev
+    ];
+    for (const dir of candidates) {
+      if (fs.existsSync(dir)) return dir;
+    }
+    return null;
+  }
+}
 
 // ============================================================================
 // DETECTION
@@ -256,17 +298,51 @@ function detectMetadata(status, version) {
     status.features.tmuxautospawn.enabled = true; // Default enabled
   }
 
-  // Read feature versions and check if outdated
+  // Read feature versions and check if outdated (content-based)
   if (meta.features) {
     const featureKeyMap = { askUserQuestion: 'askuserquestion', tmuxAutoSpawn: 'tmuxautospawn' };
+    const packageScriptDir = findPackageScriptDir();
+
     Object.entries(meta.features).forEach(([feature, data]) => {
       const statusKey = featureKeyMap[feature] || feature.toLowerCase();
       if (status.features[statusKey] && data.version) {
         status.features[statusKey].version = data.version;
-        if (data.version !== version && status.features[statusKey].enabled) {
-          status.features[statusKey].outdated = true;
-          status.hasOutdated = true;
+
+        if (!status.features[statusKey].enabled) return;
+
+        // Content-based outdated detection
+        const featureConfig = FEATURES[statusKey];
+        const scriptsToCheck = featureConfig?.scripts
+          || (featureConfig?.script ? [featureConfig.script] : []);
+
+        if (scriptsToCheck.length > 0 && packageScriptDir) {
+          // Compare installed scripts against package source
+          let isOutdated = false;
+          for (const scriptName of scriptsToCheck) {
+            const packageScript = path.join(packageScriptDir, scriptName);
+            const installedScript = path.join(
+              process.cwd(), '.agileflow', 'scripts', scriptName
+            );
+            const packageHash = hashFile(packageScript);
+            const installedHash = hashFile(installedScript);
+
+            if (packageHash && installedHash && packageHash !== installedHash) {
+              isOutdated = true;
+              break;
+            }
+          }
+          if (isOutdated) {
+            status.features[statusKey].outdated = true;
+            status.hasOutdated = true;
+          }
+        } else if (featureConfig?.metadataOnly) {
+          // Metadata-only features: use version comparison (no scripts to hash)
+          if (data.version !== version) {
+            status.features[statusKey].outdated = true;
+            status.hasOutdated = true;
+          }
         }
+        // If no package source found or no scripts, don't mark outdated (fail open)
       }
     });
   }
@@ -402,4 +478,6 @@ module.exports = {
   detectPreToolUseHooks,
   detectStatusLine,
   detectMetadata,
+  hashFile,
+  findPackageScriptDir,
 };

package/scripts/lib/configure-features.js

@@ -6,6 +6,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const crypto = require('crypto');
 const os = require('os');
 const {
   c,
@@ -53,12 +54,12 @@ const FEATURES = {
     description: 'Auto-kill duplicate Claude processes in same directory to prevent freezing',
   },
   claudeflags: {
-    metadataOnly: true,
-    description: 'Default flags for Claude CLI (e.g., --dangerously-skip-permissions)',
+    metadataOnly: false,
+    description: 'Default flags for Claude CLI (sets permissions.defaultMode in .claude/settings.json)',
   },
   agentteams: {
-    metadataOnly: true,
-    description: 'Enable Claude Code native Agent Teams (experimental multi-agent orchestration)',
+    metadataOnly: false,
+    description: 'Enable Claude Code native Agent Teams (sets env var in .claude/settings.json)',
   },
 };
 
@@ -152,6 +153,20 @@ const SCRIPTS_DIR = path.join(process.cwd(), '.agileflow', 'scripts');
 const scriptExists = scriptName => fs.existsSync(path.join(SCRIPTS_DIR, scriptName));
 const getScriptPath = scriptName => `.agileflow/scripts/${scriptName}`;
 
+/**
+ * Hash a file's content using SHA-256 (first 16 hex chars)
+ * @param {string} filePath - Path to the file
+ * @returns {string|null} 16-char hex hash, or null if file can't be read
+ */
+function hashFile(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    return crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
+  } catch {
+    return null;
+  }
+}
+
 // ============================================================================
 // METADATA MANAGEMENT
 // ============================================================================
@@ -308,8 +323,24 @@ function enableFeature(feature, options = {}, version) {
   }
 
   // Handle claude flags (e.g., --dangerously-skip-permissions)
+  // Also sets permissions.defaultMode in .claude/settings.json
   if (feature === 'claudeflags') {
     const defaultFlags = options.flags || '--dangerously-skip-permissions';
+
+    // Map CLI flags to settings.json defaultMode values
+    const flagToMode = {
+      '--dangerously-skip-permissions': 'bypassPermissions',
+      '--permission-mode acceptEdits': 'acceptEdits',
+    };
+    const defaultMode = flagToMode[defaultFlags];
+
+    if (defaultMode) {
+      settings.permissions = settings.permissions || {};
+      settings.permissions.defaultMode = defaultMode;
+      writeJSON('.claude/settings.json', settings);
+      info(`Set permissions.defaultMode = "${defaultMode}" in .claude/settings.json`);
+    }
+
     updateMetadata(
       {
         features: {
@@ -325,11 +356,17 @@ function enableFeature(feature, options = {}, version) {
     );
     success(`Default Claude flags configured: ${defaultFlags}`);
     info('These flags will be passed to Claude when launched via "af" or "agileflow"');
+    if (defaultMode) {
+      info('Restart Claude Code for the new default mode to take effect');
+    }
     return true;
   }
 
-  // Handle agent teams (metadata only)
+  // Handle agent teams - set env var in .claude/settings.json
   if (feature === 'agentteams') {
+    settings.env = settings.env || {};
+    settings.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS = '1';
+    writeJSON('.claude/settings.json', settings);
     updateMetadata(
       {
         features: {
@@ -343,8 +380,8 @@ function enableFeature(feature, options = {}, version) {
       version
     );
     success('Native Agent Teams enabled');
-    info('Claude Code will use native TeamCreate/SendMessage tools when available');
-    info('Requires: CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 (set by Claude Code)');
+    info('Set CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 in .claude/settings.json');
+    info('Claude Code will use native TeamCreate/SendMessage tools');
     info('Fallback: subagent mode (Task/TaskOutput) when native is unavailable');
     return true;
   }
@@ -416,9 +453,18 @@ function enableFeature(feature, options = {}, version) {
     return enableDamageControl(settings, options, version);
   }
 
+  const featureConfig = FEATURES[feature];
+  const contentHash = featureConfig?.script
+    ? hashFile(path.join(SCRIPTS_DIR, featureConfig.script))
+    : null;
   writeJSON('.claude/settings.json', settings);
   updateMetadata(
-    { features: { [feature]: { enabled: true, version, at: new Date().toISOString() } } },
+    { features: { [feature]: {
+      enabled: true,
+      version,
+      ...(contentHash ? { contentHash } : {}),
+      at: new Date().toISOString(),
+    } } },
     version
   );
   updateGitignore();
@@ -583,6 +629,7 @@ function enableDamageControl(settings, options, version) {
 
   success('Damage control PreToolUse hooks enabled');
 
+  const primaryHash = hashFile(path.join(SCRIPTS_DIR, 'damage-control-bash.js'));
   updateMetadata(
     {
       features: {
@@ -590,6 +637,7 @@ function enableDamageControl(settings, options, version) {
           enabled: true,
           protectionLevel: level,
           version,
+          ...(primaryHash ? { contentHash: primaryHash } : {}),
           at: new Date().toISOString(),
         },
       },
@@ -735,8 +783,13 @@ function disableFeature(feature, version) {
     return true;
   }
 
-  // Disable claude flags
+  // Disable claude flags - also reset permissions.defaultMode in settings.json
   if (feature === 'claudeflags') {
+    if (settings.permissions?.defaultMode) {
+      delete settings.permissions.defaultMode;
+      writeJSON('.claude/settings.json', settings);
+      info('Removed permissions.defaultMode from .claude/settings.json');
+    }
     updateMetadata(
       {
         features: {
@@ -752,11 +805,19 @@ function disableFeature(feature, version) {
     );
     success('Default Claude flags disabled');
     info('Claude will launch with default permissions (prompts for each action)');
+    info('Restart Claude Code for the change to take effect');
     return true;
   }
 
-  // Disable agent teams
+  // Disable agent teams - remove env var from .claude/settings.json
   if (feature === 'agentteams') {
+    if (settings.env) {
+      delete settings.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS;
+      if (Object.keys(settings.env).length === 0) {
+        delete settings.env;
+      }
+    }
+    writeJSON('.claude/settings.json', settings);
     updateMetadata(
       {
         features: {
@@ -770,6 +831,7 @@ function disableFeature(feature, version) {
       version
     );
     success('Native Agent Teams disabled');
+    info('Removed CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS from .claude/settings.json');
     info('AgileFlow will use subagent mode (Task/TaskOutput) for multi-agent orchestration');
     return true;
   }

package/scripts/precompact-context.sh

@@ -10,6 +10,8 @@
 
 # Track start time for hook metrics
 HOOK_START_TIME=$(date +%s%3N 2>/dev/null || date +%s)
+# macOS date doesn't support %N - outputs literal "3N" instead of millis
+[[ ! "$HOOK_START_TIME" =~ ^[0-9]+$ ]] && HOOK_START_TIME="$(date +%s)000"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
 # Get current version from package.json
@@ -286,6 +288,7 @@ fi
 # Record hook metrics
 if command -v node &> /dev/null && [[ -f "$SCRIPT_DIR/lib/hook-metrics.js" ]]; then
   HOOK_END_TIME=$(date +%s%3N 2>/dev/null || date +%s)
+  [[ ! "$HOOK_END_TIME" =~ ^[0-9]+$ ]] && HOOK_END_TIME="$(date +%s)000"
   HOOK_DURATION=$((HOOK_END_TIME - HOOK_START_TIME))
   HOOK_DURATION="$HOOK_DURATION" node -e '
     try {

package/src/core/commands/configure.md

@@ -411,6 +411,8 @@ Present the Sessions sub-menu:
 
 Configure default startup mode for new sessions created with `/agileflow:session:new`.
 
+**How it works**: When skip-permissions is selected, `/configure` sets `permissions.defaultMode = "bypassPermissions"` in `.claude/settings.json`. Claude Code reads this on startup and skips all permission prompts automatically. No CLI flags needed.
+
 First, read current setting:
 ```bash
 cat docs/00-meta/agileflow-metadata.json | grep '"defaultStartupMode"' 2>/dev/null || echo "normal"
@@ -441,38 +443,45 @@ Map selection to value:
 | Accept edits only | `accept-edits` |
 | Don't start Claude | `no-claude` |
 
-Update the metadata file:
-```bash
-# Read current metadata
-metadata=$(cat docs/00-meta/agileflow-metadata.json)
+Update the metadata file AND configure the CLI flags:
 
-# Update defaultStartupMode (using jq if available, or manual edit)
-# The value should be one of: normal, skip-permissions, accept-edits, no-claude
+1. Update `docs/00-meta/agileflow-metadata.json`:
+   - Find: `"defaultStartupMode": "..."`
+   - Replace with: `"defaultStartupMode": "{selected_value}"`
+
+2. **Also run** the configure script to set Claude Code's permission mode:
+```bash
+node .agileflow/scripts/agileflow-configure.js --enable=claudeflags --flags="{cli_flag}"
 ```
 
-Or use the Edit tool to update `docs/00-meta/agileflow-metadata.json`:
-- Find: `"defaultStartupMode": "..."`
-- Replace with: `"defaultStartupMode": "{selected_value}"`
+Where `{cli_flag}` is:
+- `skip-permissions` → `--dangerously-skip-permissions` (sets `permissions.defaultMode = "bypassPermissions"`)
+- `accept-edits` → `--permission-mode acceptEdits` (sets `permissions.defaultMode = "acceptEdits"`)
+- `normal` → (disable claudeflags instead: `--disable=claudeflags`, removes `defaultMode`)
 
 Display confirmation:
 ```
 ✅ Default session startup mode set to: {selected_value}
 
-When creating new sessions with /agileflow:session:new, this will be the
-recommended option. You can still choose a different mode per-session.
+What was configured:
+  • .claude/settings.json: permissions.defaultMode = "{defaultMode}"
+  • Metadata: defaultStartupMode = "{selected_value}"
+  • AgileFlow commands (af, /session:new) will also use this mode
+
+⚠️  Restart Claude Code for the new permission mode to take effect.
 ```
 
-**If user selected "Skip permissions" or "Accept edits only"**, offer Claude settings integration:
+**If user selected "Skip permissions" or "Accept edits only"**, offer shell alias:
 
 ```xml
 <invoke name="AskUserQuestion">
 <parameter name="questions">[{
-  "question": "Also configure Claude to default to this mode?",
-  "header": "Claude settings",
+  "question": "Also add a shell alias so 'claude' always uses this mode?",
+  "header": "Shell alias",
   "multiSelect": false,
   "options": [
-    {"label": "af wrapper only (Recommended)", "description": "The 'af' command already uses this setting. No other changes needed."},
-    {"label": "Also add shell alias", "description": "Add alias to your shell profile so 'claude' also uses this mode"},
+    {"label": "AgileFlow commands only (Recommended)", "description": "Only 'af' and /session:new use this mode. Direct 'claude' command unchanged."},
+    {"label": "Also add shell alias", "description": "Add 'alias claude=\"claude {flag}\"' to shell profile"},
     {"label": "No thanks", "description": "Keep current setup"}
   ]
 }]</parameter>
@@ -511,10 +520,10 @@ Run `source {SHELL_RC}` or open a new terminal for the alias to take effect.
 To remove later: edit {SHELL_RC} and remove the 'alias claude=' line.
 ```
 
-**If "af wrapper only" or "No thanks" selected:**
+**If "AgileFlow commands only" or "No thanks" selected:**
 ```
-The 'af' command already reads the configured startup mode automatically.
-No additional changes needed.
+AgileFlow commands (af, /session:new) will use the configured mode automatically.
+Direct 'claude' command remains unchanged.
 ```
 
 #### If "Agent Teams" selected
@@ -547,16 +556,19 @@ Then present options:
 node .agileflow/scripts/agileflow-configure.js --enable=agentteams
 ```
 
+This sets `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` in `.claude/settings.json` under the `env` key.
+Claude Code reads this automatically on startup - no manual env var setup needed.
+
 Display:
 ```
 ✅ Native Agent Teams enabled
 
-When Claude Code sets CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1, AgileFlow will:
-  • Use native TeamCreate for parallel agent spawning
-  • Send messages via both native SendMessage AND JSONL bus
-  • Track team lifecycle events in session-state.json
+What was configured:
+  • Set CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 in .claude/settings.json
+  • Claude Code will use native TeamCreate/SendMessage tools
+  • Fallback: subagent mode (Task/TaskOutput) when native is unavailable
 
-When the flag is not set, AgileFlow falls back to subagent mode automatically.
+⚠️  Restart Claude Code for the env var to take effect.
 ```
 
 **If "Disable" selected:**
@@ -564,12 +576,17 @@ When the flag is not set, AgileFlow falls back to subagent mode automatically.
 node .agileflow/scripts/agileflow-configure.js --disable=agentteams
 ```
 
+This removes `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS` from `.claude/settings.json`.
+
 Display:
 ```
 ✅ Native Agent Teams disabled
 
-AgileFlow will use subagent mode (Task/TaskOutput) for all multi-agent
-orchestration. This is the stable, well-tested mode.
+What was configured:
+  • Removed CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS from .claude/settings.json
+  • AgileFlow will use subagent mode (Task/TaskOutput) for all multi-agent orchestration
+
+⚠️  Restart Claude Code for the change to take effect.
 ```
 
 **If "What is this?" selected:**
@@ -592,7 +609,7 @@ How AgileFlow integrates:
   4. Subagent mode remains available as automatic fallback
 
 Requirements:
-  • Claude Code must set CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1
+  • /configure sets CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 in .claude/settings.json automatically
   • Feature is opt-in per project via this configuration
   • CI/CD always uses subagent mode (safety gate)
 ```