tuna-agent 0.1.0

package/dist/executor/task-runner.js

@@ -0,0 +1,638 @@
+import path from 'path';
+import os from 'os';
+import { spawn } from 'child_process';
+import { runClaude } from '../utils/claude-cli.js';
+import { validatePath } from '../utils/validate-path.js';
+const NEEDS_INPUT_MARKER = '"status":"NEEDS_INPUT"';
+// ===== Single-session execution (original runTask for agent_team / direct mode) =====
+/**
+ * Execute a task by spawning a single Claude CLI session.
+ * Used for agent_team mode or tasks that don't need planning.
+ */
+export async function runTask(task, onProgress, signal, confirmBeforeEdit) {
+    const isAgentTeam = task.mode === 'agent_team';
+    const allowedTools = ['Read', 'Edit', 'Write', 'Bash', 'Glob', 'Grep'];
+    const args = [
+        '-p', task.description,
+        '--output-format', 'stream-json',
+        '--verbose',
+        '--allowedTools', allowedTools.join(','),
+        '--max-turns', isAgentTeam ? '50' : '30',
+    ];
+    if (confirmBeforeEdit) {
+        args.push('--permission-mode', 'default');
+    }
+    else {
+        args.push('--permission-mode', 'bypassPermissions');
+    }
+    const env = {
+        ...process.env,
+        HOME: process.env.HOME || '',
+        PATH: process.env.PATH || '/usr/local/bin:/usr/bin:/bin',
+    };
+    if (isAgentTeam) {
+        env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS = '1';
+        env.CLAUDE_CODE_TEAMMATE_MODE = 'in-process';
+    }
+    onProgress('status_change', { status: 'executing' });
+    if (isAgentTeam) {
+        onProgress('plan_ready', {
+            summary: 'Agent Team mode — Claude will create and coordinate the team',
+            subtaskCount: 1,
+        });
+    }
+    const subtaskId = isAgentTeam ? 'agent-team-main' : 'main';
+    onProgress('subtask_start', { subtaskId });
+    const defaultWorkspace = path.join(os.homedir(), 'tuna-workspace');
+    const repoPath = task.repoPath || defaultWorkspace;
+    // Validate repoPath stays within home directory
+    validatePath(repoPath, os.homedir());
+    const TASK_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
+    return new Promise((resolve, reject) => {
+        const proc = spawn('claude', args, {
+            cwd: repoPath,
+            stdio: [confirmBeforeEdit ? 'pipe' : 'ignore', 'pipe', 'pipe'],
+            env,
+        });
+        // Kill process if it exceeds timeout
+        const timeoutTimer = setTimeout(() => {
+            console.error(`[Executor] Task timed out after 30 minutes, killing process`);
+            proc.kill('SIGTERM');
+            setTimeout(() => {
+                if (!proc.killed)
+                    proc.kill('SIGKILL');
+            }, 5000);
+        }, TASK_TIMEOUT_MS);
+        // Abort signal — kill process when task is cancelled
+        if (signal) {
+            const onAbort = () => {
+                console.log('[Executor] Task cancelled — killing process');
+                proc.kill('SIGTERM');
+                setTimeout(() => { if (!proc.killed)
+                    proc.kill('SIGKILL'); }, 5000);
+            };
+            if (signal.aborted) {
+                onAbort();
+            }
+            else {
+                signal.addEventListener('abort', onAbort, { once: true });
+                proc.on('close', () => signal.removeEventListener('abort', onAbort));
+            }
+        }
+        let stdout = '';
+        let stderr = '';
+        let buffer = '';
+        proc.stdout.on('data', (chunk) => {
+            const text = chunk.toString();
+            stdout += text;
+            buffer += text;
+            const lines = buffer.split('\n');
+            buffer = lines.pop() ?? '';
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const data = JSON.parse(line);
+                    _handleStreamEvent(data, subtaskId, onProgress);
+                }
+                catch {
+                    // skip non-JSON lines
+                }
+            }
+        });
+        proc.stderr.on('data', (chunk) => {
+            stderr += chunk.toString();
+        });
+        proc.on('close', (code) => {
+            clearTimeout(timeoutTimer);
+            if (buffer.trim()) {
+                try {
+                    const data = JSON.parse(buffer);
+                    _handleStreamEvent(data, subtaskId, onProgress);
+                }
+                catch { /* skip */ }
+            }
+            if (code !== 0 && !stdout.trim()) {
+                const isTimeout = code === null || code === 143; // SIGTERM
+                const errMsg = isTimeout
+                    ? 'Task timed out after 30 minutes'
+                    : `claude exited with code ${code}: ${stderr}`;
+                reject(new Error(errMsg));
+                return;
+            }
+            const lines = stdout.trim().split('\n');
+            for (let i = lines.length - 1; i >= 0; i--) {
+                try {
+                    const data = JSON.parse(lines[i]);
+                    if (data.type === 'result') {
+                        resolve({
+                            result: data.result ?? '',
+                            sessionId: data.session_id,
+                            costUsd: data.cost_usd,
+                            durationMs: data.duration_ms,
+                            isError: data.is_error ?? data.subtype !== 'success',
+                        });
+                        return;
+                    }
+                }
+                catch { /* skip */ }
+            }
+            resolve({
+                result: stdout.trim().slice(-500),
+                isError: code !== 0,
+            });
+        });
+        proc.on('error', (err) => {
+            clearTimeout(timeoutTimer);
+            reject(new Error(`Failed to spawn claude: ${err.message}`));
+        });
+    });
+}
+function _handleStreamEvent(data, subtaskId, onProgress) {
+    const type = data.type;
+    switch (type) {
+        case 'assistant':
+            if (data.message) {
+                const message = data.message;
+                const content = message.content;
+                if (Array.isArray(content)) {
+                    for (const block of content) {
+                        if (block.type === 'text' && block.text) {
+                            onProgress('subtask_log', {
+                                subtaskId,
+                                log: { type: 'thinking', message: block.text.slice(0, 200) },
+                            });
+                        }
+                        else if (block.type === 'tool_use') {
+                            onProgress('subtask_log', {
+                                subtaskId,
+                                log: { type: 'tool_start', message: `Using tool: ${block.name}` },
+                            });
+                        }
+                    }
+                }
+            }
+            break;
+        case 'tool': {
+            const content = data.content;
+            if (content?.[0]?.text) {
+                const text = content[0].text.slice(0, 200);
+                onProgress('subtask_log', {
+                    subtaskId,
+                    log: { type: 'tool_end', message: text },
+                });
+            }
+            break;
+        }
+        case 'result':
+            break;
+    }
+}
+// ===== Planner-based execution (subtasks, layers, parallel) =====
+function log(info, type, message) {
+    const entry = { timestamp: new Date(), type, message };
+    info.logs.push(entry);
+    console.log(`[Executor:${info.subtaskId}] ${message}`);
+}
+function buildSessionPrompt(subtask, contracts) {
+    let prompt = `You are a ${subtask.role} developer working on this specific task. Focus only on your assigned work. Be concise and efficient.`;
+    if (contracts?.length) {
+        prompt += `\n\nAPI CONTRACTS (defined by PM — follow these exactly):\n`;
+        for (const c of contracts) {
+            prompt += `\n${c.method} ${c.path}`;
+            if (c.description)
+                prompt += ` — ${c.description}`;
+            if (c.headers)
+                prompt += `\n  Headers: ${JSON.stringify(c.headers)}`;
+            if (c.body)
+                prompt += `\n  Request body: ${JSON.stringify(c.body)}`;
+            if (c.response)
+                prompt += `\n  Response: ${JSON.stringify(c.response)}`;
+        }
+    }
+    prompt += `\n\nCRITICAL: You are running in HEADLESS mode. There is NO interactive terminal. The AskUserQuestion tool does NOT exist here. NEVER use AskUserQuestion.
+
+CRITICAL — If you need information from the user/PM to proceed:
+You MUST follow this EXACT procedure — no exceptions:
+Step 1: Use the Write tool to create file ".tuna/question.json" with content:
+  {"question": "your question here", "options": ["Option A", "Option B"], "context": "why you need this"}
+Step 2: Your FINAL output must be EXACTLY this JSON and nothing else:
+  {"status":"NEEDS_INPUT"}
+
+WARNING: If you just write questions as text output without following the above procedure, your questions will be IGNORED and nobody will ever see them. The ONLY way to ask the user is through the .tuna/question.json + NEEDS_INPUT procedure above.
+
+When to use NEEDS_INPUT:
+- Missing credentials, tokens, URLs that you cannot find in the codebase
+- Business logic decisions the user must decide
+- Ambiguous requirements where guessing could waste effort
+
+When NOT to use NEEDS_INPUT (decide yourself):
+- Technical decisions (library choice, patterns, file structure)
+- Anything with a clear best-practice answer
+- Status updates or acknowledgements`;
+    return prompt;
+}
+/**
+ * Format tool usage into user-friendly curated message.
+ */
+function formatCuratedMessage(toolName, toolInput) {
+    const filePath = toolInput?.file_path;
+    const fileName = filePath ? path.basename(filePath) : '';
+    switch (toolName) {
+        case 'Read':
+            return fileName ? `📖 Reading ${fileName}` : '📖 Reading file';
+        case 'Write':
+            return fileName ? `✍️ Created ${fileName}` : '✍️ Created new file';
+        case 'Edit':
+            return fileName ? `✏️ Modified ${fileName}` : '✏️ Modified file';
+        case 'Bash': {
+            const cmd = toolInput?.command;
+            if (!cmd)
+                return '⚙️ Running command';
+            // Extract meaningful command info
+            if (cmd.includes('npm test') || cmd.includes('jest') || cmd.includes('pytest')) {
+                return '🧪 Running tests';
+            }
+            if (cmd.includes('npm install') || cmd.includes('yarn add') || cmd.includes('pip install')) {
+                return '📦 Installing dependencies';
+            }
+            if (cmd.includes('npm run build') || cmd.includes('yarn build')) {
+                return '🔨 Building project';
+            }
+            if (cmd.includes('git commit')) {
+                return '💾 Committing changes';
+            }
+            if (cmd.includes('git push')) {
+                return '🚀 Pushing to remote';
+            }
+            // Generic command
+            return `⚙️ Running: ${cmd.split(' ')[0]}`;
+        }
+        case 'Glob':
+            return '🔍 Searching files';
+        case 'Grep':
+            return '🔍 Searching code';
+        default:
+            return null;
+    }
+}
+function createStreamHandler(info, subtask, callbacks) {
+    return (data) => {
+        if (data.type === 'assistant' && data.message) {
+            const msg = data.message;
+            const content = msg.content;
+            if (content) {
+                for (const block of content) {
+                    if (block.type === 'tool_use') {
+                        const toolName = block.name;
+                        const toolInput = block.input;
+                        // Format curated message for user
+                        const curatedMsg = formatCuratedMessage(toolName, toolInput || {});
+                        if (curatedMsg) {
+                            callbacks?.onSubtaskLog?.(subtask.id, { type: 'action', message: curatedMsg });
+                        }
+                        // Still log verbose version to console for debugging
+                        const detail = toolInput?.file_path || toolInput?.command || toolInput?.pattern || '';
+                        console.log(`    [tool] ${toolName}: ${String(detail).substring(0, 80)}`);
+                    }
+                    // Skip verbose thinking blocks - not useful for end users
+                }
+            }
+        }
+        if (data.type === 'system' && data.subtype === 'init') {
+            info.sessionId = data.session_id;
+            log(info, 'thinking', `Session ID: ${info.sessionId}`);
+        }
+    };
+}
+/**
+ * Execute a single subtask by spawning a Claude CLI session.
+ */
+export async function executeSubtask(subtask, repoPath, contracts, callbacks, signal, confirmBeforeEdit) {
+    const info = {
+        subtaskId: subtask.id,
+        status: 'running',
+        logs: [],
+    };
+    // Validate subtask cwd stays within the repo path
+    const cwd = validatePath(subtask.cwd, repoPath);
+    log(info, 'thinking', `Starting ${subtask.role} session (cwd: ${cwd})`);
+    await callbacks?.onSubtaskStart?.(subtask.id);
+    // Send curated status message
+    callbacks?.onSubtaskLog?.(subtask.id, {
+        type: 'info',
+        message: `🚀 Started: ${subtask.description.substring(0, 80)}${subtask.description.length > 80 ? '...' : ''}`,
+    });
+    try {
+        const result = await runClaude({
+            prompt: subtask.description,
+            cwd,
+            allowedTools: ['Read', 'Edit', 'Write', 'Bash', 'Glob', 'Grep'],
+            disallowedTools: ['AskUserQuestion'],
+            systemPrompt: buildSessionPrompt(subtask, contracts),
+            outputFormat: 'stream-json',
+            onStreamLine: createStreamHandler(info, subtask, callbacks),
+            signal,
+            ...(confirmBeforeEdit ? {
+                permissionMode: 'default',
+                onPermissionRequest: callbacks?.onPermissionRequest
+                    ? (tool, detail) => callbacks.onPermissionRequest(subtask.id, tool, detail)
+                    : undefined,
+            } : {}),
+        });
+        info.costUsd = result.costUsd;
+        info.durationMs = result.durationMs;
+        info.sessionId = result.sessionId ?? info.sessionId;
+        if (result.result.includes(NEEDS_INPUT_MARKER)) {
+            info.status = 'waiting_input';
+            let question = await readQuestionFile(cwd, subtask.id);
+            // Fallback: If no question.json, try to parse question from output
+            if (!question) {
+                question = parseQuestionFromOutput(result.result, subtask.id);
+            }
+            if (question) {
+                info.pendingQuestion = question;
+                log(info, 'thinking', `Needs input: ${question.question}`);
+                if (callbacks?.onSubtaskNeedsInput) {
+                    const answer = await callbacks.onSubtaskNeedsInput(subtask.id, question);
+                    if (answer) {
+                        log(info, 'thinking', `Resuming with answer: ${answer.substring(0, 80)}`);
+                        callbacks?.onSubtaskLog?.(subtask.id, {
+                            type: 'info',
+                            message: `💬 Received answer, resuming work...`,
+                        });
+                        const resumeResult = await runClaude({
+                            prompt: `The answer to your question "${question.question}" is: ${answer}\n\nContinue your work with this information.`,
+                            cwd,
+                            allowedTools: ['Read', 'Edit', 'Write', 'Bash', 'Glob', 'Grep'],
+                            disallowedTools: ['AskUserQuestion'],
+                            resumeSessionId: info.sessionId,
+                            outputFormat: 'stream-json',
+                            onStreamLine: createStreamHandler(info, subtask, callbacks),
+                            signal,
+                            ...(confirmBeforeEdit ? {
+                                permissionMode: 'default',
+                                onPermissionRequest: callbacks?.onPermissionRequest
+                                    ? (tool, detail) => callbacks.onPermissionRequest(subtask.id, tool, detail)
+                                    : undefined,
+                            } : {}),
+                        });
+                        info.costUsd = (info.costUsd ?? 0) + (resumeResult.costUsd ?? 0);
+                        info.durationMs = (info.durationMs ?? 0) + (resumeResult.durationMs ?? 0);
+                        info.pendingQuestion = undefined;
+                        if (resumeResult.isError) {
+                            info.status = 'failed';
+                            info.result = resumeResult.result;
+                            log(info, 'error', `Failed after resume: ${resumeResult.result.substring(0, 200)}`);
+                            callbacks?.onSubtaskLog?.(subtask.id, {
+                                type: 'error',
+                                message: `❌ Failed after resume: ${resumeResult.result.substring(0, 100)}`,
+                            });
+                        }
+                        else {
+                            info.status = 'done';
+                            info.result = resumeResult.result;
+                            const costStr = info.costUsd != null ? `$${info.costUsd.toFixed(4)}` : 'N/A';
+                            const durationStr = info.durationMs != null ? `${(info.durationMs / 1000).toFixed(1)}s` : 'N/A';
+                            log(info, 'result', `Done in ${durationStr}, cost: ${costStr} (resumed)`);
+                            callbacks?.onSubtaskLog?.(subtask.id, {
+                                type: 'success',
+                                message: `✅ Completed successfully in ${durationStr}`,
+                            });
+                        }
+                    }
+                    else {
+                        log(info, 'thinking', 'No answer received — task paused');
+                    }
+                }
+            }
+            else {
+                info.status = 'failed';
+                info.result = 'Session requested input but no question file found';
+                log(info, 'error', 'NEEDS_INPUT but no .tuna/question.json found');
+                callbacks?.onSubtaskLog?.(subtask.id, {
+                    type: 'error',
+                    message: '❌ Failed: AI requested input but question format was invalid',
+                });
+            }
+        }
+        else if (result.isError) {
+            info.status = 'failed';
+            info.result = result.result;
+            log(info, 'error', `Failed: ${result.result.substring(0, 200)}`);
+            // Send curated error message
+            callbacks?.onSubtaskLog?.(subtask.id, {
+                type: 'error',
+                message: `❌ Failed: ${result.result.substring(0, 100)}${result.result.length > 100 ? '...' : ''}`,
+            });
+        }
+        else {
+            // Fallback: detect if AI just wrote questions as text without using NEEDS_INPUT
+            // Only trigger for very short outputs (< 500 chars) that completed quickly (< 15s)
+            // This avoids false positives when a completed task output contains sentences with "?"
+            const isShortOutput = result.result.length < 500;
+            const isQuickRun = result.durationMs != null && result.durationMs < 15000;
+            const fallbackQuestion = (isShortOutput && isQuickRun)
+                ? parseQuestionFromOutput(result.result, subtask.id)
+                : null;
+            const seemsLikeQuestion = !!fallbackQuestion;
+            if (seemsLikeQuestion && fallbackQuestion && callbacks?.onSubtaskNeedsInput) {
+                info.status = 'waiting_input';
+                info.pendingQuestion = fallbackQuestion;
+                log(info, 'thinking', `Fallback: detected question in output (no NEEDS_INPUT marker): ${fallbackQuestion.question}`);
+                const answer = await callbacks.onSubtaskNeedsInput(subtask.id, fallbackQuestion);
+                if (answer) {
+                    log(info, 'thinking', `Resuming with answer: ${answer.substring(0, 80)}`);
+                    callbacks?.onSubtaskLog?.(subtask.id, {
+                        type: 'info',
+                        message: `💬 Received answer, resuming work...`,
+                    });
+                    const resumeResult = await runClaude({
+                        prompt: `The answer to your question "${fallbackQuestion.question}" is: ${answer}\n\nContinue your work with this information.`,
+                        cwd,
+                        allowedTools: ['Read', 'Edit', 'Write', 'Bash', 'Glob', 'Grep'],
+                        disallowedTools: ['AskUserQuestion'],
+                        resumeSessionId: info.sessionId,
+                        outputFormat: 'stream-json',
+                        onStreamLine: createStreamHandler(info, subtask, callbacks),
+                        signal,
+                        ...(confirmBeforeEdit ? {
+                            permissionMode: 'default',
+                            onPermissionRequest: callbacks?.onPermissionRequest
+                                ? (tool, detail) => callbacks.onPermissionRequest(subtask.id, tool, detail)
+                                : undefined,
+                        } : {}),
+                    });
+                    info.costUsd = (info.costUsd ?? 0) + (resumeResult.costUsd ?? 0);
+                    info.durationMs = (info.durationMs ?? 0) + (resumeResult.durationMs ?? 0);
+                    info.pendingQuestion = undefined;
+                    if (resumeResult.isError) {
+                        info.status = 'failed';
+                        info.result = resumeResult.result;
+                        log(info, 'error', `Failed after resume: ${resumeResult.result.substring(0, 200)}`);
+                    }
+                    else {
+                        info.status = 'done';
+                        info.result = resumeResult.result;
+                        const costStr = info.costUsd != null ? `$${info.costUsd.toFixed(4)}` : 'N/A';
+                        const durationStr = info.durationMs != null ? `${(info.durationMs / 1000).toFixed(1)}s` : 'N/A';
+                        log(info, 'result', `Done in ${durationStr}, cost: ${costStr} (resumed from fallback)`);
+                        callbacks?.onSubtaskLog?.(subtask.id, {
+                            type: 'success',
+                            message: `✅ Completed successfully in ${durationStr}`,
+                        });
+                    }
+                }
+                else {
+                    log(info, 'thinking', 'No answer received — task paused');
+                }
+            }
+            else {
+                info.status = 'done';
+                info.result = result.result;
+                const costStr = result.costUsd != null ? `$${result.costUsd.toFixed(4)}` : 'N/A';
+                const durationStr = result.durationMs != null ? `${(result.durationMs / 1000).toFixed(1)}s` : 'N/A';
+                log(info, 'result', `Done in ${durationStr}, cost: ${costStr}`);
+                // Send curated success message
+                callbacks?.onSubtaskLog?.(subtask.id, {
+                    type: 'success',
+                    message: `✅ Completed successfully in ${durationStr}`,
+                });
+            }
+        }
+    }
+    catch (err) {
+        info.status = 'failed';
+        const errMsg = err instanceof Error ? err.message : String(err);
+        log(info, 'error', `Exception: ${errMsg}`);
+        // Send curated error message
+        callbacks?.onSubtaskLog?.(subtask.id, {
+            type: 'error',
+            message: `❌ Error: ${errMsg}`,
+        });
+    }
+    await callbacks?.onSubtaskDone?.(subtask.id, {
+        status: info.status,
+        result: info.result,
+        costUsd: info.costUsd,
+        durationMs: info.durationMs,
+        sessionId: info.sessionId,
+    });
+    return info;
+}
+/**
+ * Build execution layers from subtask dependencies.
+ * Subtasks with all dependencies met run in the same layer (parallel).
+ */
+export function buildExecutionLayers(subtasks) {
+    const layers = [];
+    const completed = new Set();
+    let remaining = [...subtasks];
+    while (remaining.length > 0) {
+        const layer = remaining.filter((s) => s.dependencies.every((dep) => completed.has(dep)));
+        if (layer.length === 0) {
+            console.warn('[Executor] Warning: unresolvable dependencies, forcing execution');
+            layers.push(remaining);
+            break;
+        }
+        layers.push(layer);
+        for (const s of layer)
+            completed.add(s.id);
+        remaining = remaining.filter((s) => !completed.has(s.id));
+    }
+    return layers;
+}
+/**
+ * Execute a full task plan: run subtasks layer by layer, parallel within each layer.
+ * Returns all session results.
+ */
+export async function executeTaskWithPlan(task, plan, onProgress, callbacks, signal, confirmBeforeEdit) {
+    const allSessions = [];
+    console.log(`\n[Executor] Starting task: ${task.description}`);
+    console.log(`[Executor] Subtasks: ${plan.subtasks.length}`);
+    if (plan.contracts?.length) {
+        console.log(`[Executor] Contracts: ${plan.contracts.length} endpoint(s)`);
+    }
+    const layers = buildExecutionLayers(plan.subtasks);
+    for (let i = 0; i < layers.length; i++) {
+        const layer = layers[i];
+        console.log(`\n[Executor] === Layer ${i + 1}/${layers.length}: ${layer.length} subtask(s) in parallel ===`);
+        await callbacks?.onLayerStart?.(i, layers.length, layer.map((s) => s.id));
+        const results = await Promise.all(layer.map((subtask) => executeSubtask(subtask, task.repoPath, plan.contracts, callbacks, signal, confirmBeforeEdit)));
+        allSessions.push(...results);
+        const failed = results.filter((r) => r.status === 'failed');
+        if (failed.length > 0) {
+            console.log(`\n[Executor] ${failed.length} subtask(s) failed in layer ${i + 1}`);
+            return { sessions: allSessions, status: 'failed' };
+        }
+        const waiting = results.filter((r) => r.status === 'waiting_input');
+        if (waiting.length > 0) {
+            console.log(`\n[Executor] ${waiting.length} subtask(s) waiting for input in layer ${i + 1}`);
+            return { sessions: allSessions, status: 'waiting_input' };
+        }
+        for (const result of results) {
+            const subtask = plan.subtasks.find((s) => s.id === result.subtaskId);
+            if (subtask)
+                subtask.status = 'done';
+        }
+    }
+    const totalCost = allSessions.reduce((sum, s) => sum + (s.costUsd ?? 0), 0);
+    const totalTime = allSessions.reduce((sum, s) => sum + (s.durationMs ?? 0), 0);
+    console.log(`\n[Executor] Task complete!`);
+    console.log(`[Executor] Total cost: $${totalCost.toFixed(4)}`);
+    console.log(`[Executor] Total time: ${(totalTime / 1000).toFixed(1)}s`);
+    return { sessions: allSessions, status: 'done' };
+}
+/**
+ * Parse question from Claude output when question.json is missing.
+ * Fallback for when Claude outputs NEEDS_INPUT but didn't create the file.
+ */
+function parseQuestionFromOutput(output, subtaskId) {
+    try {
+        // Strip code blocks to avoid matching `?` inside code/comments
+        const withoutCode = output
+            .replace(/```[\s\S]*?```/g, '')
+            .replace(/`[^`]+`/g, '');
+        const cleanLines = withoutCode.split('\n');
+        // Look for standalone sentences ending with `?` (not inside code)
+        for (let i = cleanLines.length - 1; i >= Math.max(0, cleanLines.length - 20); i--) {
+            const line = cleanLines[i].trim();
+            // Must be a real sentence ending with `?`, at least 10 chars to avoid false positives
+            if (line.endsWith('?') && line.length >= 10) {
+                return {
+                    subtaskId,
+                    question: line,
+                    options: undefined,
+                    context: 'AI requested input during execution',
+                };
+            }
+        }
+        // No question found — return null instead of a generic fallback
+        // This will cause the caller to treat it as an error (NEEDS_INPUT without valid question)
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Read .tuna/question.json from workspace directory.
+ */
+async function readQuestionFile(cwd, subtaskId) {
+    try {
+        const fs = await import('fs/promises');
+        const filePath = path.join(cwd, '.tuna', 'question.json');
+        const raw = await fs.readFile(filePath, 'utf-8');
+        const data = JSON.parse(raw);
+        await fs.unlink(filePath).catch(() => { });
+        return {
+            subtaskId,
+            question: data.question,
+            options: data.options,
+            context: data.context,
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/pm/planner.d.ts

@@ -0,0 +1,20 @@
+import type { TaskAssignment, TaskPlan, PlanResult, ProgressCallback } from '../types/index.js';
+/**
+ * Plan a task by spawning a PM Claude session.
+ * PM reads the project, analyzes the task, and creates a structured plan.
+ */
+export declare function planTask(task: TaskAssignment, onProgress: ProgressCallback, signal?: AbortSignal, onTextChunk?: (text: string) => void, inputFiles?: string[]): Promise<PlanResult>;
+/**
+ * Chat with PM directly (resume session). PM answers conversationally
+ * OR switches to planning mode if user gives a code task.
+ * Returns { response, plan? } — plan is set only if PM outputs JSON plan.
+ */
+export declare function chatWithPM(pmSessionId: string, repoPath: string, userMessage: string, signal?: AbortSignal, onTextChunk?: (text: string) => void, inputFiles?: string[]): Promise<{
+    response: string;
+    plan?: TaskPlan;
+    sessionId?: string;
+}>;
+/**
+ * Ask PM to answer a developer question by resuming PM session.
+ */
+export declare function askPM(pmSessionId: string, repoPath: string, question: string, context: string): Promise<string | null>;