aiwcli 0.15.7 → 0.17.0

package/dist/lib/multiplexers/tmux.js

@@ -1,42 +1,21 @@
 /**
  * TmuxMultiplexer — unified tmux backend.
- * Consolidates TmuxLauncher + launchInTmuxSession + command building from pane-driver.
+ * Composes with BashAdapter for command building.
+ * Owns: split direction resolution, tmux session config, Windows bootstrap.
  */
 import { execSync } from 'node:child_process';
 import * as fs from 'node:fs';
-import { cleanClaudeEnv, getLastLine, spawnAttached, splitFlagFromDimensions } from '../mux-utils.js';
+import { sanitizedProcessEnv } from '../env-sanitizer.js';
+import { PANE_HOLD_MESSAGE, getLastLine, spawnAttached, splitFlagFromDimensions } from '../mux-utils.js';
 import { isNonWindowsPlatform, isWindowsPlatform } from '../runtime/platform-adapter.js';
-import { cleanupSentinelIpc, createSentinelIpcPaths } from '../runtime/sentinel-ipc.js';
 import { execFileAsync, findExecutable } from '../runtime/subprocess-utils.js';
-import { wrapSentinelSh } from '../sentinel-wrapper.js';
+import { BashAdapter } from '../shell-adapters/bash-adapter.js';
 import { findBestSplit, listPanes } from '../tmux-pane-placement.js';
-import { quoteForSh, toMsysPosixPath } from '../tmux-primitives.js';
-import { buildShellCommand, buildTmuxRuntimeBootstrapCommands } from '../tmux-session.js';
-/** @internal */
-export function buildEnvPrefix(env) {
-    return Object.entries(env)
-        .map(([key, value]) => `${key}=${quoteForSh(value)}`)
-        .join(' ');
-}
-/** @internal */
-export function buildShToolCommand(params) {
-    const { toolPath, args, env, mode, promptPath, promptText } = params;
-    const envPrefix = buildEnvPrefix(env);
-    const commandArgs = buildCommandArgs(args, mode, promptText);
-    const argPart = commandArgs.map((arg) => quoteForSh(arg)).join(' ');
-    const base = [envPrefix, quoteForSh(toolPath), argPart]
-        .filter(Boolean)
-        .join(' ');
-    if (mode === 'exec' && promptPath) {
-        return `${base} < ${quoteForSh(promptPath)}`;
-    }
-    return base;
-}
-/** @internal */
-export function buildCommandArgs(args, mode, promptText) {
-    if (mode !== 'repl' || promptText === undefined)
-        return args;
-    return [...args, promptText];
+import { toMsysPosixPath } from '../tmux-primitives.js';
+import { buildShellCommand, buildTmuxRuntimeBootstrapCommands, configureTmuxSession } from '../tmux-session.js';
+/** @internal — translate unified SplitDirection to tmux flag. */
+export function toTmuxSplitFlag(direction) {
+    return direction === 'horizontal' ? '-h' : '-v';
 }
 /** @internal */
 export function withWindowsTmuxBootstrap(command, platform = process.platform) {
@@ -45,15 +24,25 @@ export function withWindowsTmuxBootstrap(command, platform = process.platform) {
     const bootstrap = buildTmuxRuntimeBootstrapCommands(platform).join('; ');
     return `${bootstrap}; ${command}`;
 }
-async function resolveToolForBash(toolName) {
-    const bash = findExecutable('bash');
-    if (!bash)
-        return null;
-    const result = await execFileAsync(bash, ['-lc', `command -v ${toolName}`], {
-        timeout: 3000,
-        env: { ...process.env, MSYS_NO_PATHCONV: '1' },
-    });
-    return result.exitCode === 0 ? result.stdout.trim() || null : null;
+/** @internal */
+export function buildTmuxSplitWindowArgs(params) {
+    const args = ['split-window', params.splitFlag, '-P', '-F', '#{pane_id}'];
+    if (params.cwd) {
+        args.push('-c', params.cwd);
+    }
+    if (params.splitTarget) {
+        args.push('-t', params.splitTarget);
+    }
+    args.push(params.command);
+    return args;
+}
+/** @internal */
+export function buildTmuxCreateSessionArgs(params) {
+    const args = ['new-session'];
+    if (params.reattach)
+        args.push('-A');
+    args.push('-c', params.cwd, '-s', params.sessionName, params.shellCommand);
+    return args;
 }
 async function resolveAutoSplit(tmuxPath, splitTarget) {
     const explicitTarget = splitTarget?.trim();
@@ -83,31 +72,13 @@ async function resolveAutoSplit(tmuxPath, splitTarget) {
         splitTarget: placement.targetPane,
     };
 }
-/** @internal */
-export function buildTmuxSplitWindowArgs(params) {
-    const args = ['split-window', params.splitFlag, '-P', '-F', '#{pane_id}'];
-    if (params.cwd) {
-        args.push('-c', params.cwd);
-    }
-    if (params.splitTarget) {
-        args.push('-t', params.splitTarget);
-    }
-    args.push(params.command);
-    return args;
-}
-/** @internal */
-export function buildTmuxCreateSessionArgs(params) {
-    const args = ['new-session'];
-    if (params.reattach)
-        args.push('-A');
-    args.push('-c', params.cwd, '-s', params.sessionName, params.shellCommand);
-    return args;
-}
 export class TmuxMultiplexer {
     backend = 'tmux';
     tmuxPath;
+    shell;
     constructor(tmuxPath) {
         this.tmuxPath = tmuxPath;
+        this.shell = new BashAdapter();
     }
     static create() {
         const tmuxPath = findExecutable('tmux');
@@ -115,12 +86,21 @@ export class TmuxMultiplexer {
             return null;
         return new TmuxMultiplexer(tmuxPath);
     }
+    resolveStrategy(ctx) {
+        if (ctx.disableMux) {
+            return { strategy: 'inline', reason: 'Multiplexer disabled via --no-tmux' };
+        }
+        if (Boolean(process.env.TMUX)) {
+            return { strategy: 'split', reason: 'Inside tmux session' };
+        }
+        return { strategy: 'create-session', reason: 'Outside tmux — will create new session' };
+    }
     async createSession(options) {
-        const { sessionName, reattach } = options;
+        const { sessionName, reattach, cwd } = options;
         if (!isNonWindowsPlatform()) {
-            return { exitCode: -1, usedMux: false, reason: 'tmux not available on this platform' };
+            return { launched: false, exitCode: -1, backend: this.backend, reason: 'tmux not available on this platform' };
         }
-        // Set default-terminal BEFORE session creation (batched into single invocation)
+        // Set default-terminal BEFORE session creation
         try {
             execSync(String.raw `tmux start-server \; set -g default-terminal "tmux-256color"`, { stdio: 'ignore', timeout: 3000 });
         }
@@ -139,119 +119,98 @@ export class TmuxMultiplexer {
         });
         const args = buildTmuxCreateSessionArgs({
             sessionName,
-            cwd: process.cwd(),
+            cwd,
             shellCommand,
             reattach,
         });
-        return spawnAttached('tmux', args, cleanClaudeEnv(), this.backend);
-    }
-    isInsideSession() {
-        return Boolean(process.env.TMUX);
+        return spawnAttached('tmux', args, sanitizedProcessEnv(), this.backend);
     }
-    async kill(paneId) {
-        if (!paneId)
+    async kill(handle) {
+        if (!handle)
             return;
-        await execFileAsync(this.tmuxPath, ['kill-pane', '-t', paneId], { timeout: 3000 });
+        await execFileAsync(this.tmuxPath, ['kill-pane', '-t', handle], { timeout: 3000 });
     }
-    async splitPane(options) {
-        const mode = options.mode ?? 'repl';
-        const args = options.args ?? [];
-        const envVars = options.env ?? {};
-        const cwd = options.cwd ?? process.cwd();
+    async split(options) {
+        const { toolName, args, env, cwd, mode, sentinelPath } = options;
+        // Configure tmux session defaults (mouse, scrollback, color)
+        configureTmuxSession();
         // Resolve tool path
-        const toolPath = findExecutable(options.toolName);
-        if (!toolPath) {
-            return { launched: false, backend: this.backend, reason: `${options.toolName} not found on PATH` };
+        const nativePath = findExecutable(toolName);
+        if (!nativePath) {
+            return { launched: false, backend: this.backend, reason: `${toolName} not found on PATH` };
         }
-        // On Windows with tmux backend, resolve tool path from bash's perspective
-        let effectiveToolPath = toolPath;
-        if (isWindowsPlatform()) {
-            const bashPath = await resolveToolForBash(options.toolName);
-            if (bashPath) {
-                effectiveToolPath = bashPath;
-            }
-            else {
-                return { launched: false, backend: this.backend, reason: `${options.toolName} not found in bash PATH (required for tmux pane)` };
-            }
+        const effectiveToolPath = await this.shell.resolveToolPath(toolName, nativePath);
+        if (!effectiveToolPath) {
+            return { launched: false, backend: this.backend, reason: `${toolName} not found in bash PATH (required for tmux pane)` };
         }
-        // Sentinel IPC for exit code tracking
-        const useSentinel = options.sentinel !== false;
-        const sentinel = useSentinel ? createSentinelIpcPaths(`aiwcli-pane-${options.toolName}`) : null;
         // Inject COLORTERM=truecolor for tmux
-        const effectiveEnvVars = { COLORTERM: 'truecolor', ...envVars };
+        const effectiveEnv = { COLORTERM: 'truecolor', ...env };
         try {
             const promptText = mode === 'repl' && options.promptPath
                 ? fs.readFileSync(options.promptPath, 'utf8')
                 : undefined;
-            const baseCommand = buildShToolCommand({
+            let baseCommand = this.shell.buildToolCommand({
                 toolPath: effectiveToolPath,
                 args,
-                env: effectiveEnvVars,
+                env: effectiveEnv,
                 mode,
                 promptText,
                 ...(options.promptPath ? { promptPath: options.promptPath } : {}),
             });
-            let paneCommand = baseCommand;
-            if (sentinel) {
-                const holdMessage = options.holdMessage ?? '[aiwcli] Driver exited. Pane held open.';
-                paneCommand = wrapSentinelSh({
-                    command: baseCommand,
-                    sentinelPath: sentinel.sentinelPath,
-                    autoClose: Boolean(options.autoClose),
-                    holdPane: Boolean(options.holdPane),
-                    holdMessage,
-                });
+            if (options.retryOnQuickExit) {
+                baseCommand = this.shell.wrapQuickExitRetry(baseCommand, this.shell.quote(effectiveToolPath));
             }
+            const holdMessage = PANE_HOLD_MESSAGE;
+            const paneCommand = this.shell.wrapSentinel({
+                command: baseCommand,
+                sentinelPath,
+                autoClose: false,
+                holdPane: false,
+                holdMessage,
+            });
             // Resolve split direction
-            const splitDirection = options.split ?? 'auto';
+            const splitDirection = options.split;
             let splitFlag;
             let splitTarget;
             if (splitDirection === 'auto') {
                 try {
-                    const resolved = await resolveAutoSplit(this.tmuxPath, options.splitTarget);
+                    const resolved = await resolveAutoSplit(this.tmuxPath);
                     splitFlag = resolved.splitFlag;
                     splitTarget = resolved.splitTarget;
                 }
                 catch {
                     splitFlag = '-h';
-                    splitTarget = options.splitTarget?.trim();
                 }
             }
             else {
-                splitFlag = splitDirection === 'v' ? '-v' : '-h';
-                splitTarget = options.splitTarget?.trim();
+                splitFlag = toTmuxSplitFlag(splitDirection);
             }
             // Build tmux split-window command
-            const cwdPath = cwd ? (process.platform === 'win32' ? toMsysPosixPath(cwd) : cwd) : undefined;
+            const cwdPath = isWindowsPlatform() ? toMsysPosixPath(cwd) : cwd;
             const bootstrappedCommand = withWindowsTmuxBootstrap(paneCommand);
             const tmuxArgs = buildTmuxSplitWindowArgs({
                 splitFlag,
-                command: `bash -lc ${quoteForSh(bootstrappedCommand)}`,
+                command: `bash -lc ${this.shell.quote(bootstrappedCommand)}`,
                 cwd: cwdPath,
                 splitTarget,
             });
             const split = await execFileAsync(this.tmuxPath, tmuxArgs, { timeout: 5000 });
             if (split.exitCode !== 0) {
-                if (sentinel)
-                    cleanupSentinelIpc(sentinel);
                 return {
                     launched: false,
                     backend: this.backend,
                     reason: 'tmux split-window failed',
-                    stderr: split.stderr.trim() || undefined,
                 };
             }
-            const paneId = getLastLine(split.stdout) || undefined;
+            const handle = getLastLine(split.stdout) || undefined;
             return {
                 launched: true,
                 backend: this.backend,
-                paneId,
-                sentinelPath: sentinel?.sentinelPath,
+                handle,
+                sentinelPath,
             };
         }
         catch (error) {
-            if (sentinel)
-                cleanupSentinelIpc(sentinel);
             return {
                 launched: false,
                 backend: this.backend,

package/dist/lib/multiplexers/wezterm.d.ts

@@ -0,0 +1,38 @@
+/**
+ * WeztermMultiplexer — WezTerm backend for Windows.
+ * Composes with BashAdapter for command building.
+ * Owns: REPL-context gating (resolveStrategy), WezTerm pane management,
+ * holdPane behavior, auto-close command.
+ */
+import type { CreateSessionOptions, LaunchResult, Multiplexer, ResolvedStrategy, SplitOptions, StrategyContext } from '../multiplexer.js';
+type WeztermSplitFlag = '--bottom' | '--right';
+/** @internal — translate unified SplitDirection to wezterm flag. */
+export declare function toWeztermSplitFlag(direction: 'horizontal' | 'vertical'): WeztermSplitFlag;
+/** @internal */
+export declare function buildWeztermSplitArgs(params: {
+    bashPath?: string | undefined;
+    command: string;
+    cwd?: string | undefined;
+    paneId?: string | undefined;
+    splitFlag: WeztermSplitFlag;
+}): string[];
+/** @internal */
+export declare function buildWeztermSpawnArgs(params: {
+    bashPath?: string | undefined;
+    command: string;
+    cwd?: string | undefined;
+}): string[];
+/** @internal */
+export declare function buildWeztermKillArgs(paneId: string): string[];
+export declare class WeztermMultiplexer implements Multiplexer {
+    readonly backend: "wezterm";
+    private readonly weztermPath;
+    private readonly shell;
+    private constructor();
+    static create(): null | WeztermMultiplexer;
+    resolveStrategy(ctx: StrategyContext): ResolvedStrategy;
+    kill(handle: string): Promise<void>;
+    split(options: SplitOptions): Promise<LaunchResult>;
+    createSession(options: CreateSessionOptions): Promise<LaunchResult>;
+}
+export {};

package/dist/lib/multiplexers/wezterm.js

@@ -0,0 +1,225 @@
+/**
+ * WeztermMultiplexer — WezTerm backend for Windows.
+ * Composes with BashAdapter for command building.
+ * Owns: REPL-context gating (resolveStrategy), WezTerm pane management,
+ * holdPane behavior, auto-close command.
+ */
+import * as fs from 'node:fs';
+import { PANE_HOLD_MESSAGE, getLastLine, splitFlagFromDimensions } from '../mux-utils.js';
+import { execFileAsync, findExecutable } from '../runtime/subprocess-utils.js';
+import { BashAdapter } from '../shell-adapters/bash-adapter.js';
+/** @internal — translate unified SplitDirection to wezterm flag. */
+export function toWeztermSplitFlag(direction) {
+    return direction === 'horizontal' ? '--right' : '--bottom';
+}
+/** @internal */
+export function buildWeztermSplitArgs(params) {
+    const args = ['cli', 'split-pane', params.splitFlag];
+    if (params.cwd) {
+        args.push('--cwd', params.cwd);
+    }
+    if (params.paneId) {
+        args.push('--pane-id', params.paneId);
+    }
+    // Use -c (not -lc): login shell profiles may exec another shell (e.g. zsh),
+    // preventing the command from running. Tool paths are already absolute.
+    args.push('--', params.bashPath ?? 'bash', '-c', params.command);
+    return args;
+}
+/** @internal */
+export function buildWeztermSpawnArgs(params) {
+    const args = ['cli', 'spawn', '--new-window'];
+    if (params.cwd) {
+        args.push('--cwd', params.cwd);
+    }
+    args.push('--', params.bashPath ?? 'bash', '-c', params.command);
+    return args;
+}
+/** @internal */
+export function buildWeztermKillArgs(paneId) {
+    return ['cli', 'kill-pane', '--pane-id', paneId];
+}
+/**
+ * Resolve Git Bash path on Windows. WezTerm may resolve bare `bash` to
+ * WSL's bash.exe instead of Git Bash.
+ */
+function resolveGitBash() {
+    return findExecutable('bash');
+}
+async function resolveAutoSplit(weztermPath, currentPaneId) {
+    try {
+        const result = await execFileAsync(weztermPath, ['cli', 'list', '--format', 'json'], { timeout: 3000 });
+        if (result.exitCode !== 0)
+            return '--right';
+        const panes = JSON.parse(result.stdout);
+        const targetId = currentPaneId ?? process.env.WEZTERM_PANE;
+        if (!targetId)
+            return '--right';
+        const pane = panes.find((p) => String(p.pane_id) === targetId);
+        if (!pane?.size)
+            return '--right';
+        const muxFlag = splitFlagFromDimensions(pane.size.cols, pane.size.rows);
+        return muxFlag === '-h' ? '--right' : '--bottom';
+    }
+    catch {
+        return '--right';
+    }
+}
+export class WeztermMultiplexer {
+    backend = 'wezterm';
+    weztermPath;
+    shell;
+    constructor(weztermPath) {
+        this.weztermPath = weztermPath;
+        this.shell = new BashAdapter();
+    }
+    static create() {
+        if (!process.env.WEZTERM_PANE && process.env.TERM_PROGRAM !== 'WezTerm')
+            return null;
+        const weztermPath = findExecutable('wezterm');
+        if (!weztermPath)
+            return null;
+        return new WeztermMultiplexer(weztermPath);
+    }
+    resolveStrategy(ctx) {
+        if (ctx.disableMux) {
+            return { strategy: 'inline', reason: 'Multiplexer disabled via --no-tmux' };
+        }
+        // REPL-context gating: only split when called from a REPL session.
+        // From a shell (no REPL vars), launch inline.
+        if (!ctx.calledFromRepl) {
+            return { strategy: 'inline', reason: 'WezTerm shell — no REPL context, launching inline' };
+        }
+        return { strategy: 'split', reason: 'Inside WezTerm REPL — splitting pane' };
+    }
+    async kill(handle) {
+        if (!handle)
+            return;
+        await execFileAsync(this.weztermPath, buildWeztermKillArgs(handle), { timeout: 3000 });
+    }
+    async split(options) {
+        const { toolName, args, env, cwd, mode, sentinelPath } = options;
+        // Resolve tool path
+        const nativePath = findExecutable(toolName);
+        if (!nativePath) {
+            return { launched: false, backend: this.backend, reason: `${toolName} not found on PATH` };
+        }
+        const effectiveToolPath = await this.shell.resolveToolPath(toolName, nativePath);
+        if (!effectiveToolPath) {
+            return { launched: false, backend: this.backend, reason: `${toolName} not found in bash PATH (required for wezterm pane)` };
+        }
+        try {
+            const promptText = mode === 'repl' && options.promptPath
+                ? fs.readFileSync(options.promptPath, 'utf8')
+                : undefined;
+            let baseCommand = this.shell.buildToolCommand({
+                toolPath: effectiveToolPath,
+                args,
+                env,
+                mode,
+                promptText,
+                ...(options.promptPath ? { promptPath: options.promptPath } : {}),
+            });
+            if (options.retryOnQuickExit) {
+                baseCommand = this.shell.wrapQuickExitRetry(baseCommand, this.shell.quote(effectiveToolPath));
+            }
+            const gitBash = process.platform === 'win32' ? resolveGitBash() ?? undefined : undefined;
+            // WezTerm always holds pane and uses auto-close via wezterm kill-pane
+            const holdMessage = PANE_HOLD_MESSAGE;
+            let paneCommand = this.shell.wrapSentinel({
+                command: baseCommand,
+                sentinelPath,
+                autoClose: false,
+                autoCloseCommand: `wezterm cli kill-pane --pane-id $WEZTERM_PANE >/dev/null 2>&1 || true`,
+                holdPane: true,
+                holdMessage,
+            });
+            // Prepend nesting cleanup (PATH fix + unset REPL vars)
+            paneCommand = `${this.shell.buildNestingCleanup()} ${paneCommand}`;
+            // Resolve split direction
+            const splitDirection = options.split;
+            let splitFlag;
+            if (splitDirection === 'auto') {
+                splitFlag = await resolveAutoSplit(this.weztermPath);
+            }
+            else {
+                splitFlag = toWeztermSplitFlag(splitDirection);
+            }
+            const weztermArgs = buildWeztermSplitArgs({
+                splitFlag,
+                command: paneCommand,
+                cwd,
+                paneId: process.env.WEZTERM_PANE,
+                bashPath: gitBash,
+            });
+            const split = await execFileAsync(this.weztermPath, weztermArgs, { timeout: 5000 });
+            if (split.exitCode !== 0) {
+                return {
+                    launched: false,
+                    backend: this.backend,
+                    reason: 'wezterm split-pane failed',
+                };
+            }
+            const handle = getLastLine(split.stdout) || undefined;
+            return {
+                launched: true,
+                backend: this.backend,
+                handle,
+                sentinelPath,
+            };
+        }
+        catch (error) {
+            return {
+                launched: false,
+                backend: this.backend,
+                reason: `pane launch failed: ${String(error)}`,
+            };
+        }
+    }
+    async createSession(options) {
+        const { toolPath, toolArgs, cwd } = options;
+        // On Windows, resolve tool path from bash's perspective
+        let effectiveToolPath = toolPath;
+        if (process.platform === 'win32') {
+            const toolName = toolPath.split(/[\\/]/).pop()?.replace(/\.exe$/i, '') ?? toolPath;
+            const bashPath = await this.shell.resolveToolPath(toolName, toolPath);
+            if (bashPath) {
+                effectiveToolPath = bashPath;
+            }
+        }
+        const baseCommand = this.shell.buildToolCommand({
+            toolPath: effectiveToolPath,
+            args: toolArgs,
+            env: {},
+            mode: 'repl',
+            promptText: options.promptText,
+        });
+        // Prepend nesting cleanup
+        const spawnCommand = `${this.shell.buildNestingCleanup()} ${baseCommand}`;
+        const weztermArgs = buildWeztermSpawnArgs({
+            command: spawnCommand,
+            cwd,
+            bashPath: process.platform === 'win32' ? resolveGitBash() ?? undefined : undefined,
+        });
+        try {
+            const result = await execFileAsync(this.weztermPath, weztermArgs, { timeout: 5000 });
+            if (result.exitCode !== 0) {
+                return {
+                    launched: false,
+                    exitCode: result.exitCode,
+                    backend: this.backend,
+                    reason: `wezterm spawn failed: ${result.stderr.trim() || 'unknown error'}`,
+                };
+            }
+            return { launched: true, exitCode: 0, backend: this.backend };
+        }
+        catch (error) {
+            return {
+                launched: false,
+                exitCode: -1,
+                backend: this.backend,
+                reason: `wezterm spawn failed: ${String(error)}`,
+            };
+        }
+    }
+}

package/dist/lib/mux-utils.d.ts

@@ -1,5 +1,6 @@
-import type { CreateSessionResult } from './multiplexer.js';
+import type { LaunchResult } from './multiplexer.js';
 export declare function getLastLine(text: string): string;
-export declare function spawnAttached(command: string, args: string[], env: NodeJS.ProcessEnv | undefined, backendLabel: string): Promise<CreateSessionResult>;
+export declare function spawnAttached(command: string, args: string[], env: NodeJS.ProcessEnv | undefined, backendLabel: string): Promise<LaunchResult>;
 export declare function splitFlagFromDimensions(width: number, height: number): '-h' | '-v';
-export declare function cleanClaudeEnv(extra?: Record<string, string>): NodeJS.ProcessEnv;
+export declare const PANE_HOLD_MESSAGE = "[aiwcli] Driver exited. Pane held open.";
+export declare function buildBootstrapPrompt(filePath: string): string;

package/dist/lib/mux-utils.js

@@ -1,5 +1,4 @@
 import { spawn } from 'node:child_process';
-import { getInternalSubprocessEnv } from './runtime/subprocess-utils.js';
 const CELL_ASPECT_RATIO = 2;
 export function getLastLine(text) {
     const lines = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
@@ -12,18 +11,18 @@ export function spawnAttached(command, args, env, backendLabel) {
             child = spawn(command, args, { stdio: 'inherit', env: env ?? process.env });
         }
         catch (error) {
-            resolve({ exitCode: -1, usedMux: false, reason: error instanceof Error ? error.message : String(error) });
+            resolve({ launched: false, exitCode: -1, backend: backendLabel, reason: error instanceof Error ? error.message : String(error) });
             return;
         }
         child.on('error', (error) => {
-            resolve({ exitCode: -1, usedMux: false, reason: error.message });
+            resolve({ launched: false, exitCode: -1, backend: backendLabel, reason: error.message });
         });
         child.on('close', (code) => {
             if (code === 0) {
-                resolve({ exitCode: 0, usedMux: true });
+                resolve({ launched: true, exitCode: 0, backend: backendLabel });
             }
             else {
-                resolve({ exitCode: code ?? 1, usedMux: false, reason: `${backendLabel} exited with code ${code ?? 1}` });
+                resolve({ launched: false, exitCode: code ?? 1, backend: backendLabel, reason: `${backendLabel} exited with code ${code ?? 1}` });
             }
         });
     });
@@ -31,12 +30,7 @@ export function spawnAttached(command, args, env, backendLabel) {
 export function splitFlagFromDimensions(width, height) {
     return width >= height * CELL_ASPECT_RATIO ? '-h' : '-v';
 }
-export function cleanClaudeEnv(extra) {
-    const env = {
-        ...getInternalSubprocessEnv(),
-        ...extra,
-    };
-    delete env['CLAUDECODE'];
-    delete env['CLAUDE_CODE_ENTRYPOINT'];
-    return env;
+export const PANE_HOLD_MESSAGE = '[aiwcli] Driver exited. Pane held open.';
+export function buildBootstrapPrompt(filePath) {
+    return `Read startup instructions from this file path before taking action: ${filePath}. Use that file as the initial context.`;
 }

package/dist/lib/prompt-file-manager.d.ts

@@ -0,0 +1,23 @@
+/**
+ * PromptFileManager — owns prompt file lifecycle (creation, cleanup).
+ * Replaces scattered writeFileSync calls for prompt temp files.
+ */
+export declare class PromptFileManager {
+    private readonly files;
+    private readonly tempDir;
+    private readonly now;
+    private readonly pid;
+    constructor(options: {
+        tempDir: string;
+        now: () => number;
+        pid: number;
+    });
+    /**
+     * Write prompt text to a temp file and return the path.
+     */
+    materialize(promptText: string): string;
+    /**
+     * Clean up all created prompt files. Call in finally block.
+     */
+    cleanup(): void;
+}