@a5c-ai/agent-mux-cli 0.4.10-staging.ff407b73 → 5.0.1-staging.00fa5317c

package/dist/commands/launch.js

@@ -11,9 +11,11 @@ import { startTransportMuxRuntime } from '@a5c-ai/transport-mux';
 import { flagStr, flagNum, flagBool, flagArr } from '../parse-args.js';
 import { ExitCode } from '../exit-codes.js';
 import { printError, printJsonError } from '../output.js';
+import { resolve as resolvePath } from 'node:path';
 /** 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 +31,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 +42,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 +61,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 +77,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 +116,22 @@ 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.prompt && interactive && !session.bridgeInteractive) {
+                plan.args.push(session.prompt);
+            }
             if (session.maxTurns)
                 plan.args.push('--max-turns', String(session.maxTurns));
             break;
@@ -120,7 +139,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,16 +147,186 @@ function appendHarnessSessionArgs(plan, session) {
             if (session.prompt)
                 plan.args.push('--prompt', session.prompt);
             break;
+        case 'pi':
+            if (session.prompt && !interactive && !session.bridgeInteractive) {
+                plan.args.push('--print', 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;
     }
 }
 // ---------------------------------------------------------------------------
 // Provider auth validation helper
 // ---------------------------------------------------------------------------
+async function prepareHarnessAutomationState(harness, cwd, env) {
+    if (!isAutomationPreseedEnabled(env))
+        return;
+    if (harness === 'claude')
+        await prepareClaudeAutomationState(cwd, env);
+    if (harness === 'codex')
+        await prepareCodexAutomationState(cwd);
+}
+function isAutomationPreseedEnabled(env) {
+    return env['AMUX_PRESEED_HARNESS_ONBOARDING'] === '1' || env['CI'] === 'true' || env['GITHUB_ACTIONS'] === 'true' || process.env['CI'] === 'true' || process.env['GITHUB_ACTIONS'] === 'true';
+}
+function automationHome() {
+    return process.env['HOME'] || process.env['USERPROFILE'];
+}
+async function readJsonObject(filePath) {
+    try {
+        const fs = await import('node:fs/promises');
+        const value = JSON.parse(await fs.readFile(filePath, 'utf8'));
+        return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+    }
+    catch {
+        return {};
+    }
+}
+async function writeJsonObject(filePath, value) {
+    const { dirname } = await import('node:path');
+    const fs = await import('node:fs/promises');
+    await fs.mkdir(dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+function recordObject(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function numberAtLeast(value, minimum) {
+    const numeric = Number(value);
+    return Number.isFinite(numeric) ? Math.max(numeric, minimum) : minimum;
+}
+function approveClaudeCustomApiKey(config, env) {
+    const apiKey = env['ANTHROPIC_API_KEY'] || process.env['ANTHROPIC_API_KEY'];
+    if (!apiKey)
+        return;
+    const fingerprint = apiKey.slice(-20);
+    const responses = recordObject(config['customApiKeyResponses']);
+    const approved = Array.isArray(responses['approved']) ? responses['approved'].filter((value) => typeof value === 'string') : [];
+    const rejected = Array.isArray(responses['rejected']) ? responses['rejected'].filter((value) => typeof value === 'string' && value !== fingerprint) : [];
+    if (!approved.includes(fingerprint))
+        approved.push(fingerprint);
+    config['customApiKeyResponses'] = { ...responses, approved, rejected };
+}
+const AUTOMATION_CLAUDE_ONBOARDING_VERSION = '999.999.999';
+async function prepareClaudeAutomationState(cwd, env) {
+    const home = automationHome();
+    if (!home)
+        return;
+    const { join, resolve } = await import('node:path');
+    const settingsPath = join(home, '.claude', 'settings.json');
+    const settings = await readJsonObject(settingsPath);
+    await writeJsonObject(settingsPath, {
+        ...settings,
+        theme: typeof settings['theme'] === 'string' ? settings['theme'] : 'dark',
+        skipDangerousModePermissionPrompt: true,
+        permissions: {
+            allow: [
+                'Bash(*)', 'Read(*)', 'Write(*)', 'Edit(*)', 'Glob(*)', 'Grep(*)',
+                'WebFetch(*)', 'WebSearch(*)', 'Agent(*)', 'Skill(*)',
+                'TodoRead', 'TodoWrite',
+            ],
+            deny: [],
+            ...recordObject(settings['permissions']),
+        },
+    });
+    const configPath = join(home, '.claude.json');
+    const config = await readJsonObject(configPath);
+    approveClaudeCustomApiKey(config, env);
+    const projects = recordObject(config['projects']);
+    const projectPath = resolve(cwd).replace(/\\/g, '/');
+    const project = recordObject(projects[projectPath]);
+    projects[projectPath] = {
+        allowedTools: [],
+        mcpContextUris: [],
+        mcpServers: {},
+        enabledMcpjsonServers: [],
+        disabledMcpjsonServers: [],
+        hasClaudeMdExternalIncludesApproved: false,
+        hasClaudeMdExternalIncludesWarningShown: false,
+        ...project,
+        projectOnboardingSeenCount: numberAtLeast(project['projectOnboardingSeenCount'], 1),
+        hasTrustDialogAccepted: true,
+        hasCompletedProjectOnboarding: true,
+        lastVersionBase: AUTOMATION_CLAUDE_ONBOARDING_VERSION,
+    };
+    await writeJsonObject(configPath, {
+        ...config,
+        numStartups: numberAtLeast(config['numStartups'], 1),
+        hasCompletedOnboarding: true,
+        lastOnboardingVersion: AUTOMATION_CLAUDE_ONBOARDING_VERSION,
+        lastReleaseNotesSeen: AUTOMATION_CLAUDE_ONBOARDING_VERSION,
+        hasIdeOnboardingBeenShown: { vscode: true, ...recordObject(config['hasIdeOnboardingBeenShown']) },
+        officialMarketplaceAutoInstallAttempted: true,
+        officialMarketplaceAutoInstalled: true,
+        projects,
+    });
+}
+function extractPromptArtifactPaths(prompt, cwd) {
+    if (!prompt)
+        return [];
+    const matches = prompt.matchAll(/(?:^|[\s`"'])((?:\.\/)?\.a5c-live-test\/[^\s`"')]+)/g);
+    const paths = new Set();
+    for (const match of matches) {
+        const cleaned = match[1]?.replace(/[.,;:!?]+$/, '');
+        if (!cleaned)
+            continue;
+        paths.add(resolvePath(cwd, cleaned.replace(/^\.\//, '')));
+    }
+    return [...paths];
+}
+function startPromptArtifactCompletionMonitor(input) {
+    const expectedPaths = extractPromptArtifactPaths(input.prompt, input.cwd);
+    if (expectedPaths.length === 0)
+        return undefined;
+    const lastSizes = new Map();
+    return setInterval(() => {
+        void (async () => {
+            const fs = await import('node:fs/promises');
+            for (const expectedPath of expectedPaths) {
+                try {
+                    const stat = await fs.stat(expectedPath);
+                    if (!stat.isFile() || stat.size <= 0)
+                        continue;
+                    if (lastSizes.get(expectedPath) === stat.size) {
+                        input.onComplete();
+                        return;
+                    }
+                    lastSizes.set(expectedPath, stat.size);
+                }
+                catch {
+                    // expected artifact not written yet
+                }
+            }
+        })();
+    }, 1000);
+}
+async function prepareCodexAutomationState(cwd) {
+    const home = automationHome();
+    if (!home)
+        return;
+    const { join, resolve, dirname } = await import('node:path');
+    const fs = await import('node:fs/promises');
+    const configPath = join(home, '.codex', 'config.toml');
+    await fs.mkdir(dirname(configPath), { recursive: true });
+    let config = '';
+    try {
+        config = await fs.readFile(configPath, 'utf8');
+    }
+    catch {
+        config = '';
+    }
+    const projectPath = resolve(cwd);
+    const basicKey = JSON.stringify(projectPath);
+    const literalKey = `'${projectPath}'`;
+    if (config.includes(`[projects.${basicKey}]`) || config.includes(`[projects.${literalKey}]`))
+        return;
+    const prefix = config.trimEnd();
+    const addition = `[projects.${basicKey}]\ntrust_level = "trusted"\n`;
+    await fs.writeFile(configPath, `${prefix}${prefix ? '\n\n' : ''}${addition}`);
+}
 async function validateProviderAuth(plan) {
     const { execSync } = await import('node:child_process');
     try {
@@ -276,6 +465,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 +486,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 +552,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 +598,107 @@ 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);
+            if (plan.env['ANTHROPIC_API_KEY']) {
+                plan.env['ANTHROPIC_AUTH_TOKEN'] = '';
+            }
+            // 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 +709,40 @@ 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();
+    }
+    await prepareHarnessAutomationState(plan.harness, launchCwd, plan.env);
     // Spawn harness
-    const isInteractive = !prompt;
-    let child;
+    let child = null;
     let ptyProcess = null;
+    let ptyTerminationExpected = false;
+    const ptyCleanup = [];
+    const completePtyPrompt = () => {
+        if (!ptyProcess || ptyTerminationExpected)
+            return;
+        ptyTerminationExpected = true;
+        try {
+            ptyProcess.kill('SIGTERM');
+        }
+        catch { /* */ }
+    };
     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 +750,70 @@ 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
+            let interactiveOutputBuf = '';
+            let interactiveApiKeyHandled = false;
+            let interactiveBypassHandled = false;
+            ptyProcess.onData((data) => {
+                process.stdout.write(data);
+                interactiveOutputBuf += data;
+                // Auto-respond to Claude Code onboarding prompts
+                const stripped = interactiveOutputBuf.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+                if (!interactiveApiKeyHandled && stripped.includes('usethisAPIkey')) {
+                    interactiveApiKeyHandled = true;
+                    setTimeout(() => ptyProcess.write('\x1b[A\r'), 200);
+                }
+                if (!interactiveBypassHandled && stripped.includes('BypassPermissionsmode')) {
+                    interactiveBypassHandled = true;
+                    setTimeout(() => ptyProcess.write('\x1b[B\r'), 200);
+                }
+                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 end the PTY.
+                                setTimeout(completePtyPrompt, 1000);
+                                return;
+                            }
+                        }
+                    }
+                    catch { /* parse error — ignore */ }
+                }
+            });
             if (process.stdin.isTTY) {
                 process.stdin.setRawMode(true);
             }
@@ -421,27 +823,324 @@ export async function launchCommand(client, args) {
             process.stdout.on('resize', () => {
                 ptyProcess.resize(process.stdout.columns || 80, process.stdout.rows || 24);
             });
+            if (prompt && plan.args.some(a => a === prompt)) {
+                let artifactMonitor;
+                artifactMonitor = startPromptArtifactCompletionMonitor({
+                    prompt,
+                    cwd: launchCwd,
+                    onComplete: () => {
+                        if (artifactMonitor)
+                            clearInterval(artifactMonitor);
+                        completePtyPrompt();
+                    },
+                });
+                ptyCleanup.push(() => { if (artifactMonitor)
+                    clearInterval(artifactMonitor); });
+            }
+            // Inject prompt after observed onboarding prompts are dismissed.
+            if (prompt && !plan.args.some(a => a === prompt)) {
+                const startedAt = Date.now();
+                let promptInjected = false;
+                let artifactMonitor;
+                const injectPrompt = () => {
+                    if (promptInjected)
+                        return;
+                    promptInjected = true;
+                    ptyProcess.write(prompt);
+                    setTimeout(() => ptyProcess.write('\r'), 500);
+                    artifactMonitor = startPromptArtifactCompletionMonitor({
+                        prompt,
+                        cwd: launchCwd,
+                        onComplete: () => {
+                            if (artifactMonitor)
+                                clearInterval(artifactMonitor);
+                            completePtyPrompt();
+                        },
+                    });
+                    ptyCleanup.push(() => { if (artifactMonitor)
+                        clearInterval(artifactMonitor); });
+                };
+                const checkAndInject = () => {
+                    if (promptInjected)
+                        return;
+                    if (interactiveOutputBuf.length === 0) {
+                        if (Date.now() - startedAt >= 1000)
+                            injectPrompt();
+                        else
+                            setTimeout(checkAndInject, 100);
+                        return;
+                    }
+                    const s = interactiveOutputBuf.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+                    if (interactiveApiKeyHandled || interactiveBypassHandled) {
+                        setTimeout(injectPrompt, 2000);
+                    }
+                    else if (s.includes('APIkey') || s.includes('Bypass')) {
+                        setTimeout(checkAndInject, 500);
+                    }
+                    else {
+                        setTimeout(injectPrompt, 3000);
+                    }
+                };
+                checkAndInject();
+            }
             // 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)
+        // Pre-create full Claude Code automation state to skip all onboarding prompts
+        if (plan.harness === 'claude') {
+            await prepareClaudeAutomationState(launchCwd, plan.env);
+        }
+        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;
+        let apiKeyPromptHandled = false;
+        let bypassPromptHandled = false;
+        let idleTimer = null;
+        const IDLE_TIMEOUT_MS = 30_000;
+        const harnessesWithEndEvents = new Set(['claude', 'codex', 'gemini', 'opencode']);
+        const useIdleTimeout = !harnessesWithEndEvents.has(plan.harness);
+        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;
+            // Auto-respond to Claude Code interactive prompts that block automation.
+            // ANSI cursor-move codes replace spaces, so stripped text is concatenated.
+            const stripped = outputBuf.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+            if (!apiKeyPromptHandled && stripped.includes('usethisAPIkey')) {
+                apiKeyPromptHandled = true;
+                // Default is "No (recommended)". Send Up arrow + Enter to select "Yes".
+                setTimeout(() => ptyProcess.write('\x1b[A\r'), 200);
+            }
+            if (!bypassPromptHandled && stripped.includes('BypassPermissionsmode')) {
+                bypassPromptHandled = true;
+                // Default is "No, exit". Send Down arrow + Enter to select "Yes, I accept".
+                setTimeout(() => ptyProcess.write('\x1b[B\r'), 200);
+            }
+            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;
+                            if (idleTimer)
+                                clearTimeout(idleTimer);
+                            setTimeout(completePtyPrompt, 1000);
+                            return;
+                        }
+                        // Idle timeout fallback for harnesses without structured end events (Pi).
+                        if (useIdleTimeout) {
+                            if (idleTimer)
+                                clearTimeout(idleTimer);
+                            idleTimer = setTimeout(() => {
+                                if (!turnComplete && eventCount > 0) {
+                                    turnComplete = true;
+                                    completePtyPrompt();
+                                }
+                            }, IDLE_TIMEOUT_MS);
+                        }
+                    }
+                }
+                catch { /* parse error — ignore */ }
+            }
+        });
+        // Inject prompt after observed onboarding prompts are dismissed.
+        // If the PTY stays silent, inject after a short startup grace period because
+        // some harnesses wait for input without rendering an initial prompt.
+        if (prompt) {
+            const startedAt = Date.now();
+            let promptInjected = false;
+            let artifactMonitor;
+            const injectPrompt = () => {
+                if (promptInjected)
+                    return;
+                promptInjected = true;
+                ptyProcess.write(prompt);
+                setTimeout(() => ptyProcess.write('\r'), 500);
+                artifactMonitor = startPromptArtifactCompletionMonitor({
+                    prompt,
+                    cwd: launchCwd,
+                    onComplete: () => {
+                        if (artifactMonitor)
+                            clearInterval(artifactMonitor);
+                        completePtyPrompt();
+                    },
+                });
+                ptyCleanup.push(() => { if (artifactMonitor)
+                    clearInterval(artifactMonitor); });
+            };
+            const checkAndInject = () => {
+                if (promptInjected)
+                    return;
+                if (outputBuf.length === 0) {
+                    if (Date.now() - startedAt >= 1000)
+                        injectPrompt();
+                    else
+                        setTimeout(checkAndInject, 100);
+                    return;
+                }
+                const stripped = outputBuf.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+                if (apiKeyPromptHandled || bypassPromptHandled) {
+                    setTimeout(injectPrompt, 2000);
+                }
+                else if (stripped.includes('APIkey') || stripped.includes('Bypass')) {
+                    setTimeout(checkAndInject, 500);
+                }
+                else {
+                    setTimeout(injectPrompt, 3000);
+                }
+            };
+            checkAndInject();
+        }
+        // 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'],
+            stdio: ['pipe', 'pipe', 'inherit'],
             env: { ...process.env, ...plan.env },
             cwd: launchCwd,
-            shell: false,
+            shell: process.platform === 'win32',
+        });
+        // Pipe stdout through + idle-timeout kill for harnesses that don't exit
+        // after completing a non-interactive task (e.g., Pi doesn't exit on its own).
+        // Harnesses with proper exit behavior (claude -p, codex exec) don't need this.
+        const niUseIdleKill = !new Set(['claude', 'codex', 'gemini', 'opencode']).has(plan.harness);
+        let niIdleTimer = null;
+        let niHasOutput = false;
+        const NI_IDLE_TIMEOUT_MS = 30_000;
+        child.stdout?.on('data', (chunk) => {
+            process.stdout.write(chunk);
+            niHasOutput = true;
+            if (niUseIdleKill) {
+                if (niIdleTimer)
+                    clearTimeout(niIdleTimer);
+                niIdleTimer = setTimeout(() => {
+                    if (niHasOutput) {
+                        try {
+                            child.kill('SIGTERM');
+                        }
+                        catch { /* */ }
+                    }
+                }, NI_IDLE_TIMEOUT_MS);
+            }
         });
     }
     if (flagBool(args.flags, 'observe')) {
@@ -472,32 +1171,98 @@ 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();
+    // Ensure PTY cleanup on exit
+    if (ptyProcess) {
+        process.on('exit', () => { try {
+            ptyProcess.kill('SIGKILL');
+        }
+        catch { /* */ } });
     }
-    const exitCode = await new Promise((resolve) => {
-        if (ptyProcess) {
-            ptyProcess.onExit(({ exitCode: code }) => {
-                if (process.stdin.isTTY)
-                    process.stdin.setRawMode(false);
-                resolve(code);
-            });
+    const promptPassedAsFlag = (plan.harness === 'pi' && !isInteractive && plan.args.includes('--print'));
+    if (prompt && child.stdin && !ptyProcess && !promptPassedAsFlag) {
+        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);
         }
-    });
+    }
+    // Close stdin for harnesses where prompt was passed as a CLI flag (not via stdin)
+    // to prevent the process from hanging waiting for interactive input.
+    if (promptPassedAsFlag && child.stdin && !ptyProcess) {
+        child.stdin.end();
+    }
+    let 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));
+                });
+            }
+        }));
+    for (const cleanup of ptyCleanup.splice(0))
+        cleanup();
+    if (ptyTerminationExpected && exitCode !== 0)
+        exitCode = 0;
     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();
     }