@a5c-ai/agent-mux-cli 0.4.10-staging.ff407b73 → 5.0.1-staging.04a3db697

package/dist/commands/launch.js

@@ -14,6 +14,7 @@ import { printError, printJsonError } from '../output.js';
 /** Launch-specific flag definitions (global flags like model/json/debug are excluded). */
 export const LAUNCH_FLAGS = {
     'api-key': { type: 'string' },
+    'profile': { type: 'string' },
     'api-base': { type: 'string' },
     'region': { type: 'string' },
     'project': { type: 'string' },
@@ -29,6 +30,7 @@ export const LAUNCH_FLAGS = {
     'resume': { short: 'r', type: 'string' },
     'session-id': { short: 's', type: 'string' },
     'prompt': { short: 'p', type: 'string' },
+    'interactive': { short: 'i', type: 'boolean' },
     'max-turns': { type: 'number' },
     'max-budget-usd': { type: 'number' },
     'dry-run': { type: 'boolean' },
@@ -39,14 +41,16 @@ export const LAUNCH_FLAGS = {
     'workspace-mode': { type: 'string' },
     'workspace-repo': { type: 'string', repeatable: true },
     'workspace-name': { type: 'string' },
+    'yolo': { type: 'boolean' },
+    'bridge-interactive': { type: 'boolean' },
+    'bridge-hooks': { type: 'boolean' },
 };
 // ---------------------------------------------------------------------------
 // Plan resolution
 // ---------------------------------------------------------------------------
 export function resolveLaunchPlan(input) {
-    const providerId = (input.provider ?? 'anthropic');
     const providerConfig = resolveProvider({
-        provider: providerId,
+        provider: input.provider,
         model: input.model,
         transport: input.transport,
         apiKey: input.apiKey,
@@ -56,6 +60,7 @@ export function resolveLaunchPlan(input) {
         resourceGroup: input.resourceGroup,
         endpointName: input.endpointName,
         authCommand: input.authCommand,
+        profile: input.profile,
     });
     // Merge extra provider args into params
     if (input.providerArgs) {
@@ -71,29 +76,34 @@ export function resolveLaunchPlan(input) {
         }
         else {
             proxyNeeded = false;
-            proxyReason = `${input.harness} supports ${providerId} natively`;
+            proxyReason = `${input.harness} supports ${providerConfig.provider} natively`;
         }
     }
     else {
         if (input.proxyMode === 'never') {
-            throw new Error(`${input.harness} does not support ${providerId} natively. ` +
+            throw new Error(`${input.harness} does not support ${providerConfig.provider} natively. ` +
                 `Use --with-proxy-if-needed to auto-launch the proxy.`);
         }
         proxyReason =
-            `${input.harness} does not support ${providerId} natively; ` +
-                `proxy bridges ${providerId} → ${translation.proxyExposedTransport}`;
+            `${input.harness} does not support ${providerConfig.provider} natively; ` +
+                `proxy bridges ${providerConfig.provider} → ${translation.proxyExposedTransport}`;
     }
     const proxy = proxyNeeded
         ? {
-            targetProvider: providerId,
+            targetProvider: providerConfig.provider,
             targetModel: providerConfig.model,
             exposedTransport: translation.proxyExposedTransport ?? 'openai-chat',
             port: input.proxyPort ?? 0,
+            apiBase: providerConfig.params['apiBase'] ? String(providerConfig.params['apiBase']) : undefined,
+            apiKey: providerConfig.auth.apiKey,
+            project: providerConfig.params['project'] ? String(providerConfig.params['project']) : undefined,
+            location: providerConfig.params['region'] ? String(providerConfig.params['region']) : undefined,
+            useVertexAi: providerConfig.provider === 'vertex' || Boolean(providerConfig.params['useVertexAi']),
         }
         : undefined;
     return {
         harness: input.harness,
-        provider: providerId,
+        provider: providerConfig.provider,
         transport: providerConfig.transport,
         model: providerConfig.model,
         proxyNeeded,
@@ -105,14 +115,19 @@ export function resolveLaunchPlan(input) {
     };
 }
 function appendHarnessSessionArgs(plan, session) {
+    const interactive = session.interactive !== false;
     switch (plan.harness) {
         case 'claude':
+            if (session.bridgeInteractive) {
+                plan.args.push('--bare');
+            }
             if (session.resumeId)
                 plan.args.push('--resume', session.resumeId);
             if (session.sessionId)
                 plan.args.push('--session-id', session.sessionId);
-            if (session.prompt)
-                plan.args.push('--print', session.prompt);
+            if (session.prompt && !interactive) {
+                plan.args.push('-p', session.prompt);
+            }
             if (session.maxTurns)
                 plan.args.push('--max-turns', String(session.maxTurns));
             break;
@@ -120,7 +135,7 @@ function appendHarnessSessionArgs(plan, session) {
             if (session.resumeId) {
                 plan.args.unshift('resume', session.resumeId);
             }
-            else if (session.prompt) {
+            else if (session.prompt && !interactive) {
                 plan.args.unshift('exec', session.prompt);
             }
             break;
@@ -128,10 +143,14 @@ function appendHarnessSessionArgs(plan, session) {
             if (session.prompt)
                 plan.args.push('--prompt', session.prompt);
             break;
+        case 'pi':
+            if (session.prompt && !interactive) {
+                plan.args.push('--prompt', session.prompt);
+            }
+            break;
         case 'opencode':
             if (session.resumeId)
                 plan.args.push('--session', session.resumeId);
-            // OpenCode has no non-interactive prompt flag; prompt delivered via stdin after launch
             break;
     }
 }
@@ -276,6 +295,7 @@ export async function launchCommand(client, args) {
             resourceGroup: flagStr(args.flags, 'resource-group'),
             endpointName: flagStr(args.flags, 'endpoint-name'),
             authCommand: flagStr(args.flags, 'auth-command'),
+            profile: flagStr(args.flags, 'profile'),
             proxyMode,
             proxyPort: flagNum(args.flags, 'proxy-port'),
             adapter: adapter,
@@ -296,6 +316,7 @@ export async function launchCommand(client, args) {
         model: flagStr(args.flags, 'model'),
         apiKey: flagStr(args.flags, 'api-key'),
         authCommand: flagStr(args.flags, 'auth-command'),
+        profile: flagStr(args.flags, 'profile'),
     });
     if (resolvedConfig.auth.type === 'api_key' && !resolvedConfig.auth.apiKey) {
         const defaults = (await import('@a5c-ai/agent-mux-core')).PROVIDER_DEFAULTS;
@@ -361,6 +382,45 @@ export async function launchCommand(client, args) {
         }
         launchCwd = resolveWorkspaceDefaultCwd(workspace);
     }
+    // Resolve interactive mode (default: true)
+    const interactiveFlag = flagBool(args.flags, 'interactive');
+    const isInteractive = interactiveFlag !== false;
+    // Bridge flags: --bridge-interactive and --bridge-hooks
+    const bridgeInteractive = flagBool(args.flags, 'bridge-interactive') === true;
+    const bridgeHooks = flagBool(args.flags, 'bridge-hooks') === true;
+    if (bridgeInteractive && isInteractive) {
+        const msg = '--bridge-interactive requires --no-interactive';
+        if (jsonMode)
+            printJsonError('VALIDATION_ERROR', msg);
+        else
+            printError(msg);
+        return ExitCode.USAGE_ERROR;
+    }
+    if (bridgeHooks && isInteractive) {
+        const msg = '--bridge-hooks requires --no-interactive';
+        if (jsonMode)
+            printJsonError('VALIDATION_ERROR', msg);
+        else
+            printError(msg);
+        return ExitCode.USAGE_ERROR;
+    }
+    if (bridgeInteractive) {
+        try {
+            const { getBridgeCapabilities } = await import('@a5c-ai/agent-catalog');
+            const caps = getBridgeCapabilities(plan.harness);
+            if (!caps?.interactiveBridge) {
+                const msg = `${plan.harness} does not support interactive bridging`;
+                if (jsonMode)
+                    printJsonError('CAPABILITY_ERROR', msg);
+                else
+                    printError(msg);
+                return ExitCode.USAGE_ERROR;
+            }
+        }
+        catch {
+            // agent-catalog not available — skip capability check
+        }
+    }
     // Append session/prompt args
     const prompt = flagStr(args.flags, 'prompt');
     appendHarnessSessionArgs(plan, {
@@ -368,23 +428,104 @@ export async function launchCommand(client, args) {
         sessionId: flagStr(args.flags, 'session-id'),
         prompt,
         maxTurns: flagNum(args.flags, 'max-turns'),
+        interactive: isInteractive || bridgeInteractive,
+        bridgeInteractive,
     });
+    // Add --model for harnesses that accept it as a CLI arg
+    const modelFlag = flagStr(args.flags, 'model');
+    if (modelFlag && ['pi', 'gemini', 'opencode'].includes(plan.harness)) {
+        plan.args.push('--model', modelFlag);
+    }
+    // --yolo: add harness-specific auto-approve flags resolved through
+    // agent-catalog → atlas graph (LaunchConfig records with commArgs)
+    if (flagBool(args.flags, 'yolo')) {
+        try {
+            const { getYoloLaunchArgs } = await import('@a5c-ai/agent-catalog');
+            const yoloArgs = getYoloLaunchArgs(plan.harness);
+            if (yoloArgs.length > 0) {
+                plan.args.push(...yoloArgs);
+            }
+        }
+        catch {
+            // agent-catalog not available
+        }
+    }
     // Passthrough args after --
     const dashDashIdx = process.argv.indexOf('--');
     if (dashDashIdx >= 0) {
         plan.args.push(...process.argv.slice(dashDashIdx + 1));
     }
+    // Also check parsed positionals for -- separator (handles spawn() without shell)
+    const argsDashIdx = args.positionals.indexOf('--');
+    if (argsDashIdx >= 0) {
+        plan.args.push(...args.positionals.slice(argsDashIdx + 1));
+    }
     // Launch runtime if needed
     let proxyRuntime;
     if (plan.proxyNeeded && plan.proxy) {
         try {
+            // When exposed transport differs from target (e.g., anthropic→foundry),
+            // the proxy needs a completion engine to translate request/response formats.
+            let completionEngine;
+            if ((plan.proxy.targetProvider === 'google' || plan.proxy.targetProvider === 'vertex') && plan.proxy.apiKey) {
+                const { createGoogleCompletionEngine } = await import('./launch-completion-engine.js');
+                completionEngine = createGoogleCompletionEngine({
+                    apiBase: plan.proxy.useVertexAi ? undefined : plan.proxy.apiBase,
+                    apiKey: plan.proxy.apiKey,
+                    targetModel: plan.proxy.targetModel,
+                    provider: plan.proxy.targetProvider,
+                    project: plan.proxy.project,
+                    location: plan.proxy.location,
+                    useVertexAi: plan.proxy.useVertexAi,
+                });
+            }
+            else if (plan.proxy.apiBase && plan.proxy.apiKey) {
+                const { createOpenAICompletionEngine } = await import('./launch-completion-engine.js');
+                completionEngine = createOpenAICompletionEngine({
+                    apiBase: plan.proxy.apiBase,
+                    apiKey: plan.proxy.apiKey,
+                    targetModel: plan.proxy.targetModel,
+                });
+            }
             proxyRuntime = await startTransportMuxRuntime({
                 targetProvider: plan.proxy.targetProvider,
                 targetModel: `${plan.proxy.targetProvider}/${plan.proxy.targetModel}`,
                 exposedTransport: plan.proxy.exposedTransport,
                 port: plan.proxy.port,
+                apiBase: plan.proxy.apiBase,
+                completionEngine,
             });
             proxyRuntime.applyHarnessEnv(plan.env);
+            // Pi ignores OPENAI_BASE_URL — write a models.json config that registers
+            // a custom provider pointing to the local proxy.
+            if (plan.harness === 'pi') {
+                const { writeFileSync, mkdirSync } = await import('node:fs');
+                const { join } = await import('node:path');
+                const piConfigDir = process.env['PI_CODING_AGENT_DIR']
+                    ?? join(process.env['HOME'] ?? process.env['USERPROFILE'] ?? '/tmp', '.pi', 'agent');
+                mkdirSync(piConfigDir, { recursive: true });
+                const modelsConfig = {
+                    providers: {
+                        'amux-proxy': {
+                            baseUrl: `${proxyRuntime.url}/v1`,
+                            api: 'openai-completions',
+                            apiKey: proxyRuntime.authToken ?? 'proxy-token',
+                            models: [{
+                                    id: plan.model,
+                                    reasoning: false,
+                                    input: ['text'],
+                                    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+                                    contextWindow: 128000,
+                                    maxTokens: 16384,
+                                }],
+                        },
+                    },
+                };
+                const modelsPath = join(piConfigDir, 'models.json');
+                writeFileSync(modelsPath, JSON.stringify(modelsConfig, null, 2));
+                plan.args.push('--provider', 'amux-proxy');
+                console.error(`[amux launch] Pi proxy config written to ${modelsPath}, proxy at ${proxyRuntime.url}`);
+            }
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
@@ -395,14 +536,28 @@ export async function launchCommand(client, args) {
             return ExitCode.GENERAL_ERROR;
         }
     }
+    // Bridge hooks: emulate lifecycle hooks when --bridge-hooks is set
+    let bridgeHookEmulator;
+    if (bridgeHooks) {
+        const { BridgeHookEmulator } = await import('./launch-bridge-hooks.js');
+        bridgeHookEmulator = new BridgeHookEmulator({
+            harness: plan.harness,
+            cwd: launchCwd,
+            env: plan.env,
+            sessionId: flagStr(args.flags, 'session-id'),
+            runsDir: plan.env['BABYSITTER_RUNS_DIR'] || undefined,
+            verbose: flagBool(args.flags, 'debug') === true,
+        });
+        await bridgeHookEmulator.emulateSessionStart();
+    }
     // Spawn harness
-    const isInteractive = !prompt;
-    let child;
+    let child = null;
     let ptyProcess = null;
     if (isInteractive) {
-        // Try to use node-pty for TUI harnesses
+        // Interactive mode: full TTY passthrough. If a prompt is provided, it's
+        // injected as initial stdin after the harness starts (like typing it in).
         try {
-            const nodePty = require('node-pty'); // dynamic require — node-pty is optional
+            const nodePty = await import('node-pty');
             ptyProcess = nodePty.spawn(plan.command, plan.args, {
                 name: 'xterm-256color',
                 cols: process.stdout.columns || 80,
@@ -410,8 +565,61 @@ export async function launchCommand(client, args) {
                 cwd: launchCwd,
                 env: { ...process.env, ...plan.env },
             });
-            // Pipe PTY to stdout and stdin to PTY
-            ptyProcess.onData((data) => process.stdout.write(data));
+            // End-of-turn detection: parse PTY output through adapter's event system
+            let turnDetected = false;
+            let lineBuf = '';
+            let assembler = null;
+            let adapter = null;
+            try {
+                const core = await import('@a5c-ai/agent-mux-core');
+                assembler = new core.StreamAssembler();
+                // Resolve the adapter for this harness to use its parseEvent
+                const adaptersModule = await import('@a5c-ai/agent-mux-adapters');
+                const factory = adaptersModule.getAdapterFactory?.(plan.harness);
+                adapter = factory ? factory() : null;
+            }
+            catch { /* core/adapters not available */ }
+            // Pipe PTY to stdout + feed through event parser for turn detection
+            ptyProcess.onData((data) => {
+                process.stdout.write(data);
+                if (!assembler || !adapter || turnDetected)
+                    return;
+                // Strip ANSI escapes, then feed lines to the event parser
+                const clean = data.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '').replace(/\x1b\][^\x07]*\x07/g, '');
+                lineBuf += clean;
+                let idx;
+                while ((idx = lineBuf.indexOf('\n')) !== -1) {
+                    const line = lineBuf.slice(0, idx).replace(/\r$/, '');
+                    lineBuf = lineBuf.slice(idx + 1);
+                    if (line.length === 0)
+                        continue;
+                    const assembled = assembler.feed(line);
+                    if (assembled === null)
+                        continue;
+                    try {
+                        const ctx = { runId: 'launch', agent: plan.harness, sessionId: undefined, turnIndex: 0, debug: false, outputFormat: 'text', source: 'stdout', assembler, eventCount: 0, lastEventType: null, adapterState: {} };
+                        const result = adapter.parseEvent(assembled, ctx);
+                        if (result === null)
+                            continue;
+                        const events = Array.isArray(result) ? result : [result];
+                        for (const ev of events) {
+                            // Detect turn completion events
+                            if (ev.type === 'message_stop' || ev.type === 'turn_end' || ev.type === 'session_end') {
+                                turnDetected = true;
+                                // Give the harness a moment to flush output, then kill
+                                setTimeout(() => {
+                                    try {
+                                        ptyProcess.kill('SIGTERM');
+                                    }
+                                    catch { /* */ }
+                                }, 1000);
+                                return;
+                            }
+                        }
+                    }
+                    catch { /* parse error — ignore */ }
+                }
+            });
             if (process.stdin.isTTY) {
                 process.stdin.setRawMode(true);
             }
@@ -421,27 +629,170 @@ export async function launchCommand(client, args) {
             process.stdout.on('resize', () => {
                 ptyProcess.resize(process.stdout.columns || 80, process.stdout.rows || 24);
             });
+            // Inject prompt as initial input after a short delay for the harness to start
+            if (prompt && !plan.args.some(a => a === prompt)) {
+                setTimeout(() => ptyProcess.write(prompt + '\n'), 500);
+            }
             // Create a fake ChildProcess-like for signal handling
             child = { pid: ptyProcess.pid, kill: (sig) => ptyProcess.kill(sig) };
         }
         catch {
-            // node-pty not available, fall back to stdio inherit
+            // node-pty not available, fall back to stdio inherit with stdin pipe for prompt injection
             const { spawn } = await import('node:child_process');
             child = spawn(plan.command, plan.args, {
-                stdio: 'inherit',
+                stdio: prompt ? ['pipe', 'inherit', 'inherit'] : 'inherit',
                 env: { ...process.env, ...plan.env },
                 cwd: launchCwd,
-                shell: false,
+                shell: process.platform === 'win32',
             });
         }
     }
+    else if (bridgeInteractive) {
+        // Bridge-interactive: spawn via PTY like interactive mode, but:
+        // - No human stdin forwarding
+        // - Parse PTY output via adapter for structured events
+        // - Emit events as NDJSON to stdout
+        // - Auto-kill on turn completion
+        // - Buffer PTY output to avoid pipe deadlock (stdout is piped)
+        let nodePty;
+        try {
+            nodePty = await import('node-pty');
+        }
+        catch {
+            const msg = '--bridge-interactive requires node-pty but it is not available. Install it with: npm install node-pty';
+            if (jsonMode)
+                printJsonError('SPAWN_ERROR', msg);
+            else
+                printError(msg);
+            return ExitCode.GENERAL_ERROR;
+        }
+        ptyProcess = nodePty.spawn(plan.command, plan.args, {
+            name: 'xterm-256color',
+            cols: 120,
+            rows: 40,
+            cwd: launchCwd,
+            env: { ...process.env, ...plan.env },
+        });
+        // Set up adapter + assembler for parsing PTY output into structured events
+        let assembler = null;
+        let adapter = null;
+        try {
+            const core = await import('@a5c-ai/agent-mux-core');
+            assembler = new core.StreamAssembler();
+            const adaptersModule = await import('@a5c-ai/agent-mux-adapters');
+            const factory = adaptersModule.getAdapterFactory?.(plan.harness);
+            adapter = factory ? factory() : null;
+        }
+        catch { /* core/adapters not available — raw output only */ }
+        /** Emit a bridge event as NDJSON, deferred to avoid blocking PTY callback. */
+        function emitBridgeEvent(event) {
+            const line = JSON.stringify(event) + '\n';
+            setImmediate(() => {
+                try {
+                    process.stdout.write(line);
+                }
+                catch { /* stdout closed */ }
+            });
+        }
+        let turnComplete = false;
+        let lineBuf = '';
+        let outputBuf = '';
+        let eventCount = 0;
+        const parseCtx = {
+            runId: 'bridge',
+            agent: plan.harness,
+            sessionId: undefined,
+            turnIndex: 0,
+            debug: false,
+            outputFormat: 'text',
+            source: 'stdout',
+            assembler: assembler,
+            eventCount: 0,
+            lastEventType: null,
+            adapterState: {},
+        };
+        ptyProcess.onData((data) => {
+            // Buffer all PTY output — never write synchronously to stdout (pipe deadlock)
+            outputBuf += data;
+            if (!assembler || !adapter || turnComplete)
+                return;
+            // Strip ANSI escapes, then feed lines to the event parser
+            const clean = data.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '').replace(/\x1b\][^\x07]*\x07/g, '');
+            lineBuf += clean;
+            let idx;
+            while ((idx = lineBuf.indexOf('\n')) !== -1) {
+                const line = lineBuf.slice(0, idx).replace(/\r$/, '');
+                lineBuf = lineBuf.slice(idx + 1);
+                if (line.length === 0)
+                    continue;
+                const assembled = assembler.feed(line);
+                if (assembled === null)
+                    continue;
+                try {
+                    parseCtx.eventCount = eventCount;
+                    const result = adapter.parseEvent(assembled, parseCtx);
+                    if (result === null)
+                        continue;
+                    const events = Array.isArray(result) ? result : [result];
+                    for (const ev of events) {
+                        eventCount++;
+                        parseCtx.lastEventType = ev.type;
+                        // Emit as NDJSON bridge event
+                        emitBridgeEvent({
+                            type: ev.type,
+                            timestamp: new Date().toISOString(),
+                            data: ev,
+                        });
+                        // Detect turn completion events — schedule PTY termination
+                        if (ev.type === 'message_stop' || ev.type === 'turn_end' || ev.type === 'session_end') {
+                            turnComplete = true;
+                            setTimeout(() => {
+                                try {
+                                    ptyProcess.kill('SIGTERM');
+                                }
+                                catch { /* */ }
+                            }, 1000);
+                            return;
+                        }
+                    }
+                }
+                catch { /* parse error — ignore */ }
+            }
+        });
+        // Inject prompt as initial input after harness starts (like interactive mode)
+        if (prompt) {
+            setTimeout(() => ptyProcess.write(prompt + '\n'), 500);
+        }
+        // Create a fake ChildProcess-like for signal handling
+        child = { pid: ptyProcess.pid, kill: (sig) => ptyProcess.kill(sig) };
+        // On PTY exit, flush remaining buffered text as a final output event
+        const origOnExit = ptyProcess.onExit.bind(ptyProcess);
+        const exitPromise = new Promise((resolve) => {
+            origOnExit(({ exitCode: code }) => {
+                // Flush any remaining output as a final bridge event
+                if (outputBuf.length > 0) {
+                    emitBridgeEvent({
+                        type: 'output',
+                        timestamp: new Date().toISOString(),
+                        data: { text: outputBuf },
+                    });
+                    outputBuf = '';
+                }
+                resolve(code);
+            });
+        });
+        // Store the exit promise so main exit handler can use it
+        child.__bridgeExitPromise = exitPromise;
+    }
     else {
+        // Non-interactive: plain spawn. Each harness handles non-interactive mode
+        // internally (claude -p, codex exec, gemini --prompt, pi stdin).
         const { spawn } = await import('node:child_process');
         child = spawn(plan.command, plan.args, {
             stdio: ['pipe', 'inherit', 'inherit'],
             env: { ...process.env, ...plan.env },
             cwd: launchCwd,
-            shell: false,
+            shell: process.platform === 'win32',
         });
     }
     if (flagBool(args.flags, 'observe')) {
@@ -472,32 +823,89 @@ export async function launchCommand(client, args) {
             }
             catch { /* process may already be dead */ }
         }
+        else if (ptyProcess) {
+            // PTY child runs in its own session — kill the process group to avoid orphans
+            try {
+                process.kill(-ptyProcess.pid, sig);
+            }
+            catch { /* */ }
+            try {
+                ptyProcess.kill(sig);
+            }
+            catch { /* */ }
+        }
         else {
             child.kill(sig);
         }
     };
     process.on('SIGINT', forwardSignal);
     process.on('SIGTERM', forwardSignal);
-    if (!isInteractive && prompt && child.stdin) {
-        child.stdin.write(prompt);
-        child.stdin.end();
-    }
-    const exitCode = await new Promise((resolve) => {
-        if (ptyProcess) {
-            ptyProcess.onExit(({ exitCode: code }) => {
-                if (process.stdin.isTTY)
-                    process.stdin.setRawMode(false);
-                resolve(code);
-            });
+    // Ensure PTY cleanup on exit
+    if (ptyProcess) {
+        process.on('exit', () => { try {
+            ptyProcess.kill('SIGKILL');
+        }
+        catch { /* */ } });
+    }
+    const promptPassedAsPiFlag = plan.harness === 'pi' && !isInteractive && plan.args.includes('--prompt');
+    if (prompt && child.stdin && !ptyProcess && !promptPassedAsPiFlag) {
+        child.stdin.write(prompt + '\n');
+        if (!isInteractive) {
+            child.stdin.end();
         }
         else {
-            child.on('exit', (code, signal) => {
-                resolve(signal ? 128 + (signal === 'SIGINT' ? 2 : 15) : (code ?? 1));
-            });
+            // Interactive with stdin pipe (no PTY): reconnect terminal stdin after prompt injection
+            process.stdin.resume();
+            process.stdin.pipe(child.stdin);
         }
-    });
+    }
+    const exitCode = await (child.__bridgeExitPromise
+        ? child.__bridgeExitPromise
+        : new Promise((resolve) => {
+            if (ptyProcess) {
+                ptyProcess.onExit(({ exitCode: code }) => {
+                    if (process.stdin.isTTY)
+                        process.stdin.setRawMode(false);
+                    resolve(code);
+                });
+            }
+            else {
+                child.on('exit', (code, signal) => {
+                    resolve(signal ? 128 + (signal === 'SIGINT' ? 2 : 15) : (code ?? 1));
+                });
+            }
+        }));
     process.off('SIGINT', forwardSignal);
     process.off('SIGTERM', forwardSignal);
+    // Bridge hooks: emulate stop hook and re-spawn if shouldContinue
+    if (bridgeHookEmulator) {
+        let stopResult = await bridgeHookEmulator.emulateStop();
+        while (stopResult.shouldContinue && stopResult.resumeId) {
+            // Re-spawn with --resume to continue the session
+            const resumePlan = { ...plan, args: [...plan.args] };
+            appendHarnessSessionArgs(resumePlan, {
+                resumeId: stopResult.resumeId,
+                interactive: false,
+            });
+            const { spawn: resumeSpawn } = await import('node:child_process');
+            const resumeChild = resumeSpawn(resumePlan.command, resumePlan.args, {
+                stdio: ['pipe', 'inherit', 'inherit'],
+                env: { ...process.env, ...resumePlan.env },
+                cwd: launchCwd,
+                shell: process.platform === 'win32',
+            });
+            if (resumeChild.stdin) {
+                resumeChild.stdin.end();
+            }
+            await new Promise((resolve) => {
+                resumeChild.on('exit', (code, signal) => {
+                    resolve(signal ? 128 + (signal === 'SIGINT' ? 2 : 15) : (code ?? 1));
+                });
+            });
+            stopResult = await bridgeHookEmulator.emulateStop();
+        }
+        await bridgeHookEmulator.emulateSessionEnd();
+    }
     if (proxyRuntime) {
         await proxyRuntime.stop();
     }