teleportation-cli 1.1.4 → 1.2.0

package/lib/daemon/task-executor.js

@@ -0,0 +1,1235 @@
+/**
+ * Task Executor
+ *
+ * Executes task tasks using Claude Code's headless mode.
+ * Provides an autonomous execution loop that continues until:
+ * - Task is complete
+ * - Claude asks a question requiring user input
+ * - User stops the task
+ * - Budget is exhausted
+ *
+ * Key features:
+ * - Uses `claude -p` with `--output-format json` for structured results
+ * - Captures `session_id` from JSON result for conversation continuity
+ * - Uses `--resume <session-id>` for subsequent turns
+ * - Budget control via `--max-budget-usd`
+ * - Hooks fire normally (approvals go to mobile app)
+ *
+ * @module lib/daemon/task-executor
+ */
+
+import { spawn } from 'child_process';
+import { randomUUID } from 'crypto';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { classifyResponse, getConfidenceThreshold } from './response-classifier.js';
+
+// Paths
+const TELEPORTATION_DIR = path.join(os.homedir(), '.teleportation');
+const TASKS_LOCK_DIR = path.join(TELEPORTATION_DIR, 'task_locks');
+
+// Ensure lock directory exists with strict permissions (owner only)
+if (!fs.existsSync(TASKS_LOCK_DIR)) {
+  fs.mkdirSync(TASKS_LOCK_DIR, { recursive: true, mode: 0o700 });
+} else {
+  // Ensure permissions are correct if it already exists
+  try { fs.chmodSync(TASKS_LOCK_DIR, 0o700); } catch (e) {}
+}
+
+// Default configuration
+const DEFAULT_BUDGET_USD = 10.0;
+const DEFAULT_TIMEOUT_MS = 600000; // 10 minutes per turn
+const CLAUDE_CLI = process.env.CLAUDE_CLI_PATH || 'claude';
+const SIGTERM_TIMEOUT_MS = 2000; // 2 seconds before SIGKILL
+
+// Safety limits to prevent runaway execution
+const MAX_TURNS = 100; // Maximum execution turns before forced stop
+const WAIT_FOR_RESUME_TIMEOUT_MS = 1800000; // 30 minutes max wait for resume
+const POLLING_INTERVAL_MS = 1000; // Polling interval for waitForResume
+const SESSION_CLEANUP_INTERVAL_MS = 300000; // 5 minutes cleanup interval
+const SESSION_MAX_AGE_MS = 3600000; // 1 hour max session age
+const MAX_CONSECUTIVE_FAILURES = 3; // Stop after this many consecutive failures
+const MAX_HISTORY_SIZE = 20; // Maximum history entries to keep per session
+
+/**
+ * Helper: Remove task lock file safely
+ * @param {string} taskId 
+ */
+export function removeTaskLock(taskId) {
+  const lockPath = path.join(TASKS_LOCK_DIR, `${taskId}.pid`);
+  try {
+    fs.unlinkSync(lockPath);
+  } catch (err) {
+    if (err.code !== 'ENOENT') {
+      console.debug(`[task] Non-fatal: Failed to remove lock for ${taskId}:`, err.message);
+    }
+  }
+}
+
+/**
+ * Task session state
+ * @typedef {Object} TaskSession
+ * @property {string} id - Unique session ID
+ * @property {string} task - Original task description
+ * @property {'running' | 'paused' | 'waiting_input' | 'completed' | 'stopped' | 'budget_paused'} status
+ * @property {string|null} claude_session_id - Claude Code's session ID for resume
+ * @property {boolean} auto_continue - Whether to automatically continue after each turn
+ * @property {number} budget_usd - Total budget allocated
+ * @property {number} cost_usd - Total cost incurred so far
+ * @property {number} started_at - Timestamp when task started
+ * @property {number} updated_at - Timestamp of last update
+ * @property {number|null} completed_at - Timestamp when task completed
+ * @property {string|null} pending_question - Question waiting for user answer
+ * @property {number} turn_count - Number of execution turns
+ * @property {Array} history - Execution history
+ */
+
+// In-memory session store (will be replaced with Redis in relay endpoints)
+const taskSessions = new Map();
+
+// Track running processes for stop functionality
+const runningProcesses = new Map();
+
+/**
+ * Cleanup orphaned process entries on startup
+ * Removes Map entries for processes that are no longer running
+ */
+export function cleanupOrphanedProcesses() {
+  let cleanedCount = 0;
+  for (const [id, proc] of runningProcesses) {
+    if (proc.pid && !isProcessRunning(proc.pid)) {
+      runningProcesses.delete(id);
+      cleanedCount++;
+    }
+  }
+  if (cleanedCount > 0) {
+    console.log(`[task] Cleaned up ${cleanedCount} orphaned process entries`);
+  }
+}
+
+/**
+ * Check if a process is running
+ * @param {number} pid 
+ * @returns {boolean}
+ */
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Cleanup old/stale task locks on startup
+ * Removes lock files for processes that are no longer running
+ */
+export function cleanupStaleLocks() {
+  if (!fs.existsSync(TASKS_LOCK_DIR)) return;
+
+  try {
+    const files = fs.readdirSync(TASKS_LOCK_DIR);
+    let cleanedCount = 0;
+
+    for (const file of files) {
+      if (!file.endsWith('.pid')) continue;
+      
+      const lockPath = path.join(TASKS_LOCK_DIR, file);
+      try {
+        const lockContent = fs.readFileSync(lockPath, 'utf8');
+        const { pid } = JSON.parse(lockContent);
+        
+        // Check if process exists
+        process.kill(pid, 0);
+      } catch (e) {
+        // Process is dead, stale lock, or invalid JSON
+        // Only clean up if it's actually dead (ESRCH) or corrupted (SyntaxError)
+        if (e.code === 'ESRCH' || e instanceof SyntaxError || e.name === 'SyntaxError') {
+          try {
+            fs.unlinkSync(lockPath);
+            cleanedCount++;
+          } catch (unlinkErr) {}
+        }
+      }
+    }
+
+    if (cleanedCount > 0) {
+      console.log(`[task] Cleaned up ${cleanedCount} stale task lock(s)`);
+    }
+  } catch (err) {
+    console.error('[task] Failed to cleanup stale locks:', err.message);
+  }
+}
+
+/**
+ * Cleanup old/stale sessions to prevent memory leaks
+ * Removes sessions that:
+ * - Are completed/stopped and older than SESSION_MAX_AGE_MS
+ * - Have no activity for SESSION_MAX_AGE_MS
+ */
+function cleanupStaleSessions() {
+  const now = Date.now();
+  let cleanedCount = 0;
+
+  for (const [id, session] of taskSessions) {
+    const age = now - session.started_at;
+    const lastActivity = now - session.updated_at;
+
+    // Remove finished sessions older than max age
+    const isFinished = session.status === 'completed' || session.status === 'stopped';
+    if (isFinished && age > SESSION_MAX_AGE_MS) {
+      taskSessions.delete(id);
+      runningProcesses.delete(id);
+      cleanedCount++;
+      continue;
+    }
+
+    // Remove sessions with no activity for max age
+    if (lastActivity > SESSION_MAX_AGE_MS) {
+      // Kill any running process
+      const proc = runningProcesses.get(id);
+      if (proc) {
+        proc.kill('SIGTERM');
+        runningProcesses.delete(id);
+      }
+      taskSessions.delete(id);
+      cleanedCount++;
+    }
+  }
+
+  if (cleanedCount > 0) {
+    console.log(`[task] Cleaned up ${cleanedCount} stale sessions`);
+  }
+}
+
+// Start periodic cleanup (only in non-test environments)
+if (process.env.NODE_ENV !== 'test') {
+  setInterval(cleanupStaleSessions, SESSION_CLEANUP_INTERVAL_MS);
+}
+
+/**
+ * Generate a unique task session ID using cryptographically secure random UUID
+ * @returns {string}
+ */
+function generateTaskId() {
+  return `task-${Date.now()}-${randomUUID()}`;
+}
+
+/**
+ * Execute Claude Code in headless mode
+ *
+ * @param {Object} options
+ * @param {string} options.prompt - The prompt to send to Claude
+ * @param {string} options.cwd - Working directory
+ * @param {string|null} options.resumeSessionId - Claude session ID to resume (null for new)
+ * @param {number} options.budgetUsd - Max budget in USD
+ * @param {number} options.timeoutMs - Timeout in milliseconds
+ * @param {string} options.taskId - Task session ID for tracking
+ * @param {Function} [options.onUpdate] - Optional callback for streaming updates
+ * @returns {Promise<Object>} Execution result with session_id, output, cost, etc.
+ */
+async function executeClaudeHeadless(options) {
+  const {
+    prompt,
+    cwd,
+    resumeSessionId,
+    budgetUsd,
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+    taskId,
+    parentSessionId,
+    onUpdate,
+  } = options;
+
+  return new Promise((resolve, reject) => {
+    const args = [];
+
+    // Resume existing session or start new
+    if (resumeSessionId) {
+      args.push('--resume', resumeSessionId);
+    }
+
+    // Add prompt
+    args.push('-p', prompt);
+
+    // Output format for structured parsing - using stream-json for real-time metadata
+    args.push('--output-format', 'stream-json');
+    args.push('--verbose');
+
+    // Budget control (Claude Code native feature)
+    if (budgetUsd > 0) {
+      args.push('--max-budget-usd', budgetUsd.toFixed(2));
+    }
+
+    // Hooks enabled: approvals route to mobile app
+    // Session must be in "away" mode for hooks to wait for remote approval
+    // (Daemon sets away mode before calling startTask)
+
+    console.log(`[task] Executing: ${CLAUDE_CLI} ${args.join(' ')}`);
+
+    const proc = spawn(CLAUDE_CLI, args, {
+      cwd,
+      stdio: 'pipe',
+      env: {
+        ...process.env,
+        CI: 'true', // Non-interactive mode
+        TELEPORTATION_TASK_MODE: 'true',
+        // Pass parent session ID so hooks can log approvals to correct timeline
+        ...(parentSessionId && { TELEPORTATION_PARENT_SESSION_ID: parentSessionId }),
+      },
+    });
+
+    // Track process for stop functionality
+    runningProcesses.set(taskId, proc);
+
+    // Close stdin to prevent hanging
+    proc.stdin.end();
+
+    let stdout = '';
+    let stderr = '';
+    let timedOut = false;
+    let buffer = '';
+
+    // Final result structure
+    let result = {
+      success: false,
+      output: '',
+      error: null,
+      exit_code: 0,
+      session_id: null,
+      cost_usd: 0,
+      duration_ms: 0,
+      model: null,
+      usage: {
+        tools_used: 0,
+        input_tokens: 0,
+        output_tokens: 0,
+        cache_creation_input_tokens: 0,
+        cache_read_input_tokens: 0
+      },
+      tool_calls: [],
+    };
+
+    // Timeout handler
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      proc.kill('SIGTERM');
+    }, timeoutMs);
+
+    proc.stdout.on('data', (data) => {
+      const chunk = data.toString();
+      stdout += chunk;
+      buffer += chunk;
+
+      // Process stream-json lines
+      const lines = buffer.split('\n');
+      buffer = lines.pop(); // Keep last incomplete line
+
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          // Debug: console.debug(`[stream] Line: ${line.slice(0, 100)}`);
+          const msg = JSON.parse(line);
+          
+          // Accumulate metadata from stream
+          if (msg.type === 'system' && msg.subtype === 'init' && msg.session_id) {
+            result.session_id = msg.session_id;
+          }
+
+          if (msg.type === 'assistant' && msg.message?.content) {
+            const content = msg.message.content;
+            for (const block of content) {
+              if (block.type === 'text') {
+                result.output += block.text;
+                if (onUpdate) onUpdate({ type: 'text', text: block.text });
+              } else if (block.type === 'tool_use') {
+                result.usage.tools_used++;
+                result.tool_calls.push(block);
+                if (onUpdate) onUpdate({ type: 'tool_use', tool: block.name });
+              }
+            }
+          }
+
+          if (msg.type === 'usage' || (msg.type === 'assistant' && msg.message?.usage)) {
+            const usage = msg.usage || msg.message.usage;
+            result.usage.input_tokens += usage.input_tokens || 0;
+            result.usage.output_tokens += usage.output_tokens || 0;
+            result.usage.cache_creation_input_tokens += usage.cache_creation_input_tokens || 0;
+            result.usage.cache_read_input_tokens += usage.cache_read_input_tokens || 0;
+          }
+
+          if (msg.type === 'result') {
+             result.success = !msg.is_error;
+             if (msg.is_error) result.error = msg.error;
+             if (msg.total_cost_usd) result.cost_usd = msg.total_cost_usd;
+          }
+        } catch (e) {
+          // Non-JSON line, ignore or log
+        }
+      }
+    });
+
+    proc.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    proc.on('close', (code) => {
+      clearTimeout(timeout);
+      runningProcesses.delete(taskId);
+
+      result.exit_code = code;
+      result.duration_ms = Date.now() - (result.start_time || Date.now());
+
+      if (timedOut) {
+        result.success = false;
+        result.error = 'Execution timed out';
+        result.exit_code = -1;
+      } else if (code !== 0 && !result.error) {
+        result.success = false;
+        result.error = stderr || `Exit code: ${code}`;
+      } else if (code === 0) {
+        result.success = true;
+      }
+
+      // If output is still empty but we have stdout that wasn't stream-json, 
+      // fall back to raw stdout
+      if (!result.output && stdout) {
+        try {
+          const parsed = JSON.parse(stdout);
+          result.output = parsed.result || parsed.response || parsed.output || stdout;
+          result.session_id = result.session_id || parsed.session_id;
+          result.cost_usd = result.cost_usd || parsed.cost || 0;
+        } catch {
+          result.output = stdout;
+        }
+      }
+
+      resolve(result);
+    });
+
+    proc.on('error', (err) => {
+      clearTimeout(timeout);
+      runningProcesses.delete(taskId);
+      reject(err);
+    });
+  });
+}
+
+/**
+ * Start a new task task
+ *
+ * @param {Object} options
+ * @param {string} options.task - Task description
+ * @param {string} options.session_id - Teleportation session ID
+ * @param {string} options.cwd - Working directory
+ * @param {number} [options.budget_usd] - Max budget in USD (default: 10)
+ * @param {boolean} [options.auto_continue=false] - Auto-continue after each turn (default: false). When disabled, task pauses after each turn and waits for user message.
+ * @param {Function} [options.onEvent] - Callback for task events
+ * @returns {Promise<TaskSession>}
+ */
+export async function startTask(options) {
+  const {
+    task,
+    session_id,
+    cwd,
+    budget_usd = DEFAULT_BUDGET_USD,
+    parent_claude_session_id = null,
+    auto_continue: rawAutoContinue = false,
+    onEvent,
+  } = options;
+
+  // Validate auto_continue parameter - ensure it's a boolean
+  const auto_continue = Boolean(rawAutoContinue ?? false);
+
+  const taskId = options.task_id || generateTaskId(); 
+  const now = Date.now();
+  const lockPath = path.join(TASKS_LOCK_DIR, `${taskId}.pid`);
+
+  // Atomic lock acquisition using 'wx' (exclusive write)
+  // This prevents multiple daemon instances from claiming the same task simultaneously
+  let acquired = false;
+  let attempts = 0;
+  
+  while (!acquired && attempts < 2) {
+    attempts++;
+    try {
+      const lockData = JSON.stringify({
+        pid: process.pid,
+        taskId,
+        startTime: now,
+        hostname: os.hostname()
+      });
+      fs.writeFileSync(lockPath, lockData, { flag: 'wx', mode: 0o600 });
+      acquired = true;
+    } catch (err) {
+      if (err.code === 'EEXIST') {
+        // Lock already exists - verify if it's stale or our own
+        try {
+          const lockContent = fs.readFileSync(lockPath, 'utf8');
+          const existing = JSON.parse(lockContent);
+          
+          // 1. Self-recovery check
+          if (existing.pid === process.pid && existing.hostname === os.hostname()) {
+            console.log(`[task] Task ${taskId} already owned by this process, continuing.`);
+            acquired = true;
+            break;
+          } else if (existing.hostname === os.hostname()) {
+            // 2. Same-machine staleness check
+            process.kill(existing.pid, 0); // Throws if process is dead
+            console.log(`[task] Task ${taskId} is already being handled by process ${existing.pid} (started ${new Date(existing.startTime).toISOString()}), skipping start.`);
+            return { id: taskId, status: 'already_running' };
+          } else {
+            // 3. Different machine - assume task is alive if lock is relatively fresh (< 1 hour)
+            const lockAge = now - existing.startTime;
+            if (lockAge < 3600000) {
+              console.log(`[task] Task ${taskId} is owned by another host (${existing.hostname}), skipping start.`);
+              return { id: taskId, status: 'already_running' };
+            }
+            // Lock is old - potentially stale cross-host, remove and retry
+            console.log(`[task] Stale cross-host lock found for task ${taskId}, cleaning up and retrying acquisition.`);
+            removeTaskLock(taskId);
+            // Allow while loop to retry acquisition immediately
+            continue;
+          }
+        } catch (e) {
+          // Process dead or invalid JSON - lock is stale
+          console.log(`[task] Stale lock found for task ${taskId}, cleaning up and retrying acquisition.`);
+          removeTaskLock(taskId);
+          // Allow while loop to retry acquisition immediately
+          continue;
+        }
+      } else {
+        throw err;
+      }
+    }
+  }
+
+  if (!acquired) {
+    console.log(`[task] Failed to acquire lock for ${taskId} after retrying stale cleanup.`);
+    return { id: taskId, status: 'already_running' };
+  }
+
+  // Create task session
+  const session = {
+    id: taskId,
+    teleportation_session_id: session_id,
+    task,
+    status: 'running',
+    claude_session_id: null, // Will be set to child session on first execution
+    parent_claude_session_id, // Parent session to resume for context
+    auto_continue, // Whether to automatically continue or wait for user messages
+    budget_usd,
+    cost_usd: 0,
+    started_at: now,
+    updated_at: now,
+    completed_at: null,
+    pending_question: null,
+    turn_count: 0,
+    history: [],
+    cwd,
+  };
+
+  taskSessions.set(taskId, session);
+
+  // Emit started event
+  if (onEvent) {
+    onEvent({
+      type: 'task_started',
+      source: 'autonomous_task',
+      task_id: taskId,
+      session_id,
+      task,
+      budget_usd,
+      timestamp: now,
+    });
+  }
+
+  // Start execution loop - ensure we don't start the same task twice
+  // (Race condition protection at the executor level)
+  if (runningProcesses.has(taskId)) {
+    console.log(`[task] Task ${taskId} is already running in this process, skipping loop start`);
+    return session;
+  }
+
+  executeTaskLoop(taskId, onEvent).catch(err => {
+    console.error(`[task] Loop error for ${taskId}:`, err.message);
+    const s = taskSessions.get(taskId);
+    if (s) {
+      s.status = 'stopped';
+      s.updated_at = Date.now();
+      // Remove lock on error
+      removeTaskLock(taskId);
+      
+      if (onEvent) {
+        onEvent({
+          type: 'task_stopped',
+          source: 'autonomous_task',
+          task_id: taskId,
+          reason: `Error: ${err.message}`,
+          timestamp: Date.now(),
+        });
+      }
+    }
+  });
+
+  return session;
+}
+
+/**
+ * Main task execution loop
+ * Continues until complete, question, stopped, or budget exhausted
+ *
+ * @param {string} taskId - Task session ID
+ * @param {Function} onEvent - Event callback
+ */
+async function executeTaskLoop(taskId, onEvent) {
+  const session = taskSessions.get(taskId);
+  if (!session) {
+    throw new Error(`Task session not found: ${taskId}`);
+  }
+
+  let continueExecution = true;
+  let consecutiveFailures = 0;
+
+  while (continueExecution) {
+    // Check for stop signal
+    if (session.status === 'stopped') {
+      console.log(`[task] Session ${taskId} stopped by user`);
+      break;
+    }
+
+    // Safety: Check max turns limit to prevent infinite loops
+    if (session.turn_count >= MAX_TURNS) {
+      session.status = 'stopped';
+      session.updated_at = Date.now();
+      console.log(`[task] Session ${taskId} reached max turns limit (${MAX_TURNS})`);
+      if (onEvent) {
+        onEvent({
+          type: 'task_stopped',
+          source: 'autonomous_task',
+          task_id: taskId,
+          reason: `Max turns limit reached (${MAX_TURNS})`,
+          cost_usd: session.cost_usd,
+          turn_count: session.turn_count,
+          timestamp: Date.now(),
+        });
+      }
+      break;
+    }
+
+    // Check for pause
+    if (session.status === 'paused') {
+      console.log(`[task] Session ${taskId} paused, waiting for resume`);
+      try {
+        await waitForResume(taskId);
+      } catch (timeoutError) {
+        // Timeout occurred - session already marked as stopped in waitForResume
+        console.log(`[task] Session ${taskId} pause timeout: ${timeoutError.message}`);
+        if (onEvent) {
+          onEvent({
+            type: 'task_stopped',
+            source: 'autonomous_task',
+            task_id: taskId,
+            reason: 'Pause timeout - no resume received',
+            timestamp: Date.now(),
+          });
+        }
+        break;
+      }
+      continue;
+    }
+
+    // Check budget
+    const remainingBudget = session.budget_usd - session.cost_usd;
+    if (remainingBudget <= 0) {
+      session.status = 'budget_paused';
+      session.updated_at = Date.now();
+      console.log(`[task] Session ${taskId} budget exhausted`);
+      if (onEvent) {
+        onEvent({
+          type: 'task_budget_hit',
+          source: 'autonomous_task',
+          task_id: taskId,
+          cost_usd: session.cost_usd,
+          budget_usd: session.budget_usd,
+          timestamp: Date.now(),
+        });
+      }
+      break;
+    }
+
+    // Build prompt for this turn
+    let prompt;
+    if (session.turn_count === 0) {
+      // First turn: use the original task description
+      prompt = session.task;
+    } else if (session.auto_continue) {
+      // Auto-continuation enabled: use generic continuation
+      prompt = 'Continue working on the task.';
+    } else {
+      // Auto-continuation disabled: pause and wait for user message
+      session.status = 'paused';
+      session.updated_at = Date.now();
+      console.log(`[task] Turn ${session.turn_count + 1}: Auto-continue disabled, pausing for user input`);
+      if (onEvent) {
+        onEvent({
+          type: 'task_paused',
+          source: 'autonomous_task',
+          task_id: taskId,
+          reason: 'Waiting for user message (auto_continue disabled)',
+          turn_count: session.turn_count,
+          timestamp: Date.now(),
+        });
+      }
+      // Wait for resume with user message
+      try {
+        await waitForResume(taskId);
+        // Atomically get and clear pending_question to prevent race conditions
+        const userMessage = atomicGetAndClearMessage(taskId);
+        if (!userMessage) {
+          console.log(`[task] Resumed without user message, stopping task ${taskId}`);
+          session.status = 'stopped';
+          session.updated_at = Date.now();
+          break;
+        }
+        // Use the user's message as the prompt
+        prompt = userMessage;
+      } catch (timeoutError) {
+        console.log(`[task] Session ${taskId} pause timeout: ${timeoutError.message}`);
+        if (onEvent) {
+          onEvent({
+            type: 'task_stopped',
+            source: 'autonomous_task',
+            task_id: taskId,
+            reason: 'Pause timeout - no user message received',
+            timestamp: Date.now(),
+          });
+        }
+        break;
+      }
+    }
+
+    // Execute Claude
+    session.turn_count++;
+    console.log(`[task] Turn ${session.turn_count} for ${taskId}`);
+
+    // Re-check status immediately before expensive operation (race condition fix)
+    const currentSession = taskSessions.get(taskId);
+    if (!currentSession || currentSession.status === 'stopped') {
+      console.log(`[task] Session ${taskId} stopped before execution`);
+      break;
+    }
+
+    try {
+      // Determine which session to resume:
+      // - Turn 1: Resume parent session for context (if available)
+      // - Turn 2+: Resume child session from previous turn
+      const resumeSessionId = session.claude_session_id
+        ? session.claude_session_id  // Use child session from previous turns
+        : session.parent_claude_session_id;  // Use parent session on first turn
+
+      if (resumeSessionId && session.turn_count === 1) {
+        console.log(`[task] Turn 1: Resuming parent session ${resumeSessionId} for context`);
+      } else if (resumeSessionId) {
+        console.log(`[task] Turn ${session.turn_count}: Resuming child session ${resumeSessionId}`);
+      }
+
+      const result = await executeClaudeHeadless({
+        prompt,
+        cwd: session.cwd,
+        resumeSessionId,
+        budgetUsd: remainingBudget,
+        taskId,
+        parentSessionId: session.teleportation_session_id,
+        onUpdate: (update) => {
+          if (onEvent) {
+            onEvent({
+              type: 'task_progress',
+              source: 'autonomous_task',
+              task_id: taskId,
+              update,
+              timestamp: Date.now(),
+            });
+          }
+        }
+      });
+
+      // Update session with result
+      session.claude_session_id = result.session_id || session.claude_session_id;
+      session.cost_usd += result.cost_usd || 0;
+      session.updated_at = Date.now();
+
+      // Add to history
+      session.history.push({
+        turn: session.turn_count,
+        prompt,
+        output: result.output?.slice(0, 2000), // Truncate for storage
+        cost_usd: result.cost_usd,
+        success: result.success,
+        usage: result.usage,
+        timestamp: Date.now(),
+      });
+
+      // Trim history to prevent unbounded growth
+      if (session.history.length > MAX_HISTORY_SIZE) {
+        session.history = session.history.slice(-MAX_HISTORY_SIZE);
+      }
+
+      // Track consecutive failures for error recovery
+      if (!result.success) {
+        consecutiveFailures++;
+        console.error(`[task] Turn ${session.turn_count} failed (${consecutiveFailures}/${MAX_CONSECUTIVE_FAILURES}):`, result.error);
+
+        if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+          session.status = 'stopped';
+          session.updated_at = Date.now();
+          console.log(`[task] Session ${taskId} stopped due to ${MAX_CONSECUTIVE_FAILURES} consecutive failures`);
+          if (onEvent) {
+            onEvent({
+              type: 'task_stopped',
+              source: 'autonomous_task',
+              task_id: taskId,
+              reason: `${MAX_CONSECUTIVE_FAILURES} consecutive failures`,
+              cost_usd: session.cost_usd,
+              turn_count: session.turn_count,
+              timestamp: Date.now(),
+            });
+          }
+          break;
+        }
+      } else {
+        // Reset failure counter on success
+        consecutiveFailures = 0;
+      }
+
+      // Mic-Handover Logic (Parity with Local CLI)
+      // 1. If tools were called, we MUST continue automatically (Task loop)
+      // 2. If no tools were called, Claude is "handing the mic" to the user.
+      
+      const hasToolsMetadata = result.usage?.tools_used !== undefined || Array.isArray(result.tool_calls);
+      const toolsCalled = result.usage?.tools_used > 0 || (Array.isArray(result.tool_calls) && result.tool_calls.length > 0);
+      
+      // If we have tool metadata and tools were used, auto-continue.
+      // If we DON'T have metadata (e.g. basic coder), fall back to text classification.
+      if (hasToolsMetadata && toolsCalled && result.success) {
+        console.log(`[task] Tools executed in turn ${session.turn_count}. Auto-continuing...`);
+        // Continue working - loop will iterate automatically
+        continue;
+      }
+
+      // No tools called (or no metadata available) - Claude is done or has a question
+      console.log(`[task] ${hasToolsMetadata ? 'No tools executed' : 'No tool metadata available'}. Classifying response...`);
+      const classification = classifyResponse(result);
+      console.log(`[task] Classification: ${classification.action} (confidence: ${classification.confidence})`);
+
+      // Determine next action based on classification
+      switch (classification.action) {
+        case 'complete':
+          session.status = 'completed';
+          session.completed_at = Date.now();
+          session.updated_at = Date.now();
+          continueExecution = false;
+          console.log(`[task] Task completed for ${taskId}`);
+          
+          // Remove lock file on completion
+          removeTaskLock(taskId);
+
+          if (onEvent) {
+            onEvent({
+              type: 'task_completed',
+              source: 'autonomous_task',
+              task_id: taskId,
+              output: result.output,
+              cost_usd: session.cost_usd,
+              turn_count: session.turn_count,
+              timestamp: Date.now(),
+            });
+          }
+          break;
+
+        case 'question':
+          session.status = 'waiting_input';
+          session.pending_question = classification.questionText;
+          session.updated_at = Date.now();
+          continueExecution = false;
+          console.log(`[task] Question detected for ${taskId}: ${classification.questionText?.slice(0, 100)}`);
+          if (onEvent) {
+            onEvent({
+              type: 'task_question',
+              source: 'autonomous_task',
+              task_id: taskId,
+              question: classification.questionText,
+              confidence: classification.confidence,
+              timestamp: Date.now(),
+            });
+          }
+          break;
+
+        case 'continue':
+        default:
+          // Continue working - loop will iterate
+          console.log(`[task] Continuing execution for ${taskId}`);
+          break;
+      }
+    } catch (error) {
+      console.error(`[task] Execution error for ${taskId}:`, error.message);
+      session.status = 'stopped';
+      session.updated_at = Date.now();
+      continueExecution = false;
+      
+      // Remove lock file on error
+      removeTaskLock(taskId);
+
+      if (onEvent) {
+        onEvent({
+          type: 'task_stopped',
+          source: 'autonomous_task',
+          task_id: taskId,
+          reason: `Error: ${error.message}`,
+          timestamp: Date.now(),
+        });
+      }
+    }
+  }
+}
+
+/**
+ * Wait for an task session to be resumed
+ * @param {string} taskId
+ * @returns {Promise<void>}
+ */
+/**
+ * Wait for an task session to be resumed with timeout protection
+ * @param {string} taskId
+ * @param {number} timeoutMs - Maximum wait time (default: 30 minutes)
+ * @returns {Promise<void>}
+ * @throws {Error} If timeout is reached
+ */
+async function waitForResume(taskId, timeoutMs = WAIT_FOR_RESUME_TIMEOUT_MS) {
+  return new Promise((resolve, reject) => {
+    const startTime = Date.now();
+
+    const checkInterval = setInterval(() => {
+      const session = taskSessions.get(taskId);
+
+      // Check for timeout
+      if (Date.now() - startTime > timeoutMs) {
+        clearInterval(checkInterval);
+        console.log(`[task] Session ${taskId} resume timeout after ${timeoutMs}ms`);
+
+        // Mark session as stopped due to timeout
+        if (session) {
+          session.status = 'stopped';
+          session.updated_at = Date.now();
+
+          // Remove lock file on timeout
+          removeTaskLock(taskId);
+        }
+
+        reject(new Error(`Resume timeout after ${timeoutMs}ms`));
+        return;
+      }
+
+      // Check if session no longer paused
+      if (!session || session.status !== 'paused') {
+        clearInterval(checkInterval);
+        resolve();
+      }
+    }, POLLING_INTERVAL_MS);
+  });
+}
+
+/**
+ * Atomically get and clear pending_question from a session
+ * Prevents race conditions where the message could be modified between read and clear
+ * @param {string} taskId
+ * @returns {string|null} The pending question, or null if none exists
+ */
+function atomicGetAndClearMessage(taskId) {
+  const session = taskSessions.get(taskId);
+  if (!session) {
+    return null;
+  }
+
+  const message = session.pending_question;
+  session.pending_question = null;
+  return message;
+}
+
+/**
+ * Stop an task task
+ *
+ * @param {string} taskId - Task session ID
+ * @returns {{ success: boolean, reason?: string }}
+ */
+export function stopTask(taskId) {
+  const session = taskSessions.get(taskId);
+  if (!session) {
+    return { success: false, reason: 'Session not found' };
+  }
+
+  // Kill running process if any
+  const proc = runningProcesses.get(taskId);
+  if (proc) {
+    proc.kill('SIGTERM');
+    runningProcesses.delete(taskId);
+    console.log(`[task] Killed process for ${taskId}`);
+  }
+
+  session.status = 'stopped';
+  session.updated_at = Date.now();
+
+  // Remove lock file
+  removeTaskLock(taskId);
+
+  return { success: true };
+}
+
+/**
+ * Stop all active task tasks and kill their processes
+ */
+export function stopAllTasks() {
+  console.log(`[task] Stopping all tasks (${runningProcesses.size} processes active)`);
+  
+  for (const [id, proc] of runningProcesses) {
+    try {
+      let killTimer = null;
+
+      // 1. Setup exit handler FIRST to ensure we catch early exits
+      proc.once('exit', () => {
+        if (killTimer) {
+          clearTimeout(killTimer);
+          killTimer = null;
+        }
+      });
+
+      // 2. Try graceful SIGTERM
+      proc.kill('SIGTERM');
+      
+      // 3. Setup watchdog timer
+      killTimer = setTimeout(() => {
+        try {
+          if (proc.exitCode === null) {
+            proc.kill('SIGKILL');
+            console.log(`[task] Force killed task ${id} (no SIGTERM response)`);
+          }
+        } catch (e) {}
+      }, SIGTERM_TIMEOUT_MS);
+      
+      console.log(`[task] Signal sent to task ${id}`);
+      
+      // Remove lock file
+      removeTaskLock(id);
+    } catch (err) {
+      console.error(`[task] Failed to send signal to task ${id}:`, err.message);
+    }
+  }
+  
+  // Clear the map after signals are sent
+  runningProcesses.clear();
+  
+  for (const session of taskSessions.values()) {
+    if (session.status === 'running' || session.status === 'paused' || session.status === 'budget_paused') {
+      session.status = 'stopped';
+      session.updated_at = Date.now();
+    }
+  }
+}
+
+/**
+ * Pause an task task
+ *
+ * @param {string} taskId - Task session ID
+ * @returns {{ success: boolean, reason?: string }}
+ */
+export function pauseTask(taskId) {
+  const session = taskSessions.get(taskId);
+  if (!session) {
+    return { success: false, reason: 'Session not found' };
+  }
+
+  if (session.status !== 'running') {
+    return { success: false, reason: `Cannot pause session in ${session.status} status` };
+  }
+
+  session.status = 'paused';
+  session.updated_at = Date.now();
+
+  return { success: true };
+}
+
+/**
+ * Resume a paused task task
+ *
+ * @param {string} taskId - Task session ID
+ * @param {Function} [onEvent] - Event callback
+ * @returns {{ success: boolean, reason?: string }}
+ */
+export function resumeTask(taskId, onEvent) {
+  const session = taskSessions.get(taskId);
+  if (!session) {
+    return { success: false, reason: 'Session not found' };
+  }
+
+  if (session.status !== 'paused' && session.status !== 'budget_paused') {
+    return { success: false, reason: `Cannot resume session in ${session.status} status` };
+  }
+
+  session.status = 'running';
+  session.updated_at = Date.now();
+
+  // Restart execution loop
+  executeTaskLoop(taskId, onEvent).catch(err => {
+    console.error(`[task] Resume loop error for ${taskId}:`, err.message);
+  });
+
+  return { success: true };
+}
+
+/**
+ * Answer a question for an task task
+ *
+ * @param {string} taskId - Task session ID
+ * @param {string} answer - User's answer to the question
+ * @param {Function} [onEvent] - Event callback
+ * @returns {{ success: boolean, reason?: string }}
+ */
+export async function answerTaskQuestion(taskId, answer, onEvent) {
+  const session = taskSessions.get(taskId);
+  if (!session) {
+    return { success: false, reason: 'Session not found' };
+  }
+
+  if (session.status !== 'waiting_input' && session.status !== 'paused') {
+    return { success: false, reason: `Cannot send message in ${session.status} status` };
+  }
+
+  // Emit user input event
+  if (onEvent) {
+    onEvent({
+      type: 'task_user_input',
+      source: 'autonomous_task',
+      task_id: taskId,
+      question: session.pending_question,
+      answer,
+      timestamp: Date.now(),
+    });
+  }
+
+  // Handle based on current status
+  if (session.status === 'paused') {
+    // Task is paused waiting for user message (auto_continue disabled)
+    // Set the message as pending_question and resume the execution loop
+    session.pending_question = answer;
+    session.status = 'running';
+    session.updated_at = Date.now();
+
+    // The execution loop will pick up the pending_question and use it as the prompt
+    return { success: true };
+  } else {
+    // Task is waiting_input (Claude asked a question)
+    // Execute immediately with the user's answer
+    session.pending_question = null;
+    session.status = 'running';
+    session.updated_at = Date.now();
+
+    const remainingBudget = session.budget_usd - session.cost_usd;
+
+    try {
+      session.turn_count++;
+      const result = await executeClaudeHeadless({
+        prompt: answer,
+        cwd: session.cwd,
+        resumeSessionId: session.claude_session_id,
+        budgetUsd: remainingBudget,
+        taskId,
+        parentSessionId: session.teleportation_session_id,
+      });
+
+      // Update session
+      session.claude_session_id = result.session_id || session.claude_session_id;
+      session.cost_usd += result.cost_usd || 0;
+      session.updated_at = Date.now();
+
+      // Add to history
+      session.history.push({
+        turn: session.turn_count,
+        prompt: `[User Answer] ${answer}`,
+        output: result.output?.slice(0, 2000),
+        cost_usd: result.cost_usd,
+        success: result.success,
+        timestamp: Date.now(),
+      });
+
+      // Resume the execution loop
+      executeTaskLoop(taskId, onEvent).catch(err => {
+        console.error(`[task] Answer loop error for ${taskId}:`, err.message);
+      });
+
+      return { success: true };
+    } catch (error) {
+      session.status = 'stopped';
+      session.updated_at = Date.now();
+      return { success: false, reason: error.message };
+    }
+  }
+}
+
+/**
+ * Get task session status
+ *
+ * @param {string} taskId - Task session ID
+ * @returns {TaskSession|null}
+ */
+export function getTaskSession(taskId) {
+  return taskSessions.get(taskId) || null;
+}
+
+/**
+ * List all task sessions for a teleportation session
+ *
+ * @param {string} session_id - Teleportation session ID
+ * @returns {TaskSession[]}
+ */
+export function listTaskSessions(session_id) {
+  const sessions = [];
+  for (const [, session] of taskSessions) {
+    if (session.teleportation_session_id === session_id) {
+      sessions.push(session);
+    }
+  }
+  return sessions;
+}
+
+/**
+ * Increase budget for an task task
+ *
+ * @param {string} taskId - Task session ID
+ * @param {number} additionalBudget - Additional budget in USD
+ * @returns {{ success: boolean, new_budget?: number, reason?: string }}
+ */
+export function increaseBudget(taskId, additionalBudget) {
+  const session = taskSessions.get(taskId);
+  if (!session) {
+    return { success: false, reason: 'Session not found' };
+  }
+
+  if (additionalBudget <= 0) {
+    return { success: false, reason: 'Additional budget must be positive' };
+  }
+
+  session.budget_usd += additionalBudget;
+  session.updated_at = Date.now();
+
+  return { success: true, new_budget: session.budget_usd };
+}
+
+// Export for testing
+export const __test = {
+  taskSessions,
+  runningProcesses,
+  executeClaudeHeadless,
+  executeTaskLoop,
+  generateTaskId,
+};