aiwcli 0.15.5 → 0.17.0

package/dist/lib/multiplexers/tmux.js

@@ -0,0 +1,221 @@
+/**
+ * TmuxMultiplexer — unified tmux backend.
+ * 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 { 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 { execFileAsync, findExecutable } from '../runtime/subprocess-utils.js';
+import { BashAdapter } from '../shell-adapters/bash-adapter.js';
+import { findBestSplit, listPanes } from '../tmux-pane-placement.js';
+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) {
+    if (platform !== 'win32')
+        return command;
+    const bootstrap = buildTmuxRuntimeBootstrapCommands(platform).join('; ');
+    return `${bootstrap}; ${command}`;
+}
+/** @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();
+    if (explicitTarget) {
+        const size = await execFileAsync(tmuxPath, ['display-message', '-p', '-t', explicitTarget, '#{pane_width} #{pane_height}'], { timeout: 3000 });
+        if (size.exitCode === 0) {
+            const parts = size.stdout.trim().split(/\s+/);
+            if (parts.length >= 2) {
+                const width = Number.parseInt(parts[0] ?? '', 10);
+                const height = Number.parseInt(parts[1] ?? '', 10);
+                if (Number.isFinite(width) && Number.isFinite(height)) {
+                    return {
+                        splitFlag: splitFlagFromDimensions(width, height),
+                        splitTarget: explicitTarget,
+                    };
+                }
+            }
+        }
+        return { splitFlag: '-h', splitTarget: explicitTarget };
+    }
+    const panes = await listPanes(tmuxPath);
+    const placement = findBestSplit(panes);
+    if (!placement)
+        return { splitFlag: '-h' };
+    return {
+        splitFlag: placement.splitFlag,
+        splitTarget: placement.targetPane,
+    };
+}
+export class TmuxMultiplexer {
+    backend = 'tmux';
+    tmuxPath;
+    shell;
+    constructor(tmuxPath) {
+        this.tmuxPath = tmuxPath;
+        this.shell = new BashAdapter();
+    }
+    static create() {
+        const tmuxPath = findExecutable('tmux');
+        if (!tmuxPath)
+            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, cwd } = options;
+        if (!isNonWindowsPlatform()) {
+            return { launched: false, exitCode: -1, backend: this.backend, reason: 'tmux not available on this platform' };
+        }
+        // Set default-terminal BEFORE session creation
+        try {
+            execSync(String.raw `tmux start-server \; set -g default-terminal "tmux-256color"`, { stdio: 'ignore', timeout: 3000 });
+        }
+        catch {
+            try {
+                execSync(String.raw `tmux start-server \; set -g default-terminal "screen-256color"`, { stdio: 'ignore', timeout: 3000 });
+            }
+            catch { /* best-effort */ }
+        }
+        const shellCommand = buildShellCommand({
+            sessionName,
+            toolPath: options.toolPath,
+            toolArgs: options.toolArgs,
+            promptText: options.promptText,
+            enableMouse: options.enableMouse ?? true,
+        });
+        const args = buildTmuxCreateSessionArgs({
+            sessionName,
+            cwd,
+            shellCommand,
+            reattach,
+        });
+        return spawnAttached('tmux', args, sanitizedProcessEnv(), this.backend);
+    }
+    async kill(handle) {
+        if (!handle)
+            return;
+        await execFileAsync(this.tmuxPath, ['kill-pane', '-t', handle], { timeout: 3000 });
+    }
+    async split(options) {
+        const { toolName, args, env, cwd, mode, sentinelPath } = options;
+        // Configure tmux session defaults (mouse, scrollback, color)
+        configureTmuxSession();
+        // 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 tmux pane)` };
+        }
+        // Inject COLORTERM=truecolor for tmux
+        const effectiveEnv = { COLORTERM: 'truecolor', ...env };
+        try {
+            const promptText = mode === 'repl' && options.promptPath
+                ? fs.readFileSync(options.promptPath, 'utf8')
+                : undefined;
+            let baseCommand = this.shell.buildToolCommand({
+                toolPath: effectiveToolPath,
+                args,
+                env: effectiveEnv,
+                mode,
+                promptText,
+                ...(options.promptPath ? { promptPath: options.promptPath } : {}),
+            });
+            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;
+            let splitFlag;
+            let splitTarget;
+            if (splitDirection === 'auto') {
+                try {
+                    const resolved = await resolveAutoSplit(this.tmuxPath);
+                    splitFlag = resolved.splitFlag;
+                    splitTarget = resolved.splitTarget;
+                }
+                catch {
+                    splitFlag = '-h';
+                }
+            }
+            else {
+                splitFlag = toTmuxSplitFlag(splitDirection);
+            }
+            // Build tmux split-window command
+            const cwdPath = isWindowsPlatform() ? toMsysPosixPath(cwd) : cwd;
+            const bootstrappedCommand = withWindowsTmuxBootstrap(paneCommand);
+            const tmuxArgs = buildTmuxSplitWindowArgs({
+                splitFlag,
+                command: `bash -lc ${this.shell.quote(bootstrappedCommand)}`,
+                cwd: cwdPath,
+                splitTarget,
+            });
+            const split = await execFileAsync(this.tmuxPath, tmuxArgs, { timeout: 5000 });
+            if (split.exitCode !== 0) {
+                return {
+                    launched: false,
+                    backend: this.backend,
+                    reason: 'tmux split-window 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)}`,
+            };
+        }
+    }
+}

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

@@ -0,0 +1,6 @@
+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<LaunchResult>;
+export declare function splitFlagFromDimensions(width: number, height: number): '-h' | '-v';
+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

@@ -0,0 +1,36 @@
+import { spawn } from 'node:child_process';
+const CELL_ASPECT_RATIO = 2;
+export function getLastLine(text) {
+    const lines = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    return lines.at(-1) ?? '';
+}
+export function spawnAttached(command, args, env, backendLabel) {
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = spawn(command, args, { stdio: 'inherit', env: env ?? process.env });
+        }
+        catch (error) {
+            resolve({ launched: false, exitCode: -1, backend: backendLabel, reason: error instanceof Error ? error.message : String(error) });
+            return;
+        }
+        child.on('error', (error) => {
+            resolve({ launched: false, exitCode: -1, backend: backendLabel, reason: error.message });
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve({ launched: true, exitCode: 0, backend: backendLabel });
+            }
+            else {
+                resolve({ launched: false, exitCode: code ?? 1, backend: backendLabel, reason: `${backendLabel} exited with code ${code ?? 1}` });
+            }
+        });
+    });
+}
+export function splitFlagFromDimensions(width, height) {
+    return width >= height * CELL_ASPECT_RATIO ? '-h' : '-v';
+}
+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/paths.d.ts

@@ -13,14 +13,14 @@ export declare function expandPath(inputPath: string): string;
 /**
  * Convert a path to Unix-style forward slashes.
  * Useful for cross-platform logging or display.
- * @param inputPath - Path with any separator style
+ * @param inputPath - Path with unknown separator style
  * @returns Path with forward slashes only
  */
 export declare function toUnixPath(inputPath: string): string;
 /**
  * Convert a path to Windows-style backslashes.
  * Useful for cross-platform logging or display.
- * @param inputPath - Path with any separator style
+ * @param inputPath - Path with unknown separator style
  * @returns Path with backslashes only
  */
 export declare function toWindowsPath(inputPath: string): string;

package/dist/lib/paths.js

@@ -31,7 +31,7 @@ export function expandPath(inputPath) {
 /**
  * Convert a path to Unix-style forward slashes.
  * Useful for cross-platform logging or display.
- * @param inputPath - Path with any separator style
+ * @param inputPath - Path with unknown separator style
  * @returns Path with forward slashes only
  */
 export function toUnixPath(inputPath) {
@@ -40,7 +40,7 @@ export function toUnixPath(inputPath) {
 /**
  * Convert a path to Windows-style backslashes.
  * Useful for cross-platform logging or display.
- * @param inputPath - Path with any separator style
+ * @param inputPath - Path with unknown separator style
  * @returns Path with backslashes only
  */
 export function toWindowsPath(inputPath) {

package/dist/lib/platform-commands.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Platform-specific hook command adaptation.
+ *
+ * Claude Code on Windows uses cmd.exe to execute hook commands (Node.js
+ * child_process.exec defaults to process.env.ComSpec). Template commands use
+ * bash syntax (~/ expansion, env-var prefixes) that cmd.exe can't parse.
+ *
+ * This module rewrites commands at settings-reconstruction time so they work
+ * in cmd.exe while remaining valid in bash on Unix (where it's a no-op).
+ */
+/**
+ * Resolver path token that appears in all template hook commands.
+ * Shared between templates and adapter — changing this requires updating
+ * all template settings.json files AND tests.
+ */
+export declare const RESOLVER_TOKEN = ".aiwcli/_core/scripts/resolve-run.ts";
+/**
+ * Adapt a hook command for the current platform.
+ * On Windows: strips bash env prefixes, quotes the resolver path.
+ * On Unix: no-op (returns input unchanged).
+ */
+export declare function adaptHookCommand(command: string): string;
+/**
+ * Post-reconstruction validation. On Windows, asserts no command contains
+ * bash-only syntax. Throws with actionable message if validation fails.
+ */
+export declare function validateCommandsForPlatform(commands: string[]): void;

package/dist/lib/platform-commands.js

@@ -0,0 +1,49 @@
+/**
+ * Platform-specific hook command adaptation.
+ *
+ * Claude Code on Windows uses cmd.exe to execute hook commands (Node.js
+ * child_process.exec defaults to process.env.ComSpec). Template commands use
+ * bash syntax (~/ expansion, env-var prefixes) that cmd.exe can't parse.
+ *
+ * This module rewrites commands at settings-reconstruction time so they work
+ * in cmd.exe while remaining valid in bash on Unix (where it's a no-op).
+ */
+/**
+ * Resolver path token that appears in all template hook commands.
+ * Shared between templates and adapter — changing this requires updating
+ * all template settings.json files AND tests.
+ */
+export const RESOLVER_TOKEN = '.aiwcli/_core/scripts/resolve-run.ts';
+/** Matches leading bash-style env-var prefixes: KEY=VALUE KEY2= ... */
+const BASH_ENV_PREFIX_RE = /^(?:[A-Z_]+=\S*\s+)+/;
+/**
+ * Adapt a hook command for the current platform.
+ * On Windows: strips bash env prefixes, quotes the resolver path.
+ * On Unix: no-op (returns input unchanged).
+ */
+export function adaptHookCommand(command) {
+    if (process.platform !== 'win32')
+        return command;
+    const quotedResolver = `"${RESOLVER_TOKEN}"`;
+    let result = command.replace(BASH_ENV_PREFIX_RE, '');
+    result = result.replace(RESOLVER_TOKEN, quotedResolver);
+    return result;
+}
+/**
+ * Post-reconstruction validation. On Windows, asserts no command contains
+ * bash-only syntax. Throws with actionable message if validation fails.
+ */
+export function validateCommandsForPlatform(commands) {
+    if (process.platform !== 'win32')
+        return;
+    for (const cmd of commands) {
+        if (cmd.includes('~/')) {
+            throw new Error(`Hook command contains unexpanded ~/: "${cmd}". ` +
+                'All hook commands must use RESOLVER_TOKEN from platform-commands.ts.');
+        }
+        if (BASH_ENV_PREFIX_RE.test(cmd)) {
+            throw new Error(`Hook command contains bash env prefix: "${cmd}". ` +
+                'Move env vars into resolve-run.ts spawn env instead.');
+        }
+    }
+}

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;
+}