vibecodingmachine-cli 2026.3.14-1537 → 2026.6.17-1956

package/src/commands/auto-direct/spec-ide-runner.js

@@ -0,0 +1,318 @@
+/**
+ * Spec IDE Runner - Spec-based IDE Iteration Handler
+ *
+ * Extracted from iteration-handlers.js for constitutional compliance (<555 lines per file)
+ * Handles spec iterations using IDE providers (AppleScript) with task progress monitoring.
+ */
+
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const vibecodingmachineCore = require('vibecodingmachine-core');
+const { AppleScriptManager } = vibecodingmachineCore;
+
+// Import auto mode utilities
+const { getAutoConfig } = require('../../utils/config');
+const { stopAutoMode } = require('../../utils/auto-mode');
+
+// Import modular functions
+const { safeLog } = require('./utils');
+const { printStatusCard } = require('./status-display');
+
+// Shared variables set by parent module
+let storedStatusTitle = null;
+let storedStatus = null;
+
+/**
+ * Initialize module with shared instances
+ */
+function initialize(deps) {
+  storedStatusTitle = deps.statusVars.storedStatusTitle;
+  storedStatus = deps.statusVars.storedStatus;
+}
+
+/**
+ * Run a spec iteration using an IDE provider (AppleScript).
+ * Sends the full spec instruction to the IDE and polls tasks.md for
+ * progress (any new checkbox ticked), instead of spawning vcm auto:start.
+ *
+ * COORDINATION STRATEGY:
+ * - Wait for agent completion signals instead of just detecting any progress
+ * - Implement 2-minute cooldown after progress detection to prevent rapid spawning
+ * - Only consider iteration complete when all tasks are done AND agent signals completion
+ * - Use STATUS:WAITING and PLEASE RESPOND signals from agent to coordinate handoff
+ * - Prevent multiple agents from working on the same spec simultaneously
+ *
+ * @param {Object} spec        - Spec object with .path, .directory, .hasTasks, .hasPlan, .hasPlanPrompt
+ * @param {string} taskText    - Text of the NEXT unchecked task (for display)
+ * @param {string} taskLine    - Full line from tasks.md (used if this is a continuation)
+ * @param {Object} providerConfig - Provider config with .provider/.ide and .displayName
+ * @param {Function} countSpecCheckboxes - Function to count checkboxes in spec tasks.md
+ * @returns {Promise<{success: boolean, error?: string, shouldRetry?: boolean}>}
+ */
+async function runSpecIdeIteration(spec, taskText, taskLine, providerConfig, countSpecCheckboxes) {
+  const ideType = providerConfig.provider || providerConfig.ide;
+  const { done: doneBefore, total: totalBefore } = countSpecCheckboxes(spec.path);
+  const pctBefore = totalBefore > 0 ? Math.round((doneBefore / totalBefore) * 100) : 0;
+
+  // Get configurable timeouts from auto config
+  const autoConfig = await getAutoConfig();
+  const PROGRESS_TIMEOUT_MS = (autoConfig.specProgressTimeoutMinutes || 15) * 60 * 1000; // Configurable, default 15 minutes
+  const MAX_IDE_ATTEMPTS = autoConfig.maxIdeAttempts || 3; // Configurable, default 3 attempts
+
+  // Build the full spec instruction (mirrors buildSpecInstruction from Electron app)
+  // This lets the agent work through multiple tasks autonomously rather than one at a time.
+  let instruction;
+  if (spec.hasTasks) {
+    instruction = `Read AGENTS.md and INSTRUCTIONS.md in the repo root for workflow guidelines. Implement all remaining tasks in ${spec.path}/tasks.md. Current progress: ${doneBefore}/${totalBefore} tasks (${pctBefore}%) complete. Check off each task (change "[ ]" to "[x]") as you complete it. Report progress as "X/Y tasks (Z%) complete" after each task. When ALL tasks are checked off, create a status file at ${spec.path}/.vcm-status.json with content {"completion": 100, "status": "WAITING"} to signal completion to VCM.`;
+  } else if (spec.hasPlan) {
+    instruction = `Read AGENTS.md and INSTRUCTIONS.md in the repo root for workflow guidelines. Read ${spec.path}/plan.md, generate tasks.md for this spec, then implement all tasks. Check off each task as you complete it. Report progress as "X/Y tasks (Z%) complete" after each task. When ALL tasks are done, create a status file at ${spec.path}/.vcm-status.json with content {"completion": 100, "status": "WAITING"} to signal completion to VCM.`;
+  } else {
+    const planPromptNote = spec.hasPlanPrompt
+      ? `Use plan prompt from ${spec.path}/plan-prompt.md to guide planning. ` : '';
+    instruction = `Read AGENTS.md and INSTRUCTIONS.md in the repo root for workflow guidelines. Read ${spec.path}/spec.md. ${planPromptNote}Run speckit workflow: (1) read spec.md, (2) generate plan.md, (3) generate tasks.md, (4) implement all tasks. Check off each task as you complete it. Report progress as "X/Y tasks (Z%) complete" after each task. When ALL tasks are done, create a status file at ${spec.path}/.vcm-status.json with content {"completion": 100, "status": "WAITING"} to signal completion to VCM.`;
+  }
+
+  // Send the spec instruction to the IDE via platform-specific automation.
+  // Uses the appropriate automation manager for the current platform.
+  console.log(chalk.cyan(`━🚀 Sending spec instruction to ${providerConfig.displayName}...\n`));
+
+  if (ideType === 'devin') {
+    try {
+      let sendResult;
+
+      // Use platform-specific automation for Devin
+      if (process.platform === 'win32') {
+        const { WindowsAutomationManager } = require('vibecodingmachine-core');
+        const windowsManager = new WindowsAutomationManager();
+        sendResult = await windowsManager.sendTextToDevin?.(instruction) || { success: false, error: 'Devin Windows automation not implemented' };
+      } else {
+        const appleScriptManager = new AppleScriptManager();
+        sendResult = await appleScriptManager.sendText(instruction, 'devin');
+      }
+
+      if (sendResult && sendResult.success) {
+        console.log(chalk.green(`✓ Spec instruction sent to ${providerConfig.displayName}`));
+        console.log(chalk.gray(`👁 Polling tasks.md every 30s for checkbox progress...\n`));
+        console.log(chalk.gray(`━ Coordination: Will wait for agent completion signals before sending new tasks\n`));
+      } else {
+        console.log(chalk.red(`✗ Failed to send instruction to Devin: ${sendResult?.error || 'Unknown error'}`));
+        return { success: false, error: sendResult?.error || 'Unknown error' };
+      }
+    } catch (err) {
+      console.log(chalk.red(`✗ Automation error: ${err.message}`));
+      return { success: false, error: err.message };
+    }
+  } else {
+    // Non-Devin IDEs: use AppleScriptManager
+    try {
+      const appleScriptManager = new AppleScriptManager();
+      let sendResult;
+      // Prefer sendTextWithThreadClosure when available (.js build), fall back to sendText (.cjs build)
+      if (typeof appleScriptManager.sendTextWithThreadClosure === 'function') {
+        sendResult = await appleScriptManager.sendTextWithThreadClosure(instruction, ideType);
+      } else {
+        sendResult = await appleScriptManager.sendText(instruction, ideType);
+      }
+      if (!sendResult || !sendResult.success) {
+        const errorMsg = (sendResult && sendResult.error) || `Failed to send text to ${providerConfig.displayName}`;
+        console.log(chalk.red(`✗ ${errorMsg}`));
+        return { success: false, error: errorMsg };
+      }
+    } catch (err) {
+      console.log(chalk.red(`✗ AppleScript error: ${err.message}`));
+      return { success: false, error: err.message };
+    }
+  }
+
+  console.log(chalk.green(`✓ Spec instruction sent to ${providerConfig.displayName}`));
+  console.log(chalk.gray(`👁 Polling tasks.md every 30s for checkbox progress...\n`));
+  console.log(chalk.gray(`━ Coordination: Will wait for agent completion signals before sending new tasks\n`));
+
+  const POLL_INTERVAL_MS = 30 * 1000;        // 30 seconds
+  const CONTINUE_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
+  const TIMEOUT_MS = PROGRESS_TIMEOUT_MS;      // Use configurable progress timeout
+  const PROGRESS_COOLDOWN_MS = 2 * 60 * 1000; // 2 minutes cooldown after progress
+
+  let startTime = Date.now();
+  let lastContinueSent = Date.now();
+  let lastProgressTime = Date.now(); // Track when we last saw progress
+  let lastProgressDetectionTime = 0; // Track when we last detected progress to implement cooldown
+  let totalAttempts = (spec.totalIdeAttempts || 0) + 1; // Track attempts across IDEs
+  let agentSignaledCompletion = false; // Track if agent signaled completion
+
+  return new Promise((resolve) => {
+    let interval = null;
+
+    const cleanup = (result) => {
+      if (interval) { clearInterval(interval); interval = null; }
+      process.off('SIGINT', onSigint);
+      resolve(result);
+    };
+
+    // Handle Ctrl+C gracefully: stop polling and exit cleanly
+    const onSigint = () => {
+      console.log(chalk.yellow('\n⚠  Interrupted — stopping spec task polling\n'));
+      cleanup({ success: false, error: 'interrupted' });
+      // Re-emit to trigger normal process exit after cleanup
+      process.exit(0);
+    };
+    process.once('SIGINT', onSigint);
+
+    interval = setInterval(async () => {
+      try {
+        const elapsed = Date.now() - startTime;
+
+        if (elapsed >= TIMEOUT_MS) {
+          console.log(chalk.yellow(`⏱ Overall timeout reached - but continuing to monitor existing Devin instance\n`));
+          // Don't create new instance - just reset timer and continue monitoring
+          startTime = Date.now(); // Reset the overall timer
+          return;
+        }
+
+        // Detect progress AND check if IDE agent is done working
+        const { done: doneNow, total: totalNow } = countSpecCheckboxes(spec.path);
+        const currentTime = Date.now();
+
+        // Check for completion signals from IDE agent via status file
+        const statusFilePath = spec.path.replace(/\/$/, '') + '/.vcm-status.json';
+        let agentSignaledCompletionViaFile = false;
+        try {
+          if (await fs.pathExists(statusFilePath)) {
+            const statusContent = await fs.readFile(statusFilePath, 'utf-8');
+            const statusData = JSON.parse(statusContent);
+
+            // Check for completion signals
+            if (statusData.completion === 100 && statusData.status === 'WAITING') {
+              console.log(chalk.green(`←👁 Agent signaled completion via status file: COMPLETION: 100%, STATUS:WAITING\n`));
+              agentSignaledCompletionViaFile = true;
+
+              // Clean up status file
+              await fs.remove(statusFilePath);
+            }
+          }
+        } catch (error) {
+          // Ignore status file errors - file might not exist or be invalid JSON
+        }
+
+        if (doneNow > doneBefore) {
+          const pctNow = totalNow > 0 ? Math.round((doneNow / totalNow) * 100) : 0;
+          safeLog(chalk.green(`✓ Progress detected: ${doneNow}/${totalNow} tasks (${pctNow}%) complete\n`));
+
+          // Update progress tracking
+          lastProgressTime = currentTime;
+          lastProgressDetectionTime = currentTime;
+
+          // Check if all tasks are complete - if so, wait for agent completion signal
+          if (doneNow >= totalNow && totalNow > 0) {
+            safeLog(chalk.green(`←👁 All tasks checked off! Waiting for agent completion signal...\n`));
+            // Don't immediately return - wait for STATUS:WAITING signal or timeout
+            agentSignaledCompletion = true; // Flag that we're waiting for completion signal
+          }
+
+        // If progress detected but not all tasks done, continue waiting for agent to finish current work
+        return; // Continue polling, don't send new task yet
+      }
+
+      // Check for immediate completion via status file signal
+      if (agentSignaledCompletionViaFile) {
+        safeLog(chalk.green(`✓ Agent completed all tasks via status signal! Finishing iteration.\n`));
+        cleanup({ success: true, changes: [] });
+        return;
+      }
+
+      // If agent signaled completion (all tasks done) and we've waited a reasonable time, consider it complete
+      if (agentSignaledCompletion && (currentTime - lastProgressDetectionTime) >= 30 * 1000) {
+        safeLog(chalk.green(`✓ Agent completed all tasks! Finishing iteration.\n`));
+        cleanup({ success: true, changes: [] });
+        return;
+      }
+
+      // Implement cooldown period after progress detection to prevent rapid spawning
+      if (lastProgressDetectionTime > 0 && (currentTime - lastProgressDetectionTime) < PROGRESS_COOLDOWN_MS) {
+        const cooldownRemaining = Math.round((PROGRESS_COOLDOWN_MS - (currentTime - lastProgressDetectionTime)) / 1000);
+        safeLog(chalk.gray(`⏳ In cooldown period (${cooldownRemaining}s remaining) - allowing agent time to complete work\n`));
+        return;
+      }
+
+      // Check for no progress timeout (configurable, default 15 minutes)
+      const timeSinceLastProgress = Date.now() - lastProgressTime;
+      if (timeSinceLastProgress >= PROGRESS_TIMEOUT_MS) {
+        safeLog(chalk.yellow(`⏱  No progress detected for ${Math.round(timeSinceLastProgress / 60000)} minutes on ${providerConfig.displayName}\n`));
+
+        // Check if we've exceeded max IDE attempts
+        if (totalAttempts >= MAX_IDE_ATTEMPTS) {
+          safeLog(chalk.red(`✗ Maximum IDE attempts (${MAX_IDE_ATTEMPTS}) reached. Stopping auto mode.\n`));
+          // Update status card to stopped mode
+          if (storedStatusTitle && storedStatus) {
+            printStatusCard(storedStatusTitle, storedStatus, 'stopped');
+          }
+          // Stop auto mode - call async function properly
+          stopAutoMode().then(() => {
+            cleanup({ success: false, error: 'max_ide_attempts_exceeded', shouldRetry: false });
+          }).catch((err) => {
+            console.error('Error stopping auto mode:', err);
+            cleanup({ success: false, error: 'max_ide_attempts_exceeded', shouldRetry: false });
+          });
+          return;
+        }
+
+        // Don't create new instance - just continue monitoring and send continuation messages
+        // Reset the progress timer to allow more time for the existing instance
+        lastProgressTime = Date.now();
+        totalAttempts++;
+        console.log(chalk.yellow(`⏱  Allowing more time for existing Devin instance (attempt ${totalAttempts}/${MAX_IDE_ATTEMPTS})\n`));
+        return;
+      }
+
+      // Send continuation prompt every 5 minutes if no progress OR if waiting for completion signal
+      const sinceLastContinue = Date.now() - lastContinueSent;
+      if (sinceLastContinue >= CONTINUE_INTERVAL_MS) {
+        lastContinueSent = Date.now();
+        const pctNow = totalNow > 0 ? Math.round((doneNow / totalNow) * 100) : 0;
+        const mins = Math.round(elapsed / 60000);
+
+        let continueMsg;
+        if (agentSignaledCompletion) {
+          // All tasks done, waiting for completion signal
+          continueMsg = `All tasks appear to be completed (${doneNow}/${totalNow} tasks). If you are truly finished, create a status file at ${spec.path}/.vcm-status.json with content {"completion": 100, "status": "WAITING"} to signal completion to VCM. If you need more time, continue working and report progress. (${mins}min elapsed) PLEASE RESPOND`;
+        } else {
+          // Normal continuation prompt
+          continueMsg = `Continue implementing spec "${spec.directory}". Current progress: ${doneNow}/${totalNow} tasks (${pctNow}%) complete. Keep working until ALL tasks in tasks.md are checked off. Next task: "${taskText}". (${mins}min elapsed) PLEASE RESPOND`;
+        }
+
+        try {
+          const appleScriptManager = new AppleScriptManager();
+          // Use plain sendText for continuations (no need to open new thread)
+          await appleScriptManager.sendText(continueMsg, ideType);
+          try {
+            // Check if stdout is still writable before attempting to log
+            if (process.stdout && !process.stdout.destroyed) {
+              const message = `━🔁 Sent continuation prompt to ${providerConfig.displayName} (${mins}min elapsed)\n`;
+              console.log(chalk.gray(message));
+            }
+          } catch (logError) {
+            // Ignore EPIPE and other stdout errors - process may be terminating
+            if (logError.code !== 'EPIPE') {
+              // Re-throw non-EPIPE errors
+              throw logError;
+            }
+          }
+        } catch (_) { /* ignore continuation errors */ }
+      }
+      } catch (error) {
+        // Handle any errors in the setInterval callback, especially EPIPE
+        if (error.code === 'EPIPE') {
+          // Silently ignore EPIPE errors - process is terminating
+          return;
+        }
+        // Log other errors but don't crash
+        console.error('Error in polling interval:', error.message);
+      }
+    }, POLL_INTERVAL_MS);
+  });
+}
+
+module.exports = {
+  initialize,
+  runSpecIdeIteration
+};

package/src/commands/auto-direct/spec-processing.js

@@ -0,0 +1,203 @@
+/**
+ * Spec Processing Helpers
+ *
+ * Handles spec planning and tasks.md generation/regeneration
+ */
+
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs-extra');
+const vibecodingmachineCore = require('vibecodingmachine-core');
+const { AppleScriptManager } = vibecodingmachineCore;
+const { runIteration } = require('./iteration-handlers');
+const { countSpecCheckboxes } = require('./spec-handlers');
+
+/**
+ * Handle spec planning - create tasks.md for specs without one
+ */
+async function handleSpecPlanning(spec, providerConfig, repoPath) {
+  console.log(chalk.cyan('📝 No tasks.md yet — planning spec first...\n'));
+  const planningText = [
+    `Plan and create tasks.md for spec "${spec.directory}".`,
+    `Read ${spec.path}/spec.md${spec.hasPlanPrompt ? ` and ${spec.path}/plan-prompt.md` : ''}.`,
+    `Then create ${spec.path}/tasks.md with implementation tasks as checkboxes (- [ ] task).`
+  ].join('\n');
+
+  let planResult;
+  if (providerConfig.type === 'ide') {
+    console.log(chalk.cyan(`📤 Sending planning task to ${providerConfig.displayName}...\n`));
+    const ideTypeForPlan = providerConfig.provider || providerConfig.ide;
+
+    const sendPlanToIde = async () => {
+      if (ideTypeForPlan === 'devin') {
+        return await sendDevinPlanningTask(planningText);
+      } else {
+        const appleScriptManager = new AppleScriptManager();
+        const sendResult = typeof appleScriptManager.sendTextWithThreadClosure === 'function'
+          ? await appleScriptManager.sendTextWithThreadClosure(planningText, ideTypeForPlan)
+          : await appleScriptManager.sendText(planningText, ideTypeForPlan);
+        if (!sendResult || !sendResult.success) {
+          throw new Error((sendResult && sendResult.error) || 'send failed');
+        }
+        return { success: true };
+      }
+    };
+
+    try {
+      const sendPlanResult = await sendPlanToIde();
+      if (!sendPlanResult || !sendPlanResult.success) {
+        console.log(chalk.red(`✗ Failed to send to ${providerConfig.displayName}`));
+        planResult = { success: false, error: 'send failed' };
+      } else {
+        console.log(chalk.green(`✓ Planning task sent. Waiting for tasks.md to be created...`));
+        const tasksFilePath = path.join(spec.path, 'tasks.md');
+        const POLL_MS = 30 * 1000;
+        const TIMEOUT_MS = 30 * 60 * 1000;
+        const planStart = Date.now();
+        planResult = await new Promise((resolve) => {
+          const iv = setInterval(() => {
+            if (fs.existsSync(tasksFilePath)) {
+              clearInterval(iv);
+              console.log(chalk.green('✓ tasks.md created!\n'));
+              resolve({ success: true });
+            } else if (Date.now() - planStart >= TIMEOUT_MS) {
+              clearInterval(iv);
+              console.log(chalk.yellow('⏰ Timeout waiting for tasks.md\n'));
+              resolve({ success: false, error: 'timeout' });
+            }
+          }, POLL_MS);
+        });
+      }
+    } catch (err) {
+      planResult = { success: false, error: err.message };
+    }
+  } else {
+    const planRequirement = { text: planningText, package: null, disabled: false };
+    planResult = await runIteration(planRequirement, providerConfig, repoPath);
+  }
+
+  if (planResult.success) {
+    console.log(chalk.green('✓ tasks.md created — proceeding with implementation\n'));
+  } else {
+    console.log(chalk.red('✗ Failed to create tasks.md — skipping spec\n'));
+  }
+
+  return planResult;
+}
+
+/**
+ * Handle tasks.md regeneration for narrative format specs
+ */
+async function handleTasksRegeneration(spec, providerConfig) {
+  console.log(chalk.yellow(`\n⚠️  tasks.md exists but has no checkbox tasks (narrative format detected)`));
+  console.log(chalk.yellow(`   Regenerating tasks.md with /speckit.tasks...\n`));
+
+  const tasksRegenerationText = `Run /speckit.tasks to regenerate tasks.md for spec "${spec.directory}" in checkbox format (- [ ] task).`;
+
+  let regenResult;
+  if (providerConfig.type === 'ide') {
+    console.log(chalk.cyan(`📤 Sending tasks regeneration request to ${providerConfig.displayName}...\n`));
+    const ideType = providerConfig.provider || providerConfig.ide;
+    const appleScriptManager = new AppleScriptManager();
+    try {
+      const sendResult = typeof appleScriptManager.sendTextWithThreadClosure === 'function'
+        ? await appleScriptManager.sendTextWithThreadClosure(tasksRegenerationText, ideType)
+        : await appleScriptManager.sendText(tasksRegenerationText, ideType);
+
+      if (!sendResult || !sendResult.success) {
+        console.log(chalk.red(`✗ Failed to send to ${providerConfig.displayName}`));
+        regenResult = { success: false };
+      } else {
+        console.log(chalk.green(`✓ Regeneration request sent. Waiting for tasks.md to be updated...`));
+        await new Promise(resolve => setTimeout(resolve, 30000));
+
+        const { total: totalAfterRegen } = countSpecCheckboxes(spec.path);
+        if (totalAfterRegen > 0) {
+          console.log(chalk.green(`✓ tasks.md regenerated with ${totalAfterRegen} checkbox tasks!\n`));
+          regenResult = { success: true };
+        } else {
+          console.log(chalk.yellow(`⚠️  tasks.md still has no checkbox tasks after regeneration\n`));
+          regenResult = { success: false };
+        }
+      }
+    } catch (err) {
+      regenResult = { success: false, error: err.message };
+    }
+  } else {
+    const regenRequirement = { text: tasksRegenerationText, package: null, disabled: false };
+    regenResult = await runIteration(regenRequirement, providerConfig, spec.path);
+  }
+
+  if (!regenResult.success) {
+    console.log(chalk.red('✗ Failed to regenerate tasks.md — skipping spec\n'));
+  }
+
+  return regenResult;
+}
+
+/**
+ * Send planning task to Devin using AppleScript
+ */
+async function sendDevinPlanningTask(planningText) {
+  const { execSync } = require('child_process');
+  const { writeFileSync, unlinkSync } = require('fs');
+  const { tmpdir } = require('os');
+  const ts = Date.now();
+  const tmpText = path.join(tmpdir(), `plan_instr_${ts}.txt`);
+  const tmpScpt = path.join(tmpdir(), `send_devin_plan_${ts}.scpt`);
+  writeFileSync(tmpText, planningText, 'utf8');
+  const combinedPlanScript = `
+set planText to (do shell script "cat " & quoted form of "${tmpText}")
+tell application "Devin"
+  activate
+  delay 1.5
+end tell
+set maxTries to 3
+set tries to 0
+repeat
+  set tries to tries + 1
+  tell application "System Events"
+    set frontBundleID to bundle identifier of first process whose frontmost is true
+  end tell
+  if frontBundleID is "ai.cognition.devin" then exit repeat
+  if tries >= maxTries then
+    error "Devin did not become frontmost (frontmost bundle ID: " & frontBundleID & ")"
+  end if
+  tell application "Devin"
+    activate
+  end tell
+  delay 1.0
+end repeat
+tell application "System Events"
+  set devinProc to first process whose bundle identifier is "ai.cognition.devin"
+  tell devinProc
+    set frontmost to true
+    delay 0.5
+    keystroke "l" using {command down, shift down}
+    delay 2.0
+    keystroke "a" using {command down}
+    delay 0.3
+    key code 51
+    delay 0.3
+    set the clipboard to planText
+    keystroke "v" using {command down}
+    delay 0.5
+    key code 36
+    delay 1.0
+  end tell
+end tell
+`;
+  writeFileSync(tmpScpt, combinedPlanScript, 'utf8');
+  try {
+    execSync(`osascript "${tmpScpt}"`, { stdio: 'pipe', timeout: 30000 });
+    return { success: true };
+  } finally {
+    try { unlinkSync(tmpScpt); } catch (_) { }
+    try { unlinkSync(tmpText); } catch (_) { }
+  }
+}
+
+module.exports = {
+  handleSpecPlanning,
+  handleTasksRegeneration
+};

package/src/commands/auto-direct/status-display.js

@@ -4,7 +4,7 @@
  */
 
 const chalk = require('chalk');
-const { getAutoConfig, getStages, DEFAULT_STAGES } = require('../../../utils/config');
+const { getAutoConfig, getStages, DEFAULT_STAGES } = require('../../utils/config');
 
 // Configured stages (will be loaded from config)
 let configuredStages = DEFAULT_STAGES;
@@ -21,32 +21,32 @@ function printStatusCard(currentTitle, currentStatus) {
 
   // Get terminal width
   const terminalWidth = process.stdout.columns || 80;
-  
+
   // Calculate widths
   const padding = 2;
   const maxTitleWidth = Math.floor((terminalWidth - padding * 2) * 0.4);
   const maxStatusWidth = Math.floor((terminalWidth - padding * 2) * 0.6);
-  
+
   // Truncate title if too long
   let displayTitle = currentTitle;
   if (displayTitle.length > maxTitleWidth) {
     displayTitle = displayTitle.substring(0, maxTitleWidth - 3) + '...';
   }
-  
+
   // Build status line
   let statusLine = '';
   stages.forEach((stage, index) => {
     const isCurrent = stage === currentStatus;
     const isCompleted = stageMap[currentStatus] > index;
     const isPending = stageMap[currentStatus] < index;
-    
+
     let stageDisplay = stage;
     if (stage === 'PREPARE') stageDisplay = '🔍 PREPARE';
     else if (stage === 'ACT') stageDisplay = '⚡ ACT';
     else if (stage === 'CLEAN UP') stageDisplay = '🧹 CLEAN UP';
     else if (stage === 'VERIFY') stageDisplay = '✅ VERIFY';
     else if (stage === 'DONE') stageDisplay = '🎉 DONE';
-    
+
     if (isCurrent) {
       statusLine += chalk.bgBlue.white(` ${stageDisplay} `);
     } else if (isCompleted) {
@@ -54,17 +54,17 @@ function printStatusCard(currentTitle, currentStatus) {
     } else if (isPending) {
       statusLine += chalk.bgGray.white(` ${stageDisplay} `);
     }
-    
+
     if (index < stages.length - 1) {
       statusLine += ' ';
     }
   });
-  
+
   // Build the card
   const border = '─'.repeat(terminalWidth);
   const titleLine = displayTitle.padEnd(terminalWidth - padding * 2);
   const statusLinePadded = statusLine.padEnd(terminalWidth - padding * 2);
-  
+
   console.log();
   console.log(chalk.gray(border));
   console.log(chalk.gray(`│ ${titleLine} │`));

package/src/commands/auto-direct/utils.js

@@ -100,6 +100,84 @@ function sleep(ms) {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+/**
+ * Safely log to console with EPIPE protection
+ * @param {...any} args - Arguments to pass to console.log
+ */
+function safeLog(...args) {
+  try {
+    // Check if stdout is still writable before attempting to log
+    if (process.stdout && !process.stdout.destroyed) {
+      console.log(...args);
+    }
+  } catch (logError) {
+    // Ignore EPIPE and other stdout errors - process may be terminating
+    if (logError.code !== 'EPIPE') {
+      // Re-throw non-EPIPE errors
+      throw logError;
+    }
+  }
+}
+
+/**
+ * Normalize whitespace for comparison (convert all whitespace to single spaces)
+ */
+function normalizeWhitespace(str) {
+  return str.replace(/\s+/g, ' ').trim();
+}
+
+/**
+ * Extract key identifiers from code (variable names, function names, strings)
+ */
+function extractIdentifiers(code) {
+  const identifiers = new Set();
+
+  // Extract quoted strings
+  const stringMatches = code.match(/'([^']+)'|"([^"]+)"/g);
+  if (stringMatches) {
+    stringMatches.forEach(match => {
+      const str = match.slice(1, -1); // Remove quotes
+      if (str.length > 3) { // Only meaningful strings
+        identifiers.add(str);
+      }
+    });
+  }
+
+  // Extract variable/function names (words followed by : or =)
+  const nameMatches = code.match(/\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*[:=]/g);
+  if (nameMatches) {
+    nameMatches.forEach(match => {
+      const name = match.replace(/[:=].*$/, '').trim();
+      if (name.length > 2) {
+        identifiers.add(name);
+      }
+    });
+  }
+
+  // Extract common patterns like 'type:', 'name:', 'value:'
+  const patternMatches = code.match(/(type|name|value|file|path|function|const|let|var)\s*:/gi);
+  if (patternMatches) {
+    patternMatches.forEach(match => {
+      identifiers.add(match.toLowerCase().replace(/\s*:/, ''));
+    });
+  }
+
+  return Array.from(identifiers);
+}
+
+/**
+ * Extract structural pattern from code (ignoring values)
+ */
+function extractPattern(code) {
+  // Replace strings with placeholders
+  let pattern = code.replace(/'[^']+'|"[^"]+"/g, '"..."');
+  // Replace numbers with placeholders
+  pattern = pattern.replace(/\b\d+\b/g, 'N');
+  // Normalize whitespace
+  pattern = normalizeWhitespace(pattern);
+  return pattern;
+}
+
 module.exports = {
   getTimestamp,
   getLogTimestamp,
@@ -108,5 +186,9 @@ module.exports = {
   getVisualWidth,
   padToVisualWidth,
   isRateLimitMessage,
-  sleep
+  sleep,
+  safeLog,
+  normalizeWhitespace,
+  extractIdentifiers,
+  extractPattern
 };