agileflow 3.0.1 → 3.1.0

package/scripts/agileflow-welcome.js

@@ -30,6 +30,20 @@ const { readJSONCached, readFileCached } = require('../lib/file-cache');
 // Session manager path (relative to script location)
 const SESSION_MANAGER_PATH = path.join(__dirname, 'session-manager.js');
 
+// PERFORMANCE OPTIMIZATION: Lazy-loaded session-manager module
+// Importing directly avoids ~50-150ms subprocess overhead per call.
+let _sessionManager;
+function getSessionManager() {
+  if (_sessionManager === undefined) {
+    try {
+      _sessionManager = require('./session-manager.js');
+    } catch (e) {
+      _sessionManager = null;
+    }
+  }
+  return _sessionManager;
+}
+
 // Hook metrics module (kept at top level - needed early for timer)
 let hookMetrics;
 try {
@@ -43,6 +57,12 @@ try {
  * Uses file-cache module for automatic caching with 15s TTL.
  * Files are cached across script invocations within TTL window.
  * Estimated savings: 60-120ms on cache hits
+ *
+ * Additional optimizations in this file (US-0356):
+ * - Git batching: 3 subprocess calls → 1 (~20-40ms savings)
+ * - Session-manager inline: subprocess → direct require() (~50-150ms savings)
+ * - Tmux cache: subprocess → session-state lookup (~10-20ms after first run)
+ * Total estimated savings: ~130-260ms
  */
 function loadProjectFiles(rootDir) {
   const paths = {
@@ -109,32 +129,57 @@ function detectPlatform() {
 
 /**
  * Check if tmux is installed
+ * PERFORMANCE OPTIMIZATION: Caches result in session-state.json (~10-20ms savings on subsequent runs)
  * Returns object with availability info and platform-specific install suggestion
  */
-function checkTmuxAvailability() {
+function checkTmuxAvailability(cache) {
+  // Check session state cache first (tmux availability doesn't change within a session)
+  if (cache?.sessionState?.tmux_available !== undefined) {
+    if (cache.sessionState.tmux_available) return { available: true };
+    return { available: false, platform: detectPlatform(), noSudoCmd: 'conda install -c conda-forge tmux' };
+  }
+
+  // Actually check (first run or no cache)
   const result = executeCommandSync('which', ['tmux'], { fallback: null });
-  if (result.data !== null) {
-    return { available: true };
+  const available = result.data !== null;
+
+  // Cache in session state for next invocation
+  try {
+    const rootDir = getProjectRoot();
+    const sessionStatePath = getSessionStatePath(rootDir);
+    if (fs.existsSync(sessionStatePath)) {
+      const state = JSON.parse(fs.readFileSync(sessionStatePath, 'utf8'));
+      state.tmux_available = available;
+      fs.writeFileSync(sessionStatePath, JSON.stringify(state, null, 2) + '\n');
+    }
+  } catch (e) {
+    // Cache write failed, non-critical
   }
-  const platform = detectPlatform();
-  return {
-    available: false,
-    platform,
-    noSudoCmd: 'conda install -c conda-forge tmux',
-  };
+
+  if (available) return { available: true };
+  return { available: false, platform: detectPlatform(), noSudoCmd: 'conda install -c conda-forge tmux' };
 }
 
 /**
  * PERFORMANCE OPTIMIZATION: Batch git commands into single call
- * Reduces subprocess overhead from 3 calls to 1.
- * Estimated savings: 20-40ms
+ * Uses `git log -1 --format=%D%n%h%n%s` to get branch, short hash, and subject
+ * in a single subprocess instead of 3 separate calls.
+ * Savings: ~20-40ms (eliminates 2 subprocess spawns)
  */
 function getGitInfo(rootDir) {
-  const opts = { cwd: rootDir, timeout: 5000, fallback: 'unknown' };
-  const branch = git(['branch', '--show-current'], opts).data;
-  const commit = git(['rev-parse', '--short', 'HEAD'], opts).data;
-  const lastCommit = git(['log', '-1', '--format=%s'], { ...opts, fallback: '' }).data;
-  return { branch, commit, lastCommit };
+  const opts = { cwd: rootDir, timeout: 5000, fallback: '' };
+  const result = git(['log', '-1', '--format=%D%n%h%n%s'], opts);
+  if (result.data) {
+    const lines = result.data.split('\n');
+    // %D gives decorations like "HEAD -> main, origin/main, tag: v3.0.0"
+    const branchMatch = (lines[0] || '').match(/HEAD -> ([^,\s]+)/);
+    return {
+      branch: branchMatch ? branchMatch[1] : 'detached',
+      commit: (lines[1] || 'unknown').trim(),
+      lastCommit: lines.slice(2).join('\n').trim(),
+    };
+  }
+  return { branch: 'unknown', commit: 'unknown', lastCommit: '' };
 }
 
 function getProjectInfo(rootDir, cache = null) {
@@ -403,20 +448,39 @@ function checkParallelSessions(rootDir) {
   };
 
   try {
-    // Check if session manager exists
+    // PERFORMANCE OPTIMIZATION: Import session-manager directly instead of subprocess
+    // Saves ~50-150ms by avoiding Node subprocess spawn overhead
+    const sm = getSessionManager();
+    if (sm && sm.fullStatus) {
+      result.available = true;
+      const data = sm.fullStatus();
+      result.registered = data.registered;
+      result.currentId = data.id;
+      result.otherActive = data.otherActive || 0;
+      result.cleaned = data.cleaned || 0;
+      result.cleanedSessions = data.cleanedSessions || [];
+
+      if (data.current) {
+        result.isMain = data.current.is_main === true;
+        result.nickname = data.current.nickname;
+        result.branch = data.current.branch;
+        result.sessionPath = data.current.path;
+      }
+      return result;
+    }
+
+    // Fallback: check if session manager script exists for subprocess call
     const managerPath = path.join(getAgileflowDir(rootDir), 'scripts', 'session-manager.js');
     if (!fs.existsSync(managerPath) && !fs.existsSync(SESSION_MANAGER_PATH)) {
       return result;
     }
 
     result.available = true;
-
-    // Try to use combined full-status command (saves ~200ms vs 3 separate calls)
     const scriptPath = fs.existsSync(managerPath) ? managerPath : SESSION_MANAGER_PATH;
 
-    // PERFORMANCE: Single subprocess call instead of 3 (register + count + status)
     const fullStatusResult = executeCommandSync('node', [scriptPath, 'full-status'], {
-      cwd: rootDir, fallback: null,
+      cwd: rootDir,
+      fallback: null,
     });
 
     if (fullStatusResult.data) {
@@ -434,49 +498,7 @@ function checkParallelSessions(rootDir) {
           result.branch = data.current.branch;
           result.sessionPath = data.current.path;
         }
-      } catch (e) {
-        // JSON parse failed, fall through to individual calls
-        fullStatusResult.data = null;
-      }
-    }
-
-    if (!fullStatusResult.data) {
-      // Fall back to individual calls if full-status not available (older version)
-      const registerResult = executeCommandSync('node', [scriptPath, 'register'], {
-        cwd: rootDir, fallback: null,
-      });
-      if (registerResult.data) {
-        try {
-          const registerData = JSON.parse(registerResult.data);
-          result.registered = true;
-          result.currentId = registerData.id;
-        } catch (e) {}
-      }
-
-      const countResult = executeCommandSync('node', [scriptPath, 'count'], {
-        cwd: rootDir, fallback: null,
-      });
-      if (countResult.data) {
-        try {
-          const countData = JSON.parse(countResult.data);
-          result.otherActive = countData.count || 0;
-        } catch (e) {}
-      }
-
-      const statusCmdResult = executeCommandSync('node', [scriptPath, 'status'], {
-        cwd: rootDir, fallback: null,
-      });
-      if (statusCmdResult.data) {
-        try {
-          const statusData = JSON.parse(statusCmdResult.data);
-          if (statusData.current) {
-            result.isMain = statusData.current.is_main === true;
-            result.nickname = statusData.current.nickname;
-            result.branch = statusData.current.branch;
-            result.sessionPath = statusData.current.path;
-          }
-        } catch (e) {}
-      }
+      } catch (e) {}
     }
   } catch (e) {
     // Session system not available
@@ -930,7 +952,9 @@ async function checkUpdates() {
   };
 
   let updateChecker;
-  try { updateChecker = require('./check-update.js'); } catch (e) {}
+  try {
+    updateChecker = require('./check-update.js');
+  } catch (e) {}
   if (!updateChecker) return result;
 
   try {
@@ -1000,7 +1024,8 @@ function getChangelogEntries(version) {
 async function runAutoUpdate(rootDir, fromVersion, toVersion) {
   const runUpdate = () => {
     return executeCommandSync('npx', ['agileflow@latest', 'update', '--force'], {
-      cwd: rootDir, timeout: 120000,
+      cwd: rootDir,
+      timeout: 120000,
     });
   };
 
@@ -1528,17 +1553,26 @@ function formatTable(
   // Scale detection (EP-0033)
   if (scaleDetection && scaleDetection.scale) {
     const scaleColors = {
-      micro: c.cyan, small: c.teal, medium: c.mintGreen,
-      large: c.peach, enterprise: c.coral,
+      micro: c.cyan,
+      small: c.teal,
+      medium: c.mintGreen,
+      large: c.peach,
+      enterprise: c.coral,
     };
     const scaleIcons = {
-      micro: '◦', small: '○', medium: '◎', large: '●', enterprise: '◉',
+      micro: '◦',
+      small: '○',
+      medium: '◎',
+      large: '●',
+      enterprise: '◉',
     };
     const scale = scaleDetection.scale;
     const icon = scaleIcons[scale] || '◎';
     const label = scale.charAt(0).toUpperCase() + scale.slice(1);
     const cacheNote = scaleDetection.fromCache ? '' : ` (${scaleDetection.detection_ms}ms)`;
-    lines.push(row('Scale', `${icon} ${label}${cacheNote}`, c.lavender, scaleColors[scale] || c.dim));
+    lines.push(
+      row('Scale', `${icon} ${label}${cacheNote}`, c.lavender, scaleColors[scale] || c.dim)
+    );
   }
 
   lines.push(divider());
@@ -1634,13 +1668,20 @@ async function main() {
     // Scale detection not available
   }
 
-  const scaleRecommendations = earlyScale ? (() => {
-    try { return require('./lib/scale-detector').getScaleRecommendations(earlyScale.scale); } catch { return null; }
-  })() : null;
+  const scaleRecommendations = earlyScale
+    ? (() => {
+        try {
+          return require('./lib/scale-detector').getScaleRecommendations(earlyScale.scale);
+        } catch {
+          return null;
+        }
+      })()
+    : null;
 
-  const archival = (scaleRecommendations && scaleRecommendations.skipArchival)
-    ? { ran: false, threshold: 0, archived: 0, remaining: 0, skippedByScale: true }
-    : runArchival(rootDir, cache);
+  const archival =
+    scaleRecommendations && scaleRecommendations.skipArchival
+      ? { ran: false, threshold: 0, archived: 0, remaining: 0, skippedByScale: true }
+      : runArchival(rootDir, cache);
   const session = clearActiveCommands(rootDir, cache);
   const precompact = checkPreCompact(rootDir, cache);
   const parallelSessions = checkParallelSessions(rootDir);
@@ -1654,7 +1695,9 @@ async function main() {
 
   // Agent Teams feature flag detection
   let featureFlags;
-  try { featureFlags = require('../lib/feature-flags'); } catch (e) {}
+  try {
+    featureFlags = require('../lib/feature-flags');
+  } catch (e) {}
   let agentTeamsInfo = {};
   if (featureFlags) {
     try {
@@ -1727,7 +1770,7 @@ async function main() {
   let tmuxCheck = { available: true };
   const tmuxAutoSpawnEnabled = cache?.metadata?.features?.tmuxAutoSpawn?.enabled !== false;
   if (tmuxAutoSpawnEnabled) {
-    tmuxCheck = checkTmuxAvailability();
+    tmuxCheck = checkTmuxAvailability(cache);
   }
 
   // Show session banner FIRST if in a non-main session
@@ -1776,14 +1819,18 @@ async function main() {
 
       // Mark current version as seen to track for next update
       let updateChecker;
-      try { updateChecker = require('./check-update.js'); } catch (e) {}
+      try {
+        updateChecker = require('./check-update.js');
+      } catch (e) {}
       if (freshUpdateInfo.justUpdated && updateChecker) {
         updateChecker.markVersionSeen(info.version);
       }
     } else {
       // Mark current version as seen (for "just updated" case)
       let updateChecker;
-      try { updateChecker = require('./check-update.js'); } catch (e) {}
+      try {
+        updateChecker = require('./check-update.js');
+      } catch (e) {}
       if (updateChecker) {
         updateChecker.markVersionSeen(info.version);
       }
@@ -1868,13 +1915,12 @@ async function main() {
 
   // === SESSION HEALTH WARNINGS ===
   // Check for forgotten sessions with uncommitted changes, stale sessions, orphaned entries
+  // PERFORMANCE OPTIMIZATION: Direct function call instead of subprocess (~50-100ms savings)
   try {
-    const healthResult = executeCommandSync('node', [SESSION_MANAGER_PATH, 'health'], {
-      timeout: 10000, fallback: null,
-    });
+    const sm = getSessionManager();
+    const health = sm ? sm.getSessionsHealth({ staleDays: 7 }) : null;
 
-    if (healthResult.data) {
-      const health = JSON.parse(healthResult.data);
+    if (health) {
       const hasIssues =
         health.uncommitted.length > 0 ||
         health.stale.length > 0 ||
@@ -1922,7 +1968,9 @@ async function main() {
   // === DUPLICATE CLAUDE PROCESS DETECTION ===
   // Check for multiple Claude processes in the same working directory
   let processCleanup;
-  try { processCleanup = require('./lib/process-cleanup.js'); } catch (e) {}
+  try {
+    processCleanup = require('./lib/process-cleanup.js');
+  } catch (e) {}
   if (processCleanup) {
     try {
       // Auto-kill is explicitly opt-in at runtime.
@@ -1976,7 +2024,9 @@ async function main() {
 
   // Story claiming: cleanup stale claims and show warnings
   let storyClaiming;
-  try { storyClaiming = require('./lib/story-claiming.js'); } catch (e) {}
+  try {
+    storyClaiming = require('./lib/story-claiming.js');
+  } catch (e) {}
   if (storyClaiming) {
     try {
       // Clean up stale claims (dead PIDs, expired TTL)
@@ -2003,7 +2053,9 @@ async function main() {
 
   // File tracking: cleanup stale touches and show overlap warnings
   let fileTracking;
-  try { fileTracking = require('./lib/file-tracking.js'); } catch (e) {}
+  try {
+    fileTracking = require('./lib/file-tracking.js');
+  } catch (e) {}
   if (fileTracking) {
     try {
       // Clean up stale file touches (dead PIDs, expired TTL)
@@ -2028,7 +2080,9 @@ async function main() {
 
   // Epic completion check: auto-complete epics where all stories are done
   let storyStateMachine;
-  try { storyStateMachine = require('./lib/story-state-machine.js'); } catch (e) {}
+  try {
+    storyStateMachine = require('./lib/story-state-machine.js');
+  } catch (e) {}
   if (storyStateMachine && cache.status) {
     try {
       const statusPath = getStatusPath(rootDir);
@@ -2058,7 +2112,9 @@ async function main() {
 
   // Ideation sync: mark ideas as implemented when linked epics complete
   let syncIdeationStatus;
-  try { syncIdeationStatus = require('./lib/sync-ideation-status.js'); } catch (e) {}
+  try {
+    syncIdeationStatus = require('./lib/sync-ideation-status.js');
+  } catch (e) {}
   if (syncIdeationStatus) {
     try {
       const syncResult = syncIdeationStatus.syncImplementedIdeas(rootDir);

package/scripts/claude-tmux.sh

@@ -165,6 +165,9 @@ configure_tmux_session() {
   # Enable mouse support
   tmux set-option -t "$target_session" mouse on
 
+  # Automatically renumber windows when one is closed (no gaps)
+  tmux set-option -t "$target_session" renumber-windows on
+
   # Fix colors - proper terminal support
   tmux set-option -t "$target_session" default-terminal "xterm-256color"
   tmux set-option -t "$target_session" -ga terminal-overrides ",xterm-256color:Tc"
@@ -245,7 +248,8 @@ configure_tmux_session() {
 
   # ─── Session Creation Keybindings ──────────────────────────────────────────
   # Alt+s to create a new Claude window (starts fresh, future re-runs in same pane resume)
-  tmux bind-key -n M-s run-shell "tmux new-window -n claude -c '#{pane_current_path}' && tmux send-keys '\"\$AGILEFLOW_SCRIPTS/claude-smart.sh\" --fresh \$CLAUDE_SESSION_FLAGS' Enter"
+  # Window gets sequential name (claude-2, claude-3, ...) so windows are distinguishable
+  tmux bind-key -n M-s run-shell "N=\$(( \$(tmux list-windows -F '#{window_name}' 2>/dev/null | grep -c '^claude') + 1 )); tmux new-window -n \"claude-\$N\" -c '#{pane_current_path}' && tmux send-keys '\"\$AGILEFLOW_SCRIPTS/claude-smart.sh\" --fresh \$CLAUDE_SESSION_FLAGS' Enter"
 
   # ─── Freeze Recovery Keybindings ───────────────────────────────────────────
   # Alt+k to send Ctrl+C twice (soft interrupt for frozen processes)
@@ -253,7 +257,7 @@ configure_tmux_session() {
 
   # ─── Help Panel ──────────────────────────────────────────────────────────
   # Alt+h to show all Alt keybindings in a popup
-  tmux bind-key -n M-h display-popup -E -w 52 -h 26 "\
+  tmux bind-key -n M-h display-popup -E -w 52 -h 30 "\
     printf '\\n';\
     printf '  \\033[1;38;5;208mSESSIONS\\033[0m\\n';\
     printf '  Alt+s      New Claude session\\n';\
@@ -272,7 +276,9 @@ configure_tmux_session() {
     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 '  Alt+x      Close pane (confirm)\\n';\
+    printf '  Alt+K      Kill pane (no confirm)\\n';\
+    printf '  Alt+R      Restart pane\\n';\
     printf '\\n';\
     printf '  \\033[1;38;5;208mOTHER\\033[0m\\n';\
     printf '  Alt+[      Scroll mode\\n';\
@@ -354,7 +360,7 @@ fi
 # Silently remove sessions where all panes have exited (dead/empty shells).
 # This prevents accumulation of orphan sessions over time.
 SESSION_BASE="claude-${DIR_NAME}"
-for sid in $(tmux list-sessions -F '#{session_name}' 2>/dev/null | grep "^${SESSION_BASE}\(\$\|-[0-9]*\$\)"); do
+for sid in $(tmux list-sessions -F '#{session_name}' 2>/dev/null | grep -E "^${SESSION_BASE}($|-[0-9]+$)"); do
   # Count alive panes (pane_dead=0 means alive)
   ALIVE=$(tmux list-panes -t "$sid" -F '#{pane_dead}' 2>/dev/null | grep -c '^0$' || true)
   if [ "$ALIVE" = "0" ]; then
@@ -362,6 +368,36 @@ for sid in $(tmux list-sessions -F '#{session_name}' 2>/dev/null | grep "^${SESS
   fi
 done
 
+# ── Consolidate duplicate sessions ───────────────────────────────────────
+# Kill numbered duplicates (e.g. claude-Acuide-2, -3) that were created by
+# a previous bug. If the base session exists, duplicates are unnecessary.
+# If only numbered sessions remain, promote the lowest to the base name.
+if [ "$FORCE_NEW" = false ]; then
+  HAS_BASE=false
+  NUMBERED=()
+  if tmux has-session -t "$SESSION_BASE" 2>/dev/null; then
+    HAS_BASE=true
+  fi
+  while IFS= read -r sid; do
+    [ -n "$sid" ] && NUMBERED+=("$sid")
+  done < <(tmux list-sessions -F '#{session_name}' 2>/dev/null | grep -E "^${SESSION_BASE}-[0-9]+$" | sort -t- -k3 -n)
+
+  if [ "$HAS_BASE" = true ] && [ "${#NUMBERED[@]}" -gt 0 ]; then
+    # Base exists — kill all numbered duplicates
+    for sid in "${NUMBERED[@]}"; do
+      tmux kill-session -t "$sid" 2>/dev/null || true
+    done
+  elif [ "$HAS_BASE" = false ] && [ "${#NUMBERED[@]}" -gt 0 ]; then
+    # No base — promote lowest numbered session to base name
+    PROMOTE="${NUMBERED[0]}"
+    tmux rename-session -t "$PROMOTE" "$SESSION_BASE" 2>/dev/null || true
+    # Kill remaining duplicates
+    for sid in "${NUMBERED[@]:1}"; do
+      tmux kill-session -t "$sid" 2>/dev/null || true
+    done
+  fi
+fi
+
 # ── Auto-reattach to detached session ──────────────────────────────────────
 # When user does Alt+Q (detach) and then runs `af` again, reattach to the
 # existing session instead of creating a new one. This preserves tmux windows,
@@ -371,7 +407,7 @@ if [ "$FORCE_NEW" = false ]; then
   DETACHED=()
   while IFS= read -r sid; do
     [ -n "$sid" ] && DETACHED+=("$sid")
-  done < <(tmux list-sessions -F '#{session_name} #{session_attached}' 2>/dev/null | awk '$2 == "0" {print $1}' | grep "^${SESSION_BASE}\(\$\|-[0-9]*\$\)")
+  done < <(tmux list-sessions -F '#{session_name} #{session_attached}' 2>/dev/null | awk '$2 == "0" {print $1}' | grep -E "^${SESSION_BASE}($|-[0-9]+$)")
 
   if [ "${#DETACHED[@]}" -eq 1 ]; then
     # Single detached session — just reattach
@@ -410,7 +446,7 @@ 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]*\$\)")
+  done < <(tmux list-sessions -F '#{session_name}' 2>/dev/null | grep -E "^${SESSION_BASE}($|-[0-9]+$)")
 
   if [ "${#EXISTING[@]}" -gt 0 ]; then
     # Prefer the base session, otherwise pick the first one

package/scripts/damage-control-multi-agent.js

@@ -48,8 +48,12 @@ if (!utils || typeof utils.runDamageControlHook !== 'function') {
 
 // Tools this hook handles
 const MULTI_AGENT_TOOLS = [
-  'TeamCreate', 'TeamDelete',
-  'TaskCreate', 'TaskUpdate', 'TaskGet', 'TaskList',
+  'TeamCreate',
+  'TeamDelete',
+  'TaskCreate',
+  'TaskUpdate',
+  'TaskGet',
+  'TaskList',
   'SendMessage',
 ];
 
@@ -65,10 +69,10 @@ const MAX_MESSAGE_SIZE = 10240;
 // Blocked patterns in SendMessage content
 const BLOCKED_MESSAGE_PATTERNS = [
   // Command injection attempts
-  /\$\{.*\}/,           // Template injection ${...}
-  /`[^`]*`/,             // Backtick execution
-  /\bexec\s*\(/,         // exec() calls
-  /\beval\s*\(/,         // eval() calls
+  /\$\{.*\}/, // Template injection ${...}
+  /`[^`]*`/, // Backtick execution
+  /\bexec\s*\(/, // exec() calls
+  /\beval\s*\(/, // eval() calls
   // Dangerous git operations
   /\bgit\s+push\s+--force\b/i,
   /\bgit\s+reset\s+--hard\b/i,
@@ -143,9 +147,9 @@ function validateTaskOperation(input) {
   // Check for secrets in task descriptions
   const secretPatterns = [
     /\b(?:API_KEY|SECRET|PASSWORD|TOKEN|CREDENTIALS)\s*[:=]\s*\S+/i,
-    /\bsk-[a-zA-Z0-9]{20,}/,      // API keys starting with sk-
-    /\bghp_[a-zA-Z0-9]{36}/,      // GitHub personal access tokens
-    /\bnpm_[a-zA-Z0-9]{36}/,      // npm tokens
+    /\bsk-[a-zA-Z0-9]{20,}/, // API keys starting with sk-
+    /\bghp_[a-zA-Z0-9]{36}/, // GitHub personal access tokens
+    /\bnpm_[a-zA-Z0-9]{36}/, // npm tokens
   ];
 
   for (const pattern of secretPatterns) {
@@ -163,7 +167,7 @@ function validateTaskOperation(input) {
 
 try {
   utils.runDamageControlHook({
-    getInputValue: (input) => {
+    getInputValue: input => {
       // Check if this is a multi-agent tool
       const toolName = input.tool_name || '';
       if (!MULTI_AGENT_TOOLS.includes(toolName)) {

package/scripts/lib/bus-utils.js

@@ -341,7 +341,9 @@ function formatLogStats(stats) {
     lines.push('Archives:');
     if (stats.archives && stats.archives.length > 0) {
       for (const archive of stats.archives) {
-        lines.push(`  ${archive.filename}: ${archive.lineCount} lines (${Math.round(archive.size / 1024)} KB)`);
+        lines.push(
+          `  ${archive.filename}: ${archive.lineCount} lines (${Math.round(archive.size / 1024)} KB)`
+        );
       }
     }
 

package/scripts/lib/configure-detect.js

@@ -107,10 +107,15 @@ function detectConfig(version) {
   // Git detection
   if (fs.existsSync('.git')) {
     status.git.initialized = true;
-    status.git.remote = tryOptional(() => execFileSync('git', ['remote', 'get-url', 'origin'], {
-      encoding: 'utf8',
-      stdio: ['pipe', 'pipe', 'pipe'],
-    }).trim(), 'git remote') ?? null;
+    status.git.remote =
+      tryOptional(
+        () =>
+          execFileSync('git', ['remote', 'get-url', 'origin'], {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+          }).trim(),
+        'git remote'
+      ) ?? null;
   }
 
   // Settings file detection
@@ -312,17 +317,15 @@ function detectMetadata(status, version) {
 
         // Content-based outdated detection
         const featureConfig = FEATURES[statusKey];
-        const scriptsToCheck = featureConfig?.scripts
-          || (featureConfig?.script ? [featureConfig.script] : []);
+        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 installedScript = path.join(process.cwd(), '.agileflow', 'scripts', scriptName);
             const packageHash = hashFile(packageScript);
             const installedHash = hashFile(installedScript);