orquesta-agent 0.2.142 → 0.2.144

package/dist/executor.js

@@ -1258,83 +1258,84 @@ export async function execute(options) {
     // orquesta-cli. Holds the upstream error text for logging.
     let claudeApiError = null;
     _activePromptId = promptId;
-    // Clear per-execution buffers for new execution (concurrent-safe)
-    outputBufferMap.delete(commandId);
-    clearDetectedRequirements(commandId);
-    clearQABuffer(commandId);
-    // Start log persistence for this execution
-    startLogPersistence(promptId);
-    addLog(promptId, 'info', 'system', `Starting execution: ${content.slice(0, 100)}...`);
-    // Native coordination fast-path: if this is a RogerThat rejoin/wake dispatch
-    // (carries an <<ORQ_COORD>> spec), run the plumbing in code + one LLM call to
-    // draft the reply, instead of making the model orchestrate curls turn-by-turn
-    // (slow + fragile on weak models). Falls through to the normal prompt path if
-    // the spec is absent or malformed.
-    const coordSpec = parseCoordSpec(content);
-    if (coordSpec) {
-        addLog(promptId, 'info', 'system', `Native coordination (${coordSpec.reason}) — channel ${coordSpec.channelId}`);
-        try {
-            // The agent token isn't in process.env — it's injected per-execution
-            // (index.ts sets ORQUESTA_TOKEN on injectedCredentials before execute()).
-            const orquestaToken = getInjectedCredentials()['ORQUESTA_TOKEN'] || process.env.ORQUESTA_TOKEN || '';
-            const summary = await runCoordination(coordSpec, orquestaToken, (line) => {
-                addLog(promptId, 'info', 'output', line);
-                sendOutput(channel, commandId, 'stdout', line + '\n').catch(() => undefined);
-            });
-            addLog(promptId, 'info', 'system', summary);
-            await sendOutput(channel, commandId, 'stdout', `\n${summary}\n`);
-            await updatePromptStatus(promptId, 'completed', { text: summary, key_actions: [], files_modified: [] });
-            await sendComplete(channel, commandId, 0, startTime);
+    try {
+        // Clear per-execution buffers for new execution (concurrent-safe)
+        outputBufferMap.delete(commandId);
+        clearDetectedRequirements(commandId);
+        clearQABuffer(commandId);
+        // Start log persistence for this execution
+        startLogPersistence(promptId);
+        addLog(promptId, 'info', 'system', `Starting execution: ${content.slice(0, 100)}...`);
+        // Native coordination fast-path: if this is a RogerThat rejoin/wake dispatch
+        // (carries an <<ORQ_COORD>> spec), run the plumbing in code + one LLM call to
+        // draft the reply, instead of making the model orchestrate curls turn-by-turn
+        // (slow + fragile on weak models). Falls through to the normal prompt path if
+        // the spec is absent or malformed.
+        const coordSpec = parseCoordSpec(content);
+        if (coordSpec) {
+            addLog(promptId, 'info', 'system', `Native coordination (${coordSpec.reason}) — channel ${coordSpec.channelId}`);
+            try {
+                // The agent token isn't in process.env — it's injected per-execution
+                // (index.ts sets ORQUESTA_TOKEN on injectedCredentials before execute()).
+                const orquestaToken = getInjectedCredentials()['ORQUESTA_TOKEN'] || process.env.ORQUESTA_TOKEN || '';
+                const summary = await runCoordination(coordSpec, orquestaToken, (line) => {
+                    addLog(promptId, 'info', 'output', line);
+                    sendOutput(channel, commandId, 'stdout', line + '\n').catch(() => undefined);
+                });
+                addLog(promptId, 'info', 'system', summary);
+                await sendOutput(channel, commandId, 'stdout', `\n${summary}\n`);
+                await updatePromptStatus(promptId, 'completed', { text: summary, key_actions: [], files_modified: [] });
+                await sendComplete(channel, commandId, 0, startTime);
+            }
+            catch (err) {
+                const msg = `Coordination failed: ${err.message}`;
+                addLog(promptId, 'error', 'error', msg);
+                await updatePromptStatus(promptId, 'failed', { text: msg, key_actions: [], files_modified: [] });
+                await sendComplete(channel, commandId, 1, startTime);
+            }
+            return;
         }
-        catch (err) {
-            const msg = `Coordination failed: ${err.message}`;
-            addLog(promptId, 'error', 'error', msg);
-            await updatePromptStatus(promptId, 'failed', { text: msg, key_actions: [], files_modified: [] });
-            await sendComplete(channel, commandId, 1, startTime);
+        logger.info(`Executing prompt: ${content.slice(0, 60)}${content.length > 60 ? '...' : ''}`);
+        logger.info(`Permission mode: ${mode}`);
+        if (attachments && attachments.length > 0) {
+            logger.info(`Attachments: ${attachments.length} file(s)`);
         }
-        return;
-    }
-    logger.info(`Executing prompt: ${content.slice(0, 60)}${content.length > 60 ? '...' : ''}`);
-    logger.info(`Permission mode: ${mode}`);
-    if (attachments && attachments.length > 0) {
-        logger.info(`Attachments: ${attachments.length} file(s)`);
-    }
-    // Process attachments if present
-    let attachmentContext = '';
-    let attachmentCleanup = null;
-    let imageReferences = [];
-    if (attachments && attachments.length > 0) {
-        try {
-            const processed = await processAttachments(attachments);
-            attachmentContext = processed.contextText;
-            attachmentCleanup = processed.cleanup;
-            imageReferences = processed.fileReferences;
-            logger.info(`Processed ${attachments.length} attachment(s)`);
+        // Process attachments if present
+        let attachmentContext = '';
+        let attachmentCleanup = null;
+        let imageReferences = [];
+        if (attachments && attachments.length > 0) {
+            try {
+                const processed = await processAttachments(attachments);
+                attachmentContext = processed.contextText;
+                attachmentCleanup = processed.cleanup;
+                imageReferences = processed.fileReferences;
+                logger.info(`Processed ${attachments.length} attachment(s)`);
+            }
+            catch (error) {
+                logger.error(`Failed to process attachments: ${error}`);
+                addLog(promptId, 'error', 'system', `Failed to process attachments: ${error}`);
+            }
         }
-        catch (error) {
-            logger.error(`Failed to process attachments: ${error}`);
-            addLog(promptId, 'error', 'system', `Failed to process attachments: ${error}`);
-        }
-    }
-    // Build full prompt with settings, agent instructions, and attachments
-    let fullContent = content + attachmentContext;
-    const settingsHeader = generateSettingsHeader();
-    const browserBlock = BROWSER_TOOLS_PROMPT_BLOCK;
-    const coordinationBlock = await fetchCoordinationContextBlock();
-    const capabilitiesBlock = `${ORQUESTA_CAPABILITIES_PROMPT_BLOCK}${coordinationBlock}`;
-    // Auto-inject any rogerthat phone messages received since the last prompt /
-    // interactive turn. Shared state with the interactive path — see
-    // readNewRogerthatMessages(). No-op when no listener is active.
-    const phoneBlock = readNewRogerthatMessages();
-    if (phoneBlock) {
-        logger.info(`Injecting ${phoneBlock.length} chars of rogerthat phone messages into prompt`);
-    }
-    const userRequestBody = phoneBlock
-        ? `${phoneBlock}\n${content}${attachmentContext}`
-        : `${content}${attachmentContext}`;
-    if (agentInstructions && agentInstructions.trim()) {
-        // Prepend settings + agent instructions to the prompt
-        fullContent = `[Orquesta Configuration]
+        // Build full prompt with settings, agent instructions, and attachments
+        let fullContent = content + attachmentContext;
+        const settingsHeader = generateSettingsHeader();
+        const browserBlock = BROWSER_TOOLS_PROMPT_BLOCK;
+        const coordinationBlock = await fetchCoordinationContextBlock();
+        const capabilitiesBlock = `${ORQUESTA_CAPABILITIES_PROMPT_BLOCK}${coordinationBlock}`;
+        // Auto-inject any rogerthat phone messages received since the last prompt /
+        // interactive turn. Shared state with the interactive path — see
+        // readNewRogerthatMessages(). No-op when no listener is active.
+        const phoneBlock = readNewRogerthatMessages();
+        if (phoneBlock) {
+            logger.info(`Injecting ${phoneBlock.length} chars of rogerthat phone messages into prompt`);
+        }
+        const userRequestBody = phoneBlock
+            ? `${phoneBlock}\n${content}${attachmentContext}`
+            : `${content}${attachmentContext}`;
+        if (agentInstructions && agentInstructions.trim()) {
+            // Prepend settings + agent instructions to the prompt
+            fullContent = `[Orquesta Configuration]
 ${settingsHeader}
 [Agent Instructions from Orquesta]
 ${agentInstructions}
@@ -1345,11 +1346,11 @@ ${browserBlock}
 
 [User Request]
 ${userRequestBody}`;
-        logger.info('Including settings and agent instructions in prompt');
-    }
-    else if (settingsHeader) {
-        // Just settings, no agent instructions
-        fullContent = `[Orquesta Configuration]
+            logger.info('Including settings and agent instructions in prompt');
+        }
+        else if (settingsHeader) {
+            // Just settings, no agent instructions
+            fullContent = `[Orquesta Configuration]
 ${settingsHeader}
 
 ${capabilitiesBlock}
@@ -1358,692 +1359,699 @@ ${browserBlock}
 
 [User Request]
 ${userRequestBody}`;
-        logger.info('Including settings in prompt');
-    }
-    else {
-        // No settings — still include capabilities + browser blocks.
-        fullContent = `${capabilitiesBlock}
+            logger.info('Including settings in prompt');
+        }
+        else {
+            // No settings — still include capabilities + browser blocks.
+            fullContent = `${capabilitiesBlock}
 
 ${browserBlock}
 
 [User Request]
 ${userRequestBody}`;
-    }
-    // Build environment with authentication
-    const env = {
-        ...process.env,
-        ...injectedCredentials, // Inject credentials from Orquesta
-        CI: 'true', // Ensure non-interactive mode
-        // Expose the current prompt id so Claude can link generated files back
-        // to this prompt via /api/agent/files (prompt_id=$ORQUESTA_PROMPT_ID).
-        ORQUESTA_PROMPT_ID: promptId,
-    };
-    // Add API key if configured (overrides injected if present)
-    if (anthropicApiKey) {
-        env.ANTHROPIC_API_KEY = anthropicApiKey;
-    }
-    // Strip Claude Code session detection env vars so the spawned claude process
-    // doesn't refuse with "nested sessions" when the agent itself runs inside a
-    // Claude Code session (local dev or systemd inherits the launching shell's env).
-    delete env.CLAUDECODE;
-    delete env.CLAUDE_CODE_ENTRYPOINT;
-    delete env.CLAUDE_CODE_VERSION;
-    delete env.CLAUDE_CODE_SESSION_ID;
-    delete env.CLAUDE_CODE_PROJECT_DIR;
-    delete env.CLAUDE_CODE_HEADLESS;
-    // Select CLI based on availability and preference. _forceCli overrides
-    // this on the claude→orquesta failure-retry path.
-    let { cli: selectedCli, reason } = selectCli();
-    if (options._forceCli && (options._forceCli === 'orquesta' ? isOrquestaCliAvailable() : isClaudeCliAvailable())) {
-        selectedCli = options._forceCli;
-        reason = `Forced: ${options._forceCli} (retry after claude failure)`;
-    }
-    if (!selectedCli) {
-        throw new Error('No CLI available. Please install either orquesta-cli or claude CLI.');
-    }
-    // Preflight check: if orquesta CLI is selected, verify its LLM endpoint works
-    // This prevents wasting time on prompts that will fail with 404s
-    if (selectedCli === 'orquesta') {
-        try {
-            const testResult = execSync('orquesta --status 2>&1 || true', { encoding: 'utf-8', timeout: 5000, env });
-            // If orquesta-cli reports no endpoint or connection issues, fall back to claude
-            if (testResult.includes('No endpoint') || testResult.includes('not configured') || testResult.includes('No LLM')) {
-                const hasClaude = isClaudeCliAvailable();
-                if (hasClaude) {
-                    logger.warn('Orquesta CLI has no LLM endpoint configured — falling back to Claude CLI');
-                    selectedCli = 'claude';
-                    reason = 'Fallback: orquesta has no LLM endpoint';
+        }
+        // Build environment with authentication
+        const env = {
+            ...process.env,
+            ...injectedCredentials, // Inject credentials from Orquesta
+            CI: 'true', // Ensure non-interactive mode
+            // Expose the current prompt id so Claude can link generated files back
+            // to this prompt via /api/agent/files (prompt_id=$ORQUESTA_PROMPT_ID).
+            ORQUESTA_PROMPT_ID: promptId,
+        };
+        // Add API key if configured (overrides injected if present)
+        if (anthropicApiKey) {
+            env.ANTHROPIC_API_KEY = anthropicApiKey;
+        }
+        // Strip Claude Code session detection env vars so the spawned claude process
+        // doesn't refuse with "nested sessions" when the agent itself runs inside a
+        // Claude Code session (local dev or systemd inherits the launching shell's env).
+        delete env.CLAUDECODE;
+        delete env.CLAUDE_CODE_ENTRYPOINT;
+        delete env.CLAUDE_CODE_VERSION;
+        delete env.CLAUDE_CODE_SESSION_ID;
+        delete env.CLAUDE_CODE_PROJECT_DIR;
+        delete env.CLAUDE_CODE_HEADLESS;
+        // Select CLI based on availability and preference. _forceCli overrides
+        // this on the claude→orquesta failure-retry path.
+        let { cli: selectedCli, reason } = selectCli();
+        if (options._forceCli && (options._forceCli === 'orquesta' ? isOrquestaCliAvailable() : isClaudeCliAvailable())) {
+            selectedCli = options._forceCli;
+            reason = `Forced: ${options._forceCli} (retry after claude failure)`;
+        }
+        if (!selectedCli) {
+            throw new Error('No CLI available. Please install either orquesta-cli or claude CLI.');
+        }
+        // Preflight check: if orquesta CLI is selected, verify its LLM endpoint works
+        // This prevents wasting time on prompts that will fail with 404s
+        if (selectedCli === 'orquesta') {
+            try {
+                const testResult = execSync('orquesta --status 2>&1 || true', { encoding: 'utf-8', timeout: 5000, env });
+                // If orquesta-cli reports no endpoint or connection issues, fall back to claude
+                if (testResult.includes('No endpoint') || testResult.includes('not configured') || testResult.includes('No LLM')) {
+                    const hasClaude = isClaudeCliAvailable();
+                    if (hasClaude) {
+                        logger.warn('Orquesta CLI has no LLM endpoint configured — falling back to Claude CLI');
+                        selectedCli = 'claude';
+                        reason = 'Fallback: orquesta has no LLM endpoint';
+                    }
                 }
             }
+            catch {
+                // --status not supported or timeout, skip check
+            }
         }
-        catch {
-            // --status not supported or timeout, skip check
+        const cliCommand = selectedCli;
+        const cwd = workingDirectory || process.cwd();
+        logger.info(`CLI Selection: ${cliCommand} (${reason})`);
+        logger.info(`Spawning: ${cliCommand} -p "${fullContent.slice(0, 50)}..." in ${cwd}`);
+        // Escape content for shell - replace single quotes
+        const escapedContent = fullContent.replace(/'/g, "'\\''");
+        // Build command based on permission mode
+        // Use stream-json format to get structured output including thinking
+        let command;
+        // Different flags for different CLIs
+        // Claude CLI supports --output-format stream-json
+        // Orquesta CLI doesn't need special format flags - it outputs directly
+        const baseFlags = cliCommand === 'orquesta'
+            ? '--verbose' // Orquesta: simple verbose output
+            : '--verbose --output-format stream-json'; // Claude: stream-json format
+        const permFlags = mode === 'auto' ? '--dangerously-skip-permissions' : '';
+        // Claude CLI's headless `-p` mode does not accept positional file args as
+        // attachments — image refs are surfaced inline in the prompt as absolute
+        // paths so Claude's Read tool can pick them up.
+        command = `${cliCommand} -p '${escapedContent}' ${permFlags} ${baseFlags}`;
+        if (imageReferences.length > 0) {
+            logger.info(`Image attachments referenced inline: ${imageReferences.length}`);
+        }
+        // Windows has no `script` binary; macOS BSD `script` requires a parent TTY
+        // (which the agent daemon doesn't have, causing tcgetattr/ioctl failure).
+        // Direct-spawn the CLI on those platforms — Claude CLI's `-p` stream-json
+        // mode doesn't need a PTY. Linux util-linux `script` works without a parent
+        // TTY, so we keep PTY wrapping there.
+        const isWindows = process.platform === 'win32';
+        const isDarwin = process.platform === 'darwin';
+        let claude;
+        if (isWindows || isDarwin) {
+            const args = [];
+            args.push('-p', fullContent);
+            if (permFlags)
+                args.push(...permFlags.split(/\s+/).filter(Boolean));
+            if (baseFlags)
+                args.push(...baseFlags.split(/\s+/).filter(Boolean));
+            claude = spawn(cliCommand, args, {
+                cwd,
+                env,
+                stdio: ['pipe', 'pipe', 'pipe'],
+                shell: isWindows, // Windows needs shell:true for .cmd shim; macOS spawns directly
+            });
         }
-    }
-    const cliCommand = selectedCli;
-    const cwd = workingDirectory || process.cwd();
-    logger.info(`CLI Selection: ${cliCommand} (${reason})`);
-    logger.info(`Spawning: ${cliCommand} -p "${fullContent.slice(0, 50)}..." in ${cwd}`);
-    // Escape content for shell - replace single quotes
-    const escapedContent = fullContent.replace(/'/g, "'\\''");
-    // Build command based on permission mode
-    // Use stream-json format to get structured output including thinking
-    let command;
-    // Different flags for different CLIs
-    // Claude CLI supports --output-format stream-json
-    // Orquesta CLI doesn't need special format flags - it outputs directly
-    const baseFlags = cliCommand === 'orquesta'
-        ? '--verbose' // Orquesta: simple verbose output
-        : '--verbose --output-format stream-json'; // Claude: stream-json format
-    const permFlags = mode === 'auto' ? '--dangerously-skip-permissions' : '';
-    // Claude CLI's headless `-p` mode does not accept positional file args as
-    // attachments — image refs are surfaced inline in the prompt as absolute
-    // paths so Claude's Read tool can pick them up.
-    command = `${cliCommand} -p '${escapedContent}' ${permFlags} ${baseFlags}`;
-    if (imageReferences.length > 0) {
-        logger.info(`Image attachments referenced inline: ${imageReferences.length}`);
-    }
-    // Windows has no `script` binary; macOS BSD `script` requires a parent TTY
-    // (which the agent daemon doesn't have, causing tcgetattr/ioctl failure).
-    // Direct-spawn the CLI on those platforms — Claude CLI's `-p` stream-json
-    // mode doesn't need a PTY. Linux util-linux `script` works without a parent
-    // TTY, so we keep PTY wrapping there.
-    const isWindows = process.platform === 'win32';
-    const isDarwin = process.platform === 'darwin';
-    let claude;
-    if (isWindows || isDarwin) {
-        const args = [];
-        args.push('-p', fullContent);
-        if (permFlags)
-            args.push(...permFlags.split(/\s+/).filter(Boolean));
-        if (baseFlags)
-            args.push(...baseFlags.split(/\s+/).filter(Boolean));
-        claude = spawn(cliCommand, args, {
-            cwd,
-            env,
-            stdio: ['pipe', 'pipe', 'pipe'],
-            shell: isWindows, // Windows needs shell:true for .cmd shim; macOS spawns directly
-        });
-    }
-    else {
-        // Sandbox wraps the `script` invocation in bwrap when active (Linux only);
-        // no-op otherwise.
-        const { file: spawnFile, args: spawnArgs } = sandboxArgv('script', scriptWrapArgs(command), cwd);
-        if (spawnFile === 'bwrap') {
-            logger.info(`Sandbox active — confining writes to ${cwd}`);
+        else {
+            // Sandbox wraps the `script` invocation in bwrap when active (Linux only);
+            // no-op otherwise.
+            const { file: spawnFile, args: spawnArgs } = sandboxArgv('script', scriptWrapArgs(command), cwd);
+            if (spawnFile === 'bwrap') {
+                logger.info(`Sandbox active — confining writes to ${cwd}`);
+            }
+            claude = spawn(spawnFile, spawnArgs, {
+                cwd,
+                env: sandboxEnv(env),
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
         }
-        claude = spawn(spawnFile, spawnArgs, {
-            cwd,
-            env: sandboxEnv(env),
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-    }
-    logger.info(`Process spawned with PID: ${claude.pid}`);
-    // Track process for cancellation
-    runningProcesses.set(commandId, claude);
-    // Also map promptId -> commandId so cancel can find by either ID
-    if (promptId) {
-        promptIdToCommandId.set(promptId, commandId);
-    }
-    // Buffer for incomplete JSON lines
-    let jsonBuffer = '';
-    // Track current tool use for pairing with results
-    let currentToolUseId = null;
-    let currentToolName = null;
-    // Track streaming content for complete log entries
-    let thinkingBuffer = '';
-    let textBuffer = '';
-    let toolInputBuffer = '';
-    // Parse stream-json output format
-    // Returns { output: string, hadValidJson: boolean, logs: AgentLogEntry[] }
-    const parseStreamJson = (text) => {
-        jsonBuffer += text;
-        let output = '';
-        let hadValidJson = false;
-        const logs = [];
-        // Split by newlines and process complete JSON objects
-        const lines = jsonBuffer.split('\n');
-        jsonBuffer = lines.pop() || ''; // Keep incomplete line in buffer
-        for (const line of lines) {
-            if (!line.trim())
-                continue;
-            try {
-                const json = JSON.parse(line);
-                hadValidJson = true; // Successfully parsed JSON
-                // Handle Orquesta CLI eval format (has 'event' field)
-                if (json.event) {
-                    if (json.event === 'start') {
-                        output += `\n🎯 Starting task...\n`;
-                        logs.push(createSystemLog('init', 'Task started', 'info', promptId, json.data));
-                    }
-                    else if (json.event === 'todo') {
-                        const { action, id, title } = json.data;
-                        if (action === 'created') {
-                            output += `\n📝 Task ${id}: ${title}\n`;
+        logger.info(`Process spawned with PID: ${claude.pid}`);
+        // Track process for cancellation
+        runningProcesses.set(commandId, claude);
+        // Also map promptId -> commandId so cancel can find by either ID
+        if (promptId) {
+            promptIdToCommandId.set(promptId, commandId);
+        }
+        // Buffer for incomplete JSON lines
+        let jsonBuffer = '';
+        // Track current tool use for pairing with results
+        let currentToolUseId = null;
+        let currentToolName = null;
+        // Track streaming content for complete log entries
+        let thinkingBuffer = '';
+        let textBuffer = '';
+        let toolInputBuffer = '';
+        // Parse stream-json output format
+        // Returns { output: string, hadValidJson: boolean, logs: AgentLogEntry[] }
+        const parseStreamJson = (text) => {
+            jsonBuffer += text;
+            let output = '';
+            let hadValidJson = false;
+            const logs = [];
+            // Split by newlines and process complete JSON objects
+            const lines = jsonBuffer.split('\n');
+            jsonBuffer = lines.pop() || ''; // Keep incomplete line in buffer
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const json = JSON.parse(line);
+                    hadValidJson = true; // Successfully parsed JSON
+                    // Handle Orquesta CLI eval format (has 'event' field)
+                    if (json.event) {
+                        if (json.event === 'start') {
+                            output += `\n🎯 Starting task...\n`;
+                            logs.push(createSystemLog('init', 'Task started', 'info', promptId, json.data));
                         }
-                        else if (action === 'started') {
-                            output += `\n▶️  Working on: ${title}\n`;
+                        else if (json.event === 'todo') {
+                            const { action, id, title } = json.data;
+                            if (action === 'created') {
+                                output += `\n📝 Task ${id}: ${title}\n`;
+                            }
+                            else if (action === 'started') {
+                                output += `\n▶️  Working on: ${title}\n`;
+                            }
+                            else if (action === 'completed') {
+                                output += `\n✅ Completed: ${title}\n`;
+                            }
+                            else if (action === 'failed') {
+                                output += `\n❌ Failed: ${title}\n`;
+                            }
                         }
-                        else if (action === 'completed') {
-                            output += `\n✅ Completed: ${title}\n`;
+                        else if (json.event === 'tool_call') {
+                            const { tool, args } = json.data;
+                            output += `\n🔧 Tool: ${tool}\n`;
+                            const argsStr = JSON.stringify(args, null, 2);
+                            if (argsStr.length < 500) {
+                                output += `${argsStr}\n`;
+                            }
+                            logs.push(createToolCallLog(tool, args, 'info', promptId));
+                            currentToolName = tool;
                         }
-                        else if (action === 'failed') {
-                            output += `\n❌ Failed: ${title}\n`;
+                        else if (json.event === 'tool_result') {
+                            const { tool, success, result, error } = json.data;
+                            if (success && result) {
+                                const preview = result.slice(0, 1000);
+                                output += `\n📋 Result: ${preview}${result.length > 1000 ? '...' : ''}\n`;
+                                logs.push(createToolResultLog(tool, true, result.slice(0, 5000), undefined, 'success', promptId));
+                            }
+                            else if (error) {
+                                output += `\n❌ Error: ${error}\n`;
+                                logs.push(createToolResultLog(tool, false, undefined, error, 'error', promptId));
+                            }
                         }
-                    }
-                    else if (json.event === 'tool_call') {
-                        const { tool, args } = json.data;
-                        output += `\n🔧 Tool: ${tool}\n`;
-                        const argsStr = JSON.stringify(args, null, 2);
-                        if (argsStr.length < 500) {
-                            output += `${argsStr}\n`;
+                        else if (json.event === 'response') {
+                            const { content } = json.data;
+                            if (content) {
+                                output += `\n${content}\n`;
+                                logs.push(createOutputLog(content, 'markdown', 'info', promptId));
+                            }
                         }
-                        logs.push(createToolCallLog(tool, args, 'info', promptId));
-                        currentToolName = tool;
+                        else if (json.event === 'end') {
+                            const { success, duration_ms, usage } = json.data;
+                            const duration = (duration_ms / 1000).toFixed(1);
+                            output += `\n${success ? '✅' : '❌'} Completed in ${duration}s\n`;
+                            if (usage) {
+                                output += `📊 Tokens: ${usage.total_tokens || 0}\n`;
+                            }
+                            logs.push(createSystemLog('complete', `Execution ${success ? 'succeeded' : 'failed'}`, success ? 'success' : 'error', promptId, json.data));
+                        }
+                        // Continue to next line - don't process as Claude format
+                        continue;
                     }
-                    else if (json.event === 'tool_result') {
-                        const { tool, success, result, error } = json.data;
-                        if (success && result) {
-                            const preview = result.slice(0, 1000);
-                            output += `\n📋 Result: ${preview}${result.length > 1000 ? '...' : ''}\n`;
-                            logs.push(createToolResultLog(tool, true, result.slice(0, 5000), undefined, 'success', promptId));
+                    // Handle different message types from Claude CLI stream-json
+                    if (json.type === 'assistant') {
+                        // Assistant message with content blocks
+                        if (json.message?.content) {
+                            for (const block of json.message.content) {
+                                if (block.type === 'thinking') {
+                                    output += `\n💭 Thinking:\n${block.thinking}\n`;
+                                    // Create structured thinking log
+                                    logs.push(createThinkingLog(block.thinking, 'info', promptId));
+                                }
+                                else if (block.type === 'text') {
+                                    output += block.text;
+                                    // Create structured output log
+                                    if (block.text.trim()) {
+                                        logs.push(createOutputLog(block.text, 'markdown', 'info', promptId));
+                                    }
+                                }
+                                else if (block.type === 'tool_use') {
+                                    output += `\n🔧 Tool: ${block.name}\n`;
+                                    const inputStr = block.input
+                                        ? (typeof block.input === 'string' ? block.input : JSON.stringify(block.input, null, 2))
+                                        : '';
+                                    if (inputStr) {
+                                        output += `${inputStr.slice(0, 500)}${inputStr.length > 500 ? '...' : ''}\n`;
+                                    }
+                                    // Create structured tool call log
+                                    logs.push(createToolCallLog(block.name, block.input || {}, 'info', promptId, block.id));
+                                    currentToolUseId = block.id;
+                                    currentToolName = block.name;
+                                    // Track file modifications for memory summaries
+                                    const toolInput = block.input;
+                                    if (toolInput && typeof toolInput.file_path === 'string') {
+                                        if (['Edit', 'Write', 'NotebookEdit'].includes(block.name)) {
+                                            trackFileModified(promptId, toolInput.file_path);
+                                        }
+                                    }
+                                }
+                                else if (block.type === 'tool_result') {
+                                    const content = typeof block.content === 'string'
+                                        ? block.content
+                                        : JSON.stringify(block.content);
+                                    output += `\n📋 Result:\n${content.slice(0, 1000)}${content.length > 1000 ? '...' : ''}\n`;
+                                    // Create structured tool result log
+                                    const isError = block.is_error === true;
+                                    logs.push(createToolResultLog(currentToolName || 'Unknown', !isError, isError ? undefined : content.slice(0, 5000), isError ? content : undefined, isError ? 'error' : 'success', promptId, block.tool_use_id));
+                                }
+                            }
                         }
-                        else if (error) {
-                            output += `\n❌ Error: ${error}\n`;
-                            logs.push(createToolResultLog(tool, false, undefined, error, 'error', promptId));
+                    }
+                    else if (json.type === 'user') {
+                        // User message (tool results from Claude CLI)
+                        if (json.message?.content) {
+                            for (const block of json.message.content) {
+                                if (block.type === 'tool_result') {
+                                    const content = typeof block.content === 'string'
+                                        ? block.content
+                                        : JSON.stringify(block.content);
+                                    // Show tool results but keep them concise
+                                    if (content.length > 50) {
+                                        output += `\n📋 ${content.slice(0, 800)}${content.length > 800 ? '...' : ''}\n`;
+                                    }
+                                    // Create structured tool result log
+                                    const isError = block.is_error === true;
+                                    logs.push(createToolResultLog(currentToolName || 'Unknown', !isError, isError ? undefined : content.slice(0, 5000), isError ? content : undefined, isError ? 'error' : 'success', promptId, block.tool_use_id));
+                                }
+                            }
                         }
                     }
-                    else if (json.event === 'response') {
-                        const { content } = json.data;
-                        if (content) {
-                            output += `\n${content}\n`;
-                            logs.push(createOutputLog(content, 'markdown', 'info', promptId));
+                    else if (json.type === 'content_block_delta') {
+                        // Streaming content delta - accumulate in buffers
+                        if (json.delta?.type === 'thinking_delta') {
+                            const thinking = json.delta.thinking || '';
+                            output += thinking;
+                            thinkingBuffer += thinking;
+                        }
+                        else if (json.delta?.type === 'text_delta') {
+                            const text = json.delta.text || '';
+                            output += text;
+                            textBuffer += text;
+                        }
+                        else if (json.delta?.type === 'input_json_delta') {
+                            // Tool input streaming
+                            const partialJson = json.delta.partial_json || '';
+                            output += partialJson;
+                            toolInputBuffer += partialJson;
                         }
                     }
-                    else if (json.event === 'end') {
-                        const { success, duration_ms, usage } = json.data;
-                        const duration = (duration_ms / 1000).toFixed(1);
-                        output += `\n${success ? '✅' : '❌'} Completed in ${duration}s\n`;
-                        if (usage) {
-                            output += `📊 Tokens: ${usage.total_tokens || 0}\n`;
+                    else if (json.type === 'content_block_start') {
+                        // Start of a content block - reset buffers
+                        if (json.content_block?.type === 'thinking') {
+                            output += '\n💭 Thinking:\n';
+                            thinkingBuffer = '';
+                        }
+                        else if (json.content_block?.type === 'tool_use') {
+                            output += `\n🔧 Tool: ${json.content_block.name || 'unknown'}\n`;
+                            currentToolName = json.content_block.name;
+                            currentToolUseId = json.content_block.id;
+                            toolInputBuffer = '';
+                        }
+                        else if (json.content_block?.type === 'text') {
+                            textBuffer = '';
                         }
-                        logs.push(createSystemLog('complete', `Execution ${success ? 'succeeded' : 'failed'}`, success ? 'success' : 'error', promptId, json.data));
                     }
-                    // Continue to next line - don't process as Claude format
-                    continue;
-                }
-                // Handle different message types from Claude CLI stream-json
-                if (json.type === 'assistant') {
-                    // Assistant message with content blocks
-                    if (json.message?.content) {
-                        for (const block of json.message.content) {
-                            if (block.type === 'thinking') {
-                                output += `\n💭 Thinking:\n${block.thinking}\n`;
-                                // Create structured thinking log
-                                logs.push(createThinkingLog(block.thinking, 'info', promptId));
-                            }
-                            else if (block.type === 'text') {
-                                output += block.text;
-                                // Create structured output log
-                                if (block.text.trim()) {
-                                    logs.push(createOutputLog(block.text, 'markdown', 'info', promptId));
-                                }
-                            }
-                            else if (block.type === 'tool_use') {
-                                output += `\n🔧 Tool: ${block.name}\n`;
-                                const inputStr = block.input
-                                    ? (typeof block.input === 'string' ? block.input : JSON.stringify(block.input, null, 2))
-                                    : '';
-                                if (inputStr) {
-                                    output += `${inputStr.slice(0, 500)}${inputStr.length > 500 ? '...' : ''}\n`;
-                                }
-                                // Create structured tool call log
-                                logs.push(createToolCallLog(block.name, block.input || {}, 'info', promptId, block.id));
-                                currentToolUseId = block.id;
-                                currentToolName = block.name;
+                    else if (json.type === 'content_block_stop') {
+                        // Block ended - emit structured logs from buffers
+                        output += '\n';
+                        if (thinkingBuffer.trim()) {
+                            logs.push(createThinkingLog(thinkingBuffer, 'info', promptId));
+                            thinkingBuffer = '';
+                        }
+                        if (textBuffer.trim()) {
+                            logs.push(createOutputLog(textBuffer, 'markdown', 'info', promptId));
+                            textBuffer = '';
+                        }
+                        if (toolInputBuffer.trim() && currentToolName) {
+                            try {
+                                const parsedInput = JSON.parse(toolInputBuffer);
+                                logs.push(createToolCallLog(currentToolName, parsedInput, 'info', promptId, currentToolUseId || undefined));
                                 // Track file modifications for memory summaries
-                                const toolInput = block.input;
-                                if (toolInput && typeof toolInput.file_path === 'string') {
-                                    if (['Edit', 'Write', 'NotebookEdit'].includes(block.name)) {
-                                        trackFileModified(promptId, toolInput.file_path);
+                                if (parsedInput && typeof parsedInput.file_path === 'string') {
+                                    if (['Edit', 'Write', 'NotebookEdit'].includes(currentToolName)) {
+                                        trackFileModified(promptId, parsedInput.file_path);
                                     }
                                 }
                             }
-                            else if (block.type === 'tool_result') {
-                                const content = typeof block.content === 'string'
-                                    ? block.content
-                                    : JSON.stringify(block.content);
-                                output += `\n📋 Result:\n${content.slice(0, 1000)}${content.length > 1000 ? '...' : ''}\n`;
-                                // Create structured tool result log
-                                const isError = block.is_error === true;
-                                logs.push(createToolResultLog(currentToolName || 'Unknown', !isError, isError ? undefined : content.slice(0, 5000), isError ? content : undefined, isError ? 'error' : 'success', promptId, block.tool_use_id));
+                            catch {
+                                // Invalid JSON input - emit as-is
+                                logs.push(createToolCallLog(currentToolName, { raw: toolInputBuffer }, 'info', promptId, currentToolUseId || undefined));
                             }
+                            toolInputBuffer = '';
                         }
                     }
-                }
-                else if (json.type === 'user') {
-                    // User message (tool results from Claude CLI)
-                    if (json.message?.content) {
-                        for (const block of json.message.content) {
-                            if (block.type === 'tool_result') {
-                                const content = typeof block.content === 'string'
-                                    ? block.content
-                                    : JSON.stringify(block.content);
-                                // Show tool results but keep them concise
-                                if (content.length > 50) {
-                                    output += `\n📋 ${content.slice(0, 800)}${content.length > 800 ? '...' : ''}\n`;
-                                }
-                                // Create structured tool result log
-                                const isError = block.is_error === true;
-                                logs.push(createToolResultLog(currentToolName || 'Unknown', !isError, isError ? undefined : content.slice(0, 5000), isError ? content : undefined, isError ? 'error' : 'success', promptId, block.tool_use_id));
+                    else if (json.type === 'result') {
+                        // Final result from Claude CLI.
+                        //
+                        // Claude reports an upstream account/API failure here by exiting 0
+                        // with is_error set and the error string as `result` (e.g. "API
+                        // Error: 400 This organization has been disabled."). Treating that
+                        // as a successful ✅ result is wrong — the prompt silently
+                        // "completes" with the error text. Detect it and flag for the
+                        // claude→orquesta fallback in the close handler instead of emitting
+                        // it as success.
+                        const apiErrStatus = typeof json.api_error_status === 'number' ? json.api_error_status : 0;
+                        const isAccountFailure = json.is_error === true &&
+                            (apiErrStatus >= 400 || CLAUDE_PROVIDER_FATAL_PATTERN.test(json.result || ''));
+                        if (isAccountFailure && selectedCli === 'claude') {
+                            claudeApiError = json.result || `claude api_error_status ${apiErrStatus}`;
+                            // Don't emit the error as a ✅ success result; the close handler
+                            // logs the failure + the orquesta-cli fallback.
+                        }
+                        else {
+                            if (json.result) {
+                                output += `\n✅ ${json.result}\n`;
+                            }
+                            if (json.cost_usd) {
+                                output += `💰 Cost: $${json.cost_usd.toFixed(4)}\n`;
+                            }
+                            // Track usage for persistence to DB
+                            if (json.total_tokens) {
+                                promptTokensUsed.set(promptId, json.total_tokens);
+                            }
+                            if (json.cost_usd) {
+                                promptCostCents.set(promptId, Math.round(json.cost_usd * 100));
                             }
+                            // Emit system log for completion
+                            logs.push(createSystemLog('complete', json.result || 'Execution completed', 'success', promptId, {
+                                cost_cents: json.cost_usd ? Math.round(json.cost_usd * 100) : undefined,
+                                tokens_used: json.total_tokens,
+                            }));
                         }
                     }
-                }
-                else if (json.type === 'content_block_delta') {
-                    // Streaming content delta - accumulate in buffers
-                    if (json.delta?.type === 'thinking_delta') {
-                        const thinking = json.delta.thinking || '';
-                        output += thinking;
-                        thinkingBuffer += thinking;
-                    }
-                    else if (json.delta?.type === 'text_delta') {
-                        const text = json.delta.text || '';
-                        output += text;
-                        textBuffer += text;
-                    }
-                    else if (json.delta?.type === 'input_json_delta') {
-                        // Tool input streaming
-                        const partialJson = json.delta.partial_json || '';
-                        output += partialJson;
-                        toolInputBuffer += partialJson;
+                    else if (json.type === 'system') {
+                        // System messages from Claude CLI
+                        if (json.message && !json.message.includes('initialization')) {
+                            output += `ℹ️ ${json.message}\n`;
+                            logs.push(createSystemLog('heartbeat', json.message, 'info', promptId));
+                        }
                     }
+                    // Silently ignore: message_start, message_stop, ping, etc.
                 }
-                else if (json.type === 'content_block_start') {
-                    // Start of a content block - reset buffers
-                    if (json.content_block?.type === 'thinking') {
-                        output += '\n💭 Thinking:\n';
-                        thinkingBuffer = '';
-                    }
-                    else if (json.content_block?.type === 'tool_use') {
-                        output += `\n🔧 Tool: ${json.content_block.name || 'unknown'}\n`;
-                        currentToolName = json.content_block.name;
-                        currentToolUseId = json.content_block.id;
-                        toolInputBuffer = '';
-                    }
-                    else if (json.content_block?.type === 'text') {
-                        textBuffer = '';
-                    }
+                catch {
+                    // Not valid JSON, output as plain text
+                    output += line + '\n';
                 }
-                else if (json.type === 'content_block_stop') {
-                    // Block ended - emit structured logs from buffers
-                    output += '\n';
-                    if (thinkingBuffer.trim()) {
-                        logs.push(createThinkingLog(thinkingBuffer, 'info', promptId));
-                        thinkingBuffer = '';
-                    }
-                    if (textBuffer.trim()) {
-                        logs.push(createOutputLog(textBuffer, 'markdown', 'info', promptId));
-                        textBuffer = '';
-                    }
-                    if (toolInputBuffer.trim() && currentToolName) {
-                        try {
-                            const parsedInput = JSON.parse(toolInputBuffer);
-                            logs.push(createToolCallLog(currentToolName, parsedInput, 'info', promptId, currentToolUseId || undefined));
-                            // Track file modifications for memory summaries
-                            if (parsedInput && typeof parsedInput.file_path === 'string') {
-                                if (['Edit', 'Write', 'NotebookEdit'].includes(currentToolName)) {
-                                    trackFileModified(promptId, parsedInput.file_path);
-                                }
-                            }
-                        }
-                        catch {
-                            // Invalid JSON input - emit as-is
-                            logs.push(createToolCallLog(currentToolName, { raw: toolInputBuffer }, 'info', promptId, currentToolUseId || undefined));
+            }
+            return { output, hadValidJson, logs };
+        };
+        // Helper to send special events (git commits, deployments)
+        const sendSpecialEvent = async (eventType, details) => {
+            try {
+                await channel.send({
+                    type: 'broadcast',
+                    event: eventType,
+                    payload: {
+                        id: commandId,
+                        promptId,
+                        ...details,
+                        timestamp: Date.now(),
+                    },
+                });
+            }
+            catch (err) {
+                logger.warn(`Failed to send ${eventType} event: ${err}`);
+            }
+        };
+        // Stream stdout
+        if (claude.stdout) {
+            claude.stdout.on('data', (data) => {
+                const text = data.toString();
+                // Skip logging if it looks like base64/binary data (long strings without spaces)
+                const preview = text.slice(0, 150);
+                const looksLikeBinary = preview.length > 50 && !preview.includes(' ') && /^[A-Za-z0-9+/=]+$/.test(preview.replace(/\s/g, ''));
+                if (!looksLikeBinary) {
+                    logger.info(`[STDOUT] ${text.slice(0, 100)}`);
+                }
+                // Parse stream-json and send formatted output
+                const { output: parsed, hadValidJson, logs: structuredLogs } = parseStreamJson(text);
+                // Only fallback to raw text if it wasn't valid JSON
+                // If it was valid JSON but produced no output (e.g., system init), don't send anything
+                const outputToSend = hadValidJson ? parsed : text;
+                if (outputToSend.trim()) {
+                    logger.output('stdout', outputToSend.slice(0, 200));
+                    sendOutput(channel, commandId, 'stdout', outputToSend);
+                }
+                // Add structured logs to accumulator for persistence
+                for (const log of structuredLogs) {
+                    addStructuredLog(promptId, log);
+                }
+                // Fallback: if no structured logs but we have output, create output log
+                if (structuredLogs.length === 0 && outputToSend.trim() && !hadValidJson) {
+                    addLog(promptId, 'info', 'output', outputToSend);
+                }
+                // Detect git commits in the output
+                // Matches various formats:
+                // - [f0f66f3] commit message (git log)
+                // - commit f0f66f3 (git show)
+                // - **Commit**: `f0f66f3` (Claude formatted)
+                // - Commit: f0f66f3 (plain text)
+                const commitMatch = text.match(/\[([a-f0-9]{7,40})\]\s+(.+)/i) ||
+                    text.match(/commit\s+([a-f0-9]{7,40})/i) ||
+                    text.match(/\*\*Commit\*\*:\s*`([a-f0-9]{7,40})`/i) ||
+                    text.match(/Commit:\s*`?([a-f0-9]{7,40})`?/i);
+                if (commitMatch) {
+                    // Try to get GitHub URL from git remote
+                    let commitUrl = null;
+                    try {
+                        const remoteUrl = execSync('git config --get remote.origin.url', {
+                            cwd: workingDirectory,
+                            encoding: 'utf-8',
+                            timeout: 5000,
+                        }).trim();
+                        // Convert git remote URL to GitHub commit URL
+                        const githubMatch = remoteUrl.match(/github\.com[:/](.+?)(?:\.git)?$/);
+                        if (githubMatch) {
+                            const repoPath = githubMatch[1].replace(/\.git$/, '');
+                            commitUrl = `https://github.com/${repoPath}/commit/${commitMatch[1]}`;
                         }
-                        toolInputBuffer = '';
                     }
-                }
-                else if (json.type === 'result') {
-                    // Final result from Claude CLI.
-                    //
-                    // Claude reports an upstream account/API failure here by exiting 0
-                    // with is_error set and the error string as `result` (e.g. "API
-                    // Error: 400 This organization has been disabled."). Treating that
-                    // as a successful ✅ result is wrong — the prompt silently
-                    // "completes" with the error text. Detect it and flag for the
-                    // claude→orquesta fallback in the close handler instead of emitting
-                    // it as success.
-                    const apiErrStatus = typeof json.api_error_status === 'number' ? json.api_error_status : 0;
-                    const isAccountFailure = json.is_error === true &&
-                        (apiErrStatus >= 400 || CLAUDE_PROVIDER_FATAL_PATTERN.test(json.result || ''));
-                    if (isAccountFailure && selectedCli === 'claude') {
-                        claudeApiError = json.result || `claude api_error_status ${apiErrStatus}`;
-                        // Don't emit the error as a ✅ success result; the close handler
-                        // logs the failure + the orquesta-cli fallback.
+                    catch {
+                        // Ignore errors getting git remote
                     }
-                    else {
-                        if (json.result) {
-                            output += `\n✅ ${json.result}\n`;
-                        }
-                        if (json.cost_usd) {
-                            output += `💰 Cost: $${json.cost_usd.toFixed(4)}\n`;
-                        }
-                        // Track usage for persistence to DB
-                        if (json.total_tokens) {
-                            promptTokensUsed.set(promptId, json.total_tokens);
-                        }
-                        if (json.cost_usd) {
-                            promptCostCents.set(promptId, Math.round(json.cost_usd * 100));
-                        }
-                        // Emit system log for completion
-                        logs.push(createSystemLog('complete', json.result || 'Execution completed', 'success', promptId, {
-                            cost_cents: json.cost_usd ? Math.round(json.cost_usd * 100) : undefined,
-                            tokens_used: json.total_tokens,
-                        }));
+                    sendSpecialEvent('git_commit', {
+                        commitSha: commitMatch[1],
+                        message: commitMatch[2] || '',
+                        commitUrl,
+                    });
+                    // Track commit as key action for memory summary
+                    const commitMsg = commitMatch[2] ? commitMatch[2].slice(0, 50) : 'changes';
+                    trackAction(promptId, `Committed: ${commitMsg}`);
+                }
+                // Detect deployments in the output
+                if (text.includes('Deployed to') || text.includes('Production:') || text.includes('vercel.app')) {
+                    const urlMatch = text.match(/(https:\/\/[^\s]+\.vercel\.app[^\s]*)/i);
+                    if (urlMatch) {
+                        sendSpecialEvent('deploy', {
+                            url: urlMatch[1],
+                            provider: 'vercel',
+                        });
+                        // Track deployment as key action for memory summary
+                        trackAction(promptId, `Deployed to Vercel`);
                     }
                 }
-                else if (json.type === 'system') {
-                    // System messages from Claude CLI
-                    if (json.message && !json.message.includes('initialization')) {
-                        output += `ℹ️ ${json.message}\n`;
-                        logs.push(createSystemLog('heartbeat', json.message, 'info', promptId));
+                // Detect requirements (API keys, credentials, decisions needed)
+                const requirementResult = detectRequirement(text, commandId);
+                if (requirementResult?.detected && requirementResult.requirement) {
+                    logger.warn(`Requirement detected: ${requirementResult.requirement.title}`);
+                    // Send via realtime channel
+                    sendRequirement(channel, commandId, promptId, requirementResult.requirement);
+                    // Also persist to database (creates Linear ticket if connected)
+                    persistRequirement(promptId, requirementResult.requirement).catch(err => {
+                        logger.warn(`Failed to persist requirement: ${err}`);
+                    });
+                }
+                // Detect QA instructions
+                const qaInstructions = detectQAInstructions(text, commandId);
+                if (qaInstructions) {
+                    logger.success(`QA Instructions detected: ${qaInstructions.feature}`);
+                    // Send via realtime channel
+                    sendQAInstructions(channel, commandId, promptId, qaInstructions);
+                    // Persist to database
+                    persistQAInstructions(promptId, qaInstructions).catch(err => {
+                        logger.warn(`Failed to persist QA instructions: ${err}`);
+                    });
+                }
+                // In supervised mode, check for permission requests
+                if (mode === 'supervised') {
+                    const { detected, content: permissionContent } = detectPermissionRequest(text, commandId);
+                    if (detected) {
+                        handlePermissionRequest(commandId, promptId, channel, claude, permissionContent);
                     }
                 }
-                // Silently ignore: message_start, message_stop, ping, etc.
-            }
-            catch {
-                // Not valid JSON, output as plain text
-                output += line + '\n';
-            }
-        }
-        return { output, hadValidJson, logs };
-    };
-    // Helper to send special events (git commits, deployments)
-    const sendSpecialEvent = async (eventType, details) => {
-        try {
-            await channel.send({
-                type: 'broadcast',
-                event: eventType,
-                payload: {
-                    id: commandId,
-                    promptId,
-                    ...details,
-                    timestamp: Date.now(),
-                },
             });
         }
-        catch (err) {
-            logger.warn(`Failed to send ${eventType} event: ${err}`);
+        else {
+            logger.warn('No stdout pipe available');
+        }
+        // Stream stderr
+        if (claude.stderr) {
+            claude.stderr.on('data', (data) => {
+                const raw = data.toString();
+                const text = stripAnsiCodes(raw);
+                if (!text.trim())
+                    return;
+                logger.info(`[STDERR] ${text.slice(0, 100)}`);
+                logger.output('stderr', text);
+                sendOutput(channel, commandId, 'stderr', text);
+                // Add to log accumulator for persistence backup
+                addLog(promptId, 'error', 'stderr', text);
+            });
         }
-    };
-    // Stream stdout
-    if (claude.stdout) {
-        claude.stdout.on('data', (data) => {
-            const text = data.toString();
-            // Skip logging if it looks like base64/binary data (long strings without spaces)
-            const preview = text.slice(0, 150);
-            const looksLikeBinary = preview.length > 50 && !preview.includes(' ') && /^[A-Za-z0-9+/=]+$/.test(preview.replace(/\s/g, ''));
-            if (!looksLikeBinary) {
-                logger.info(`[STDOUT] ${text.slice(0, 100)}`);
-            }
-            // Parse stream-json and send formatted output
-            const { output: parsed, hadValidJson, logs: structuredLogs } = parseStreamJson(text);
-            // Only fallback to raw text if it wasn't valid JSON
-            // If it was valid JSON but produced no output (e.g., system init), don't send anything
-            const outputToSend = hadValidJson ? parsed : text;
-            if (outputToSend.trim()) {
-                logger.output('stdout', outputToSend.slice(0, 200));
-                sendOutput(channel, commandId, 'stdout', outputToSend);
-            }
-            // Add structured logs to accumulator for persistence
-            for (const log of structuredLogs) {
-                addStructuredLog(promptId, log);
-            }
-            // Fallback: if no structured logs but we have output, create output log
-            if (structuredLogs.length === 0 && outputToSend.trim() && !hadValidJson) {
-                addLog(promptId, 'info', 'output', outputToSend);
-            }
-            // Detect git commits in the output
-            // Matches various formats:
-            // - [f0f66f3] commit message (git log)
-            // - commit f0f66f3 (git show)
-            // - **Commit**: `f0f66f3` (Claude formatted)
-            // - Commit: f0f66f3 (plain text)
-            const commitMatch = text.match(/\[([a-f0-9]{7,40})\]\s+(.+)/i) ||
-                text.match(/commit\s+([a-f0-9]{7,40})/i) ||
-                text.match(/\*\*Commit\*\*:\s*`([a-f0-9]{7,40})`/i) ||
-                text.match(/Commit:\s*`?([a-f0-9]{7,40})`?/i);
-            if (commitMatch) {
-                // Try to get GitHub URL from git remote
-                let commitUrl = null;
-                try {
-                    const remoteUrl = execSync('git config --get remote.origin.url', {
-                        cwd: workingDirectory,
-                        encoding: 'utf-8',
-                        timeout: 5000,
-                    }).trim();
-                    // Convert git remote URL to GitHub commit URL
-                    const githubMatch = remoteUrl.match(/github\.com[:/](.+?)(?:\.git)?$/);
-                    if (githubMatch) {
-                        const repoPath = githubMatch[1].replace(/\.git$/, '');
-                        commitUrl = `https://github.com/${repoPath}/commit/${commitMatch[1]}`;
+        else {
+            logger.warn('No stderr pipe available');
+        }
+        // Wrap process lifecycle in a Promise so callers can await completion
+        return new Promise((resolveExecution) => {
+            // Handle completion
+            claude.on('close', async (code) => {
+                runningProcesses.delete(commandId);
+                if (promptId)
+                    promptIdToCommandId.delete(promptId);
+                pendingSupervisionCallbacks.delete(commandId);
+                // Clean up per-execution buffers (concurrent-safe)
+                outputBufferMap.delete(commandId);
+                detectedRequirementsMap.delete(commandId);
+                qaBufferMap.delete(commandId);
+                qaDetectedMap.delete(commandId);
+                // claude→orquesta fallback: if Claude CLI failed at the account/API
+                // level (org disabled, auth) and orquesta-cli is available, re-run the
+                // SAME prompt through it (→ Batuta proxy → Kimi) instead of completing
+                // with the error text. _forceCli guards against re-recursing. The
+                // recursive call owns final completion (sendComplete/flush), so we skip
+                // the rest of this handler and resolve once it returns.
+                if (claudeApiError && selectedCli === 'claude' && !options._forceCli && isOrquestaCliAvailable()) {
+                    logger.warn(`Claude CLI unavailable (${claudeApiError.slice(0, 80)}) — retrying via orquesta-cli`);
+                    addLog(promptId, 'warning', 'system', 'Claude CLI unavailable — falling back to orquesta-cli');
+                    try {
+                        await execute({ ...options, _forceCli: 'orquesta' });
+                    }
+                    catch (err) {
+                        logger.error(`orquesta-cli fallback failed: ${err}`);
+                        stopLogPersistence(promptId);
+                        if (_activePromptId === promptId)
+                            _activePromptId = null;
+                        try {
+                            await flushLogs(promptId);
+                        }
+                        catch { /* noop */ }
+                        executionLogs.delete(promptId);
+                        sendComplete(channel, commandId, 1, startTime);
                     }
+                    resolveExecution();
+                    return;
                 }
-                catch {
-                    // Ignore errors getting git remote
+                // If Claude failed at the account level but we could NOT fall back
+                // (no orquesta-cli, or this IS the forced run), surface it as a real
+                // failure instead of a silent exit-0 "completed" with empty output.
+                // claude exits 0 even on "organization has been disabled".
+                if (claudeApiError) {
+                    addLog(promptId, 'error', 'system', `Claude CLI unavailable (no fallback): ${claudeApiError}`);
+                    sendOutput(channel, commandId, 'stderr', `\n❌ Claude CLI unavailable: ${claudeApiError}\n`);
                 }
-                sendSpecialEvent('git_commit', {
-                    commitSha: commitMatch[1],
-                    message: commitMatch[2] || '',
-                    commitUrl,
-                });
-                // Track commit as key action for memory summary
-                const commitMsg = commitMatch[2] ? commitMatch[2].slice(0, 50) : 'changes';
-                trackAction(promptId, `Committed: ${commitMsg}`);
-            }
-            // Detect deployments in the output
-            if (text.includes('Deployed to') || text.includes('Production:') || text.includes('vercel.app')) {
-                const urlMatch = text.match(/(https:\/\/[^\s]+\.vercel\.app[^\s]*)/i);
-                if (urlMatch) {
-                    sendSpecialEvent('deploy', {
-                        url: urlMatch[1],
-                        provider: 'vercel',
-                    });
-                    // Track deployment as key action for memory summary
-                    trackAction(promptId, `Deployed to Vercel`);
+                const exitCode = claudeApiError ? (code || 1) : (code ?? 0);
+                const duration = Date.now() - startTime;
+                const status = exitCode === 0 ? 'completed' : 'failed';
+                if (exitCode === 0) {
+                    logger.success(`Completed in ${(duration / 1000).toFixed(1)}s`);
                 }
-            }
-            // Detect requirements (API keys, credentials, decisions needed)
-            const requirementResult = detectRequirement(text, commandId);
-            if (requirementResult?.detected && requirementResult.requirement) {
-                logger.warn(`Requirement detected: ${requirementResult.requirement.title}`);
-                // Send via realtime channel
-                sendRequirement(channel, commandId, promptId, requirementResult.requirement);
-                // Also persist to database (creates Linear ticket if connected)
-                persistRequirement(promptId, requirementResult.requirement).catch(err => {
-                    logger.warn(`Failed to persist requirement: ${err}`);
-                });
-            }
-            // Detect QA instructions
-            const qaInstructions = detectQAInstructions(text, commandId);
-            if (qaInstructions) {
-                logger.success(`QA Instructions detected: ${qaInstructions.feature}`);
-                // Send via realtime channel
-                sendQAInstructions(channel, commandId, promptId, qaInstructions);
-                // Persist to database
-                persistQAInstructions(promptId, qaInstructions).catch(err => {
-                    logger.warn(`Failed to persist QA instructions: ${err}`);
-                });
-            }
-            // In supervised mode, check for permission requests
-            if (mode === 'supervised') {
-                const { detected, content: permissionContent } = detectPermissionRequest(text, commandId);
-                if (detected) {
-                    handlePermissionRequest(commandId, promptId, channel, claude, permissionContent);
+                else {
+                    logger.warn(`Exited with code ${exitCode}`);
                 }
-            }
-        });
-    }
-    else {
-        logger.warn('No stdout pipe available');
-    }
-    // Stream stderr
-    if (claude.stderr) {
-        claude.stderr.on('data', (data) => {
-            const raw = data.toString();
-            const text = stripAnsiCodes(raw);
-            if (!text.trim())
-                return;
-            logger.info(`[STDERR] ${text.slice(0, 100)}`);
-            logger.output('stderr', text);
-            sendOutput(channel, commandId, 'stderr', text);
-            // Add to log accumulator for persistence backup
-            addLog(promptId, 'error', 'stderr', text);
-        });
-    }
-    else {
-        logger.warn('No stderr pipe available');
-    }
-    // Wrap process lifecycle in a Promise so callers can await completion
-    return new Promise((resolveExecution) => {
-        // Handle completion
-        claude.on('close', async (code) => {
-            runningProcesses.delete(commandId);
-            if (promptId)
-                promptIdToCommandId.delete(promptId);
-            pendingSupervisionCallbacks.delete(commandId);
-            // Clean up per-execution buffers (concurrent-safe)
-            outputBufferMap.delete(commandId);
-            detectedRequirementsMap.delete(commandId);
-            qaBufferMap.delete(commandId);
-            qaDetectedMap.delete(commandId);
-            // claude→orquesta fallback: if Claude CLI failed at the account/API
-            // level (org disabled, auth) and orquesta-cli is available, re-run the
-            // SAME prompt through it (→ Batuta proxy → Kimi) instead of completing
-            // with the error text. _forceCli guards against re-recursing. The
-            // recursive call owns final completion (sendComplete/flush), so we skip
-            // the rest of this handler and resolve once it returns.
-            if (claudeApiError && selectedCli === 'claude' && !options._forceCli && isOrquestaCliAvailable()) {
-                logger.warn(`Claude CLI unavailable (${claudeApiError.slice(0, 80)}) — retrying via orquesta-cli`);
-                addLog(promptId, 'warning', 'system', 'Claude CLI unavailable — falling back to orquesta-cli');
+                // Add completion log entry
+                addLog(promptId, exitCode === 0 ? 'success' : 'error', 'system', `Execution ${status} with exit code ${exitCode} in ${(duration / 1000).toFixed(1)}s`);
+                // Stop periodic log persistence and flush any remaining logs
+                stopLogPersistence(promptId);
+                if (_activePromptId === promptId)
+                    _activePromptId = null;
                 try {
-                    await execute({ ...options, _forceCli: 'orquesta' });
+                    await flushLogs(promptId);
+                    executionLogs.delete(promptId);
+                    logger.debug('All logs flushed to database');
                 }
                 catch (err) {
-                    logger.error(`orquesta-cli fallback failed: ${err}`);
-                    stopLogPersistence(promptId);
-                    if (_activePromptId === promptId)
-                        _activePromptId = null;
-                    try {
-                        await flushLogs(promptId);
-                    }
-                    catch { /* noop */ }
-                    sendComplete(channel, commandId, 1, startTime);
+                    logger.error(`Failed to flush final logs: ${err}`);
+                }
+                // Clear output buffer for this command
+                clearOutputBuffer(commandId);
+                // Clean up attachment temp files
+                if (attachmentCleanup) {
+                    attachmentCleanup();
+                }
+                // Send completion via WebSocket (for real-time UI update)
+                sendComplete(channel, commandId, exitCode, startTime);
+                // Generate execution summary for project memory
+                const summary = generateExecutionSummary(promptId, content, exitCode);
+                if (summary) {
+                    logger.info(`Generated summary: ${summary.text.slice(0, 100)}...`);
+                    logger.debug(`Files modified: ${summary.files_modified.length}, Actions: ${summary.key_actions.length}`);
+                }
+                // Collect token/cost usage tracked during streaming
+                const usage = {};
+                if (promptTokensUsed.has(promptId)) {
+                    usage.tokens_used = promptTokensUsed.get(promptId);
+                    promptTokensUsed.delete(promptId);
                 }
+                if (promptCostCents.has(promptId)) {
+                    usage.cost_cents = promptCostCents.get(promptId);
+                    promptCostCents.delete(promptId);
+                }
+                // Update prompt status in database with summary and usage (backend fix - don't rely on frontend)
+                updatePromptStatus(promptId, status, summary || undefined, Object.keys(usage).length > 0 ? usage : undefined).catch(err => {
+                    logger.error(`Failed to update prompt status: ${err}`);
+                });
                 resolveExecution();
-                return;
-            }
-            // If Claude failed at the account level but we could NOT fall back
-            // (no orquesta-cli, or this IS the forced run), surface it as a real
-            // failure instead of a silent exit-0 "completed" with empty output.
-            // claude exits 0 even on "organization has been disabled".
-            if (claudeApiError) {
-                addLog(promptId, 'error', 'system', `Claude CLI unavailable (no fallback): ${claudeApiError}`);
-                sendOutput(channel, commandId, 'stderr', `\n❌ Claude CLI unavailable: ${claudeApiError}\n`);
-            }
-            const exitCode = claudeApiError ? (code || 1) : (code ?? 0);
-            const duration = Date.now() - startTime;
-            const status = exitCode === 0 ? 'completed' : 'failed';
-            if (exitCode === 0) {
-                logger.success(`Completed in ${(duration / 1000).toFixed(1)}s`);
-            }
-            else {
-                logger.warn(`Exited with code ${exitCode}`);
-            }
-            // Add completion log entry
-            addLog(promptId, exitCode === 0 ? 'success' : 'error', 'system', `Execution ${status} with exit code ${exitCode} in ${(duration / 1000).toFixed(1)}s`);
-            // Stop periodic log persistence and flush any remaining logs
-            stopLogPersistence(promptId);
-            if (_activePromptId === promptId)
-                _activePromptId = null;
-            try {
-                await flushLogs(promptId);
-                logger.debug('All logs flushed to database');
-            }
-            catch (err) {
-                logger.error(`Failed to flush final logs: ${err}`);
-            }
-            // Clear output buffer for this command
-            clearOutputBuffer(commandId);
-            // Clean up attachment temp files
-            if (attachmentCleanup) {
-                attachmentCleanup();
-            }
-            // Send completion via WebSocket (for real-time UI update)
-            sendComplete(channel, commandId, exitCode, startTime);
-            // Generate execution summary for project memory
-            const summary = generateExecutionSummary(promptId, content, exitCode);
-            if (summary) {
-                logger.info(`Generated summary: ${summary.text.slice(0, 100)}...`);
-                logger.debug(`Files modified: ${summary.files_modified.length}, Actions: ${summary.key_actions.length}`);
-            }
-            // Collect token/cost usage tracked during streaming
-            const usage = {};
-            if (promptTokensUsed.has(promptId)) {
-                usage.tokens_used = promptTokensUsed.get(promptId);
-                promptTokensUsed.delete(promptId);
-            }
-            if (promptCostCents.has(promptId)) {
-                usage.cost_cents = promptCostCents.get(promptId);
-                promptCostCents.delete(promptId);
-            }
-            // Update prompt status in database with summary and usage (backend fix - don't rely on frontend)
-            updatePromptStatus(promptId, status, summary || undefined, Object.keys(usage).length > 0 ? usage : undefined).catch(err => {
-                logger.error(`Failed to update prompt status: ${err}`);
             });
-            resolveExecution();
-        });
-        // Handle errors
-        claude.on('error', async (err) => {
-            runningProcesses.delete(commandId);
-            if (promptId)
-                promptIdToCommandId.delete(promptId);
-            pendingSupervisionCallbacks.delete(commandId);
-            logger.error(`Execution error: ${err.message}`);
-            // Add error log entry
-            addLog(promptId, 'error', 'system', `Execution error: ${err.message}`);
-            // Stop log persistence and flush remaining logs
-            stopLogPersistence(promptId);
-            if (_activePromptId === promptId)
-                _activePromptId = null;
-            try {
-                await flushLogs(promptId);
-            }
-            catch (flushErr) {
-                logger.error(`Failed to flush logs on error: ${flushErr}`);
-            }
-            // Clear output buffer
-            clearOutputBuffer(commandId);
-            // Clean up attachment temp files
-            if (attachmentCleanup) {
-                attachmentCleanup();
-            }
-            if (err.message.includes('ENOENT')) {
-                const errPath = err.path;
-                if (errPath === 'script') {
-                    sendError(channel, commandId, `Failed to spawn PTY wrapper 'script' (Unix-only). On Windows this code path should be unreachable — please report this bug.`, 'SPAWN_SCRIPT_FAILED');
+            // Handle errors
+            claude.on('error', async (err) => {
+                runningProcesses.delete(commandId);
+                if (promptId)
+                    promptIdToCommandId.delete(promptId);
+                pendingSupervisionCallbacks.delete(commandId);
+                logger.error(`Execution error: ${err.message}`);
+                // Add error log entry
+                addLog(promptId, 'error', 'system', `Execution error: ${err.message}`);
+                // Stop log persistence and flush remaining logs
+                stopLogPersistence(promptId);
+                if (_activePromptId === promptId)
+                    _activePromptId = null;
+                try {
+                    await flushLogs(promptId);
+                }
+                catch (flushErr) {
+                    logger.error(`Failed to flush logs on error: ${flushErr}`);
+                }
+                // Clear output buffer
+                clearOutputBuffer(commandId);
+                // Clean up attachment temp files
+                if (attachmentCleanup) {
+                    attachmentCleanup();
+                }
+                if (err.message.includes('ENOENT')) {
+                    const errPath = err.path;
+                    if (errPath === 'script') {
+                        sendError(channel, commandId, `Failed to spawn PTY wrapper 'script' (Unix-only). On Windows this code path should be unreachable — please report this bug.`, 'SPAWN_SCRIPT_FAILED');
+                    }
+                    else {
+                        sendError(channel, commandId, `CLI not found: '${errPath || cliCommand}'. Install with: npm install -g @anthropic-ai/claude-code`, 'CLI_NOT_FOUND');
+                    }
                 }
                 else {
-                    sendError(channel, commandId, `CLI not found: '${errPath || cliCommand}'. Install with: npm install -g @anthropic-ai/claude-code`, 'CLI_NOT_FOUND');
+                    sendError(channel, commandId, err.message);
                 }
-            }
-            else {
-                sendError(channel, commandId, err.message);
-            }
-            resolveExecution();
+                resolveExecution();
+            });
         });
-    });
+    }
+    catch (err) {
+        _activePromptId = null;
+        throw err;
+    }
 }
 // Handle a detected permission request
 function handlePermissionRequest(commandId, promptId, channel, process, content) {