@adhdev/daemon-core 0.9.82-rc.32 → 0.9.82-rc.321

package/src/cli-adapters/provider-cli-parse.d.ts

@@ -15,6 +15,7 @@ export declare function buildCliParseInput(options: {
     accumulatedRawBuffer: string;
     recentOutputBuffer: string;
     terminalScreenText: string;
+    workingDir?: string;
     baseMessages: CliChatMessage[];
     partialResponse: string;
     isWaitingForResponse?: boolean;

package/src/cli-adapters/provider-cli-parse.ts

@@ -35,22 +35,30 @@ export function buildCliParseInput(options: {
     accumulatedRawBuffer: string;
     recentOutputBuffer: string;
     terminalScreenText: string;
+    workingDir?: string;
+    providerSessionId?: string;
+    historySessionId?: string;
     baseMessages: CliChatMessage[];
     partialResponse: string;
     isWaitingForResponse?: boolean;
     scope?: TurnParseScope | null;
     runtimeSettings: Record<string, any>;
+    spawnAt?: number;
 }): CliScriptInput {
     const {
         accumulatedBuffer,
         accumulatedRawBuffer,
         recentOutputBuffer,
         terminalScreenText,
+        workingDir,
+        providerSessionId,
+        historySessionId,
         baseMessages,
         partialResponse,
         isWaitingForResponse,
         scope,
         runtimeSettings,
+        spawnAt,
     } = options;
     const buffer = scope
         ? sliceFromOffset(accumulatedBuffer, scope.bufferStart)
@@ -66,6 +74,10 @@ export function buildCliParseInput(options: {
         rawBuffer,
         recentBuffer,
         screenText,
+        workspace: workingDir,
+        workingDir,
+        providerSessionId,
+        historySessionId,
         screen: buildCliScreenSnapshot(screenText),
         bufferScreen: buildCliScreenSnapshot(buffer),
         recentScreen: buildCliScreenSnapshot(recentBuffer),
@@ -74,6 +86,7 @@ export function buildCliParseInput(options: {
         isWaitingForResponse,
         promptText: scope?.prompt || '',
         settings: { ...runtimeSettings },
+        ...(typeof spawnAt === 'number' && spawnAt > 0 ? { spawnAt } : {}),
     };
 }
 

package/src/cli-adapters/provider-cli-runtime.ts

@@ -34,20 +34,69 @@ export function resolveCliSpawnPlan(options: {
     const configuredCommand = typeof runtimeSettings.executablePath === 'string' && runtimeSettings.executablePath.trim()
         ? runtimeSettings.executablePath.trim()
         : spawnConfig.command;
-    const binaryPath = findBinary(configuredCommand);
+    return resolveCliSpawnPlanFromParts({
+        command: configuredCommand,
+        baseArgs: spawnConfig.args,
+        shell: spawnConfig.shell,
+        baseEnv: spawnConfig.env,
+        workingDir,
+        extraArgs,
+        extraEnv,
+    });
+}
+
+/**
+ * Cols/rows for a PTY spawn. Defaults to the session-host terminal size; the
+ * spec driver may override per-instance.
+ */
+export interface CliSpawnGeometry {
+    cols?: number;
+    rows?: number;
+}
+
+/**
+ * Core spawn-plan resolution from already-flattened spawn parts — the single
+ * source of truth for binary resolution (findBinary: PATH + npm-global / Node
+ * dir fallback), `{{workingDir}}` token substitution, shell wrapping
+ * (script-shims / non-absolute / non-native binaries), and env sanitization +
+ * TERMINAL_CWD. Both the legacy provider-module path (resolveCliSpawnPlan) and
+ * the spec/FSM path (FsmDriver.buildAdapterOpts) feed into this so the two
+ * spawn paths can never diverge.
+ */
+export function resolveCliSpawnPlanFromParts(options: {
+    /** Raw command from the spec/provider (`binary` / `spawn.command`), or an
+     *  operator-configured executable path override. */
+    command: string;
+    /** Base launch args declared by the spec/provider (`spawn_args` /
+     *  `spawn.args`). */
+    baseArgs?: string[];
+    /** When true, always wrap the launch in a login shell. */
+    shell?: boolean;
+    /** Base env declared by the spec/provider (`env` / `spawn.env`). */
+    baseEnv?: Record<string, string>;
+    workingDir: string;
+    /** Per-launch extra args (e.g. resume session id) appended after baseArgs. */
+    extraArgs?: string[];
+    extraEnv?: Record<string, string>;
+    geometry?: CliSpawnGeometry;
+}): CliSpawnPlan {
+    const { command, baseArgs, shell, baseEnv, workingDir, extraArgs, extraEnv, geometry } = options;
+    const binaryPath = findBinary(command);
     const isWin = os.platform() === 'win32';
-    const allArgs = [...spawnConfig.args, ...extraArgs];
+    const allArgs = [...(baseArgs ?? []), ...(extraArgs ?? [])].map((arg) =>
+        typeof arg === 'string' ? arg.replace(/\{\{workingDir\}\}/g, workingDir) : arg,
+    );
 
     let shellCmd: string;
     let shellArgs: string[];
     const useShellUnix = !isWin && (
-        !!spawnConfig.shell
+        !!shell
         || !path.isAbsolute(binaryPath)
         || isScriptBinary(binaryPath)
         || !looksLikeMachOOrElf(binaryPath)
     );
     const isCmdShim = isWin && /\.(cmd|bat)$/i.test(binaryPath);
-    const useShellWin = !!spawnConfig.shell
+    const useShellWin = !!shell
         || isCmdShim
         || !path.isAbsolute(binaryPath)
         || isScriptBinary(binaryPath);
@@ -66,7 +115,7 @@ export function resolveCliSpawnPlan(options: {
         shellArgs = allArgs;
     }
 
-    const env = buildCliSpawnEnv(process.env, { ...(spawnConfig.env || {}), ...(extraEnv || {}) });
+    const env = buildCliSpawnEnv(process.env, { ...(baseEnv || {}), ...(extraEnv || {}) });
     // Some CLI agents, notably Hermes, route their tools through TERMINAL_CWD
     // rather than process.cwd(). Keep the generic ADHDev launch workspace as
     // the single source of truth so PTY cwd and tool cwd cannot diverge.
@@ -80,8 +129,8 @@ export function resolveCliSpawnPlan(options: {
         isWin,
         useShell,
         ptyOptions: {
-            cols: DEFAULT_SESSION_HOST_COLS,
-            rows: DEFAULT_SESSION_HOST_ROWS,
+            cols: geometry?.cols ?? DEFAULT_SESSION_HOST_COLS,
+            rows: geometry?.rows ?? DEFAULT_SESSION_HOST_ROWS,
             cwd: workingDir,
             env,
         },

package/src/cli-adapters/provider-cli-shared.d.ts

@@ -55,6 +55,8 @@ export interface CliScriptInput {
     rawBuffer: string;
     recentBuffer: string;
     screenText: string;
+    workspace?: string;
+    workingDir?: string;
     screen: CliScreenSnapshot;
     bufferScreen: CliScreenSnapshot;
     recentScreen: CliScreenSnapshot;

package/src/cli-adapters/provider-cli-shared.ts

@@ -4,6 +4,7 @@ import { execSync } from 'child_process';
 import type { ProviderResumeCapability } from '../providers/contracts.js';
 import type { ChatMessageKind } from '../providers/chat-message-normalization.js';
 import type { ChatBubbleState } from '../types.js';
+import type { InteractivePrompt } from '../providers/types/interactive-prompt.js';
 import { sanitizeSpawnEnv } from './spawn-env.js';
 
 export interface CliChatMessage {
@@ -28,8 +29,27 @@ export interface CliSessionStatus {
     messages: CliChatMessage[];
     workingDir: string;
     activeModal: { message: string; buttons: string[] } | null;
+    /**
+     * Monotonic counter identifying which approval *entry* the current modal
+     * belongs to. Bumped by the FSM on every fresh waiting_approval entry.
+     * Consumers (e.g. auto-approval) use it to distinguish a genuinely new
+     * approval from the same approval re-observed across TUI paint flaps —
+     * two distinct approvals can carry identical message/button text, so the
+     * seq is the only reliable discriminator.
+     */
+    approvalEntrySeq?: number;
+    activeInteractivePrompt?: InteractivePrompt | null;
+    pendingOutboundCount?: number;
+    pendingOutboundMessages?: Array<{
+        id: string;
+        role: 'user';
+        content: string;
+        queuedAt: number;
+        source: string;
+    }>;
     errorMessage?: string;
     errorReason?: string;
+    providerSessionId?: string;
     bufferState?: {
         responseBuffer?: { truncated: boolean; droppedChars: number; maxChars: number };
         recentOutputBuffer?: { truncated: boolean; droppedChars: number; maxChars: number };
@@ -43,6 +63,9 @@ export interface ParsedSession {
     messages: any[];
     modal: { message: string; buttons: string[] } | null;
     parsedStatus: string | null;
+    errorMessage?: string;
+    errorReason?: string;
+    providerSessionId?: string;
     transcriptAuthority?: 'provider' | 'daemon';
     coverage?: 'full' | 'tail' | 'current-turn';
 }
@@ -94,6 +117,10 @@ export interface CliScriptInput {
     rawBuffer: string;
     recentBuffer: string;
     screenText: string;
+    workspace?: string;
+    workingDir?: string;
+    providerSessionId?: string;
+    historySessionId?: string;
     screen: CliScreenSnapshot;
     bufferScreen: CliScreenSnapshot;
     recentScreen: CliScreenSnapshot;
@@ -103,6 +130,7 @@ export interface CliScriptInput {
     promptText?: string;
     settings?: Record<string, any>;
     args?: Record<string, any>;
+    spawnAt?: number;
 }
 
 export interface CliStatusInput {
@@ -141,16 +169,26 @@ export interface CliProviderModule {
     binary: string;
     approvalKeys?: Record<number, string>;
     sendDelayMs?: number;
+    /** Wall-clock budget (ms) for a single provider script invocation. Default 50. Range 1..5000.
+     *  Exceeding the budget records `timedOut: true` on the invocation trace and emits a
+     *  throttled WARN — it does NOT abort the script (Node CJS can't interrupt sync code). */
+    scriptCallBudgetMs?: number;
     sendKey?: string;
     submitStrategy?: 'wait_for_echo' | 'immediate';
     /** Require the typed prompt to be visible on the PTY screen before sending Enter. */
     requirePromptEchoBeforeSubmit?: boolean;
     /** Allow sending another prompt while the CLI is still generating so users can intervene mid-turn. */
     allowInputDuringGeneration?: boolean;
+    /** When true, only transition to idle after the parsed transcript includes a final standard assistant message. */
+    requiresFinalAssistantBeforeIdle?: boolean;
+    /** When true, allow providers to augment stale snapshot data before parse. Reserved for future use. */
+    augmentStaleSnapshot?: boolean;
     /** When provider-owned, daemon treats provider parser output as canonical transcript authority. */
     transcriptAuthority?: 'provider' | 'daemon';
     /** Full context lets provider-owned parsers canonicalize retained history instead of daemon prefix stitching. */
     transcriptContext?: 'full' | 'tail';
+    /** v1 declarative tui block — used by CliScriptRunner to synthesize SDK helpers (declarativeDetectStatus, declarativeParseApproval). */
+    tui?: Record<string, unknown>;
     scripts?: CliScripts;
     spawn: {
         command: string;
@@ -342,7 +380,18 @@ export class TerminalTranscriptAccumulator {
         this.ensureRow();
         if (final === 'A') this.row = Math.max(0, this.row - count);
         else if (final === 'B') this.row += count;
-        else if (final === 'C') this.col += count;
+        else if (final === 'C') {
+            // (fix) Cursor-forward must materialize spaces in the cells it
+            // skips, otherwise rendered transcripts collapse "Do you" written
+            // as "Do\x1b[1Cyou" into "Doyou". That mis-rendering broke
+            // Claude Code's approval-prompt and prompt-line detection
+            // (parseApproval saw "Doyouwanttoproceed?" and returned null).
+            const line = this.lines[this.row];
+            for (let c = this.col; c < this.col + count; c += 1) {
+                if (line[c] === undefined) line[c] = ' ';
+            }
+            this.col += count;
+        }
         else if (final === 'D') this.col = Math.max(0, this.col - count);
         else if (final === 'G') this.col = Math.max(0, count - 1);
         else if (final === 'H' || final === 'f') {
@@ -484,17 +533,42 @@ export function findBinary(name: string): string {
         return path.isAbsolute(expanded) ? expanded : path.resolve(expanded);
     }
     const isWin = os.platform() === 'win32';
-    try {
-        const cmd = isWin ? `where ${trimmed}` : `which ${trimmed}`;
-        return execSync(cmd, {
-            encoding: 'utf-8',
-            timeout: 5000,
-            stdio: ['pipe', 'pipe', 'pipe'],
-            ...(isWin ? { windowsHide: true } : {}),
-        }).trim().split('\n')[0].trim();
-    } catch {
-        return isWin ? `${trimmed}.cmd` : trimmed;
+    const paths = (process.env.PATH || '').split(path.delimiter);
+    // Also search well-known global-bin directories that are frequently NOT on
+    // the daemon's inherited PATH. A daemon running under one Node install (e.g.
+    // nvm) never sees another npm prefix's bin dir — notably npm's Windows
+    // default prefix at %APPDATA%\npm, where `npm i -g @openai/codex` lands. We
+    // append these after PATH (so explicit PATH entries still win) so that an
+    // npm-global CLI resolves to an absolute path; the spawn layer's .cmd-shim
+    // handling then launches it correctly regardless of PATH.
+    const extraDirs: string[] = [];
+    if (isWin) {
+        if (process.env.APPDATA) extraDirs.push(path.join(process.env.APPDATA, 'npm'));
+        try { extraDirs.push(path.dirname(process.execPath)); } catch { /* best-effort */ }
+    } else {
+        extraDirs.push(path.join(os.homedir(), '.npm-global', 'bin'));
+        extraDirs.push('/usr/local/bin', '/opt/homebrew/bin');
+        try { extraDirs.push(path.dirname(process.execPath)); } catch { /* best-effort */ }
+    }
+    const searchDirs = [...paths, ...extraDirs];
+    const exes = isWin ? ['.exe', '.cmd', '.bat', ''] : [''];
+
+    for (const p of searchDirs) {
+        if (!p) continue;
+        for (const ext of exes) {
+            const fullPath = path.join(p, trimmed + ext);
+            try {
+                const fs = require('fs');
+                if (fs.existsSync(fullPath)) {
+                    const stat = fs.statSync(fullPath);
+                    if (stat.isFile() && (isWin || (stat.mode & 0o111))) {
+                        return fullPath;
+                    }
+                }
+            } catch { }
+        }
     }
+    return isWin ? `${trimmed}.cmd` : trimmed;
 }
 
 export function isScriptBinary(binaryPath: string): boolean {

package/src/cli-adapters/pty-transport.ts

@@ -1,5 +1,6 @@
 import * as os from 'os';
 import { ensureNodePtySpawnHelperPermissions } from './spawn-env.js';
+import { resolveWin32Executable } from './resolve-executable.js';
 
 let cachedPty: any | null | undefined;
 
@@ -119,7 +120,7 @@ export class NodePtyTransportFactory implements PtyTransportFactory {
         cwd = os.homedir();
       }
     }
-    const handle = pty.spawn(command, args, {
+    const handle = pty.spawn(resolveWin32Executable(command), args, {
       name: 'xterm-256color',
       cols: options.cols,
       rows: options.rows,

package/src/cli-adapters/raw-terminal-io.ts

@@ -0,0 +1,252 @@
+import { randomUUID } from 'crypto';
+import {
+    SessionHostClient,
+    type SessionHostEndpoint,
+    type SessionHostRequest,
+    type SessionHostResponse,
+    type SessionTerminalSnapshot,
+    type SessionTerminalState,
+} from '@adhdev/session-host-core';
+
+type LowercaseLetter =
+    | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm'
+    | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';
+
+type FunctionKey = 'f1' | 'f2' | 'f3' | 'f4' | 'f5' | 'f6' | 'f7' | 'f8' | 'f9' | 'f10' | 'f11' | 'f12';
+type BaseNamedKey =
+    | 'enter' | 'escape' | 'tab' | 'backspace'
+    | 'up' | 'down' | 'left' | 'right'
+    | 'home' | 'end' | 'pageup' | 'pagedown' | 'space'
+    | FunctionKey;
+type ShiftNamedKey = BaseNamedKey | LowercaseLetter | `ctrl+${LowercaseLetter}` | `alt+${LowercaseLetter}`;
+
+export type NamedKey =
+    | BaseNamedKey
+    | `ctrl+${LowercaseLetter}`
+    | `alt+${LowercaseLetter}`
+    | `shift+${ShiftNamedKey}`;
+
+const BASE_KEY_SEQUENCES: Record<BaseNamedKey, string> = {
+    enter: '\r',
+    escape: '\x1b',
+    tab: '\t',
+    backspace: '\x7f',
+    up: '\x1b[A',
+    down: '\x1b[B',
+    right: '\x1b[C',
+    left: '\x1b[D',
+    home: '\x1b[H',
+    end: '\x1b[F',
+    pageup: '\x1b[5~',
+    pagedown: '\x1b[6~',
+    space: ' ',
+    f1: '\x1bOP',
+    f2: '\x1bOQ',
+    f3: '\x1bOR',
+    f4: '\x1bOS',
+    f5: '\x1b[15~',
+    f6: '\x1b[17~',
+    f7: '\x1b[18~',
+    f8: '\x1b[19~',
+    f9: '\x1b[20~',
+    f10: '\x1b[21~',
+    f11: '\x1b[23~',
+    f12: '\x1b[24~',
+};
+
+const SHIFTED_CSI_KEYS: Partial<Record<BaseNamedKey, string>> = {
+    up: '\x1b[1;2A',
+    down: '\x1b[1;2B',
+    right: '\x1b[1;2C',
+    left: '\x1b[1;2D',
+    home: '\x1b[1;2H',
+    end: '\x1b[1;2F',
+    pageup: '\x1b[5;2~',
+    pagedown: '\x1b[6;2~',
+    f1: '\x1b[1;2P',
+    f2: '\x1b[1;2Q',
+    f3: '\x1b[1;2R',
+    f4: '\x1b[1;2S',
+    f5: '\x1b[15;2~',
+    f6: '\x1b[17;2~',
+    f7: '\x1b[18;2~',
+    f8: '\x1b[19;2~',
+    f9: '\x1b[20;2~',
+    f10: '\x1b[21;2~',
+    f11: '\x1b[23;2~',
+    f12: '\x1b[24;2~',
+};
+
+function isLowercaseLetter(value: string): value is LowercaseLetter {
+    return /^[a-z]$/.test(value);
+}
+
+function encodeControlLetter(letter: LowercaseLetter): string {
+    return String.fromCharCode(letter.charCodeAt(0) - 96);
+}
+
+function encodeShiftedKey(key: string): string {
+    if (isLowercaseLetter(key)) return key.toUpperCase();
+    if (key.startsWith('ctrl+') && isLowercaseLetter(key.slice(5))) {
+        return encodeControlLetter(key.slice(5) as LowercaseLetter);
+    }
+    if (key.startsWith('alt+') && isLowercaseLetter(key.slice(4))) {
+        return `\x1b${key.slice(4).toUpperCase()}`;
+    }
+    if (key === 'tab') return '\x1b[Z';
+    if (key in SHIFTED_CSI_KEYS) return SHIFTED_CSI_KEYS[key as BaseNamedKey]!;
+    if (key in BASE_KEY_SEQUENCES) return BASE_KEY_SEQUENCES[key as BaseNamedKey];
+    throw new Error(`Unsupported named key: shift+${key}`);
+}
+
+export function namedKeyToAnsi(key: NamedKey | string): string {
+    const normalized = String(key || '').trim().toLowerCase();
+    if (normalized in BASE_KEY_SEQUENCES) return BASE_KEY_SEQUENCES[normalized as BaseNamedKey];
+    if (normalized.startsWith('ctrl+') && isLowercaseLetter(normalized.slice(5))) {
+        return encodeControlLetter(normalized.slice(5) as LowercaseLetter);
+    }
+    if (normalized.startsWith('alt+') && isLowercaseLetter(normalized.slice(4))) {
+        return `\x1b${normalized.slice(4)}`;
+    }
+    if (normalized.startsWith('shift+')) return encodeShiftedKey(normalized.slice(6));
+    throw new Error(`Unsupported named key: ${key}`);
+}
+
+export function namedKeysToAnsi(keys: readonly (NamedKey | string)[]): string {
+    if (!Array.isArray(keys)) throw new Error('keys must be an array');
+    return keys.map(namedKeyToAnsi).join('');
+}
+
+export interface RawTerminalSessionHostClient {
+    connect(): Promise<void>;
+    request<T = unknown>(request: SessionHostRequest): Promise<SessionHostResponse<T>>;
+    close(): Promise<void>;
+}
+
+export interface RawTerminalAttachmentOptions {
+    endpoint?: SessionHostEndpoint;
+    sessionId: string;
+    mode?: 'read' | 'write';
+    clientId?: string;
+    client?: RawTerminalSessionHostClient;
+}
+
+export class RawTerminalAttachment {
+    private closed = false;
+
+    private constructor(
+        readonly sessionId: string,
+        private readonly clientId: string,
+        private readonly mode: 'read' | 'write',
+        private readonly client: RawTerminalSessionHostClient,
+    ) {}
+
+    static async attach(options: RawTerminalAttachmentOptions): Promise<RawTerminalAttachment> {
+        const sessionId = String(options.sessionId || '').trim();
+        if (!sessionId) throw new Error('sessionId is required');
+        const mode = options.mode || 'read';
+        const clientId = options.clientId || `raw-terminal-${process.pid}-${randomUUID().slice(0, 8)}`;
+        const client = options.client || new SessionHostClient({ endpoint: options.endpoint });
+        await client.connect();
+
+        const attachResponse = await client.request({
+            type: 'attach_session',
+            payload: {
+                sessionId,
+                clientId,
+                clientType: 'web',
+                readOnly: mode === 'read',
+            },
+        });
+        if (!attachResponse.success) {
+            await client.close().catch(() => {});
+            throw new Error(attachResponse.error || `Failed to attach terminal session ${sessionId}`);
+        }
+
+        if (mode === 'write') {
+            const ownerResponse = await client.request({
+                type: 'acquire_write',
+                payload: {
+                    sessionId,
+                    clientId,
+                    ownerType: 'user',
+                    force: true,
+                },
+            });
+            if (!ownerResponse.success) {
+                await client.request({
+                    type: 'detach_session',
+                    payload: { sessionId, clientId },
+                }).catch(() => ({ success: false }));
+                await client.close().catch(() => {});
+                throw new Error(ownerResponse.error || `Failed to acquire terminal session ${sessionId}`);
+            }
+        }
+
+        return new RawTerminalAttachment(sessionId, clientId, mode, client);
+    }
+
+    async readSnapshot(): Promise<SessionTerminalSnapshot> {
+        const response = await this.client.request<SessionTerminalSnapshot>({
+            type: 'get_terminal_snapshot',
+            payload: { sessionId: this.sessionId },
+        });
+        if (!response.success || !response.result) {
+            throw new Error(response.error || `Terminal screen unavailable for ${this.sessionId}`);
+        }
+        return response.result;
+    }
+
+    async readScreenText(): Promise<string> {
+        return (await this.readSnapshot()).text;
+    }
+
+    async readState(): Promise<SessionTerminalState> {
+        return (await this.readSnapshot()).state;
+    }
+
+    async writeInput(text: string): Promise<void> {
+        if (this.mode !== 'write') throw new Error('Raw terminal attachment is read-only');
+        const response = await this.client.request({
+            type: 'send_input',
+            payload: {
+                sessionId: this.sessionId,
+                clientId: this.clientId,
+                data: text,
+            },
+        });
+        if (!response.success) throw new Error(response.error || `Failed to write terminal input to ${this.sessionId}`);
+    }
+
+    async writeKeys(keys: readonly (NamedKey | string)[]): Promise<void> {
+        await this.writeInput(namedKeysToAnsi(keys));
+    }
+
+    async close(): Promise<void> {
+        if (this.closed) return;
+        this.closed = true;
+        if (this.mode === 'write') {
+            await this.client.request({
+                type: 'release_write',
+                payload: { sessionId: this.sessionId, clientId: this.clientId },
+            }).catch(() => ({ success: false }));
+        }
+        await this.client.request({
+            type: 'detach_session',
+            payload: { sessionId: this.sessionId, clientId: this.clientId },
+        }).catch(() => ({ success: false }));
+        await this.client.close().catch(() => {});
+    }
+}
+
+export async function withRawTerminalAttachment<T>(
+    options: RawTerminalAttachmentOptions,
+    operation: (attachment: RawTerminalAttachment) => Promise<T>,
+): Promise<T> {
+    const attachment = await RawTerminalAttachment.attach(options);
+    try {
+        return await operation(attachment);
+    } finally {
+        await attachment.close();
+    }
+}

package/src/cli-adapters/resolve-executable.ts

@@ -0,0 +1,90 @@
+import { execFileSync } from 'child_process';
+import { existsSync } from 'fs';
+import * as path from 'path';
+
+// Extensions ConPTY/CreateProcess can launch directly (not .cmd/.bat, which
+// need a cmd.exe wrapper).
+const DIRECT_EXEC_EXT = new Set(['.exe', '.com']);
+
+// Executable extensions to probe when scanning a directory ourselves, ordered
+// most-directly-launchable first. node-pty's ConPTY backend launches an
+// absolute `.cmd`/`.bat` shim fine (verified) — it only fails to *resolve* a
+// bare command against an incomplete PATH — so once we hand it an absolute
+// path, a `.cmd` shim works just as well as a real `.exe`.
+const WIN_EXEC_EXT = ['.exe', '.com', '.cmd', '.bat'];
+
+/**
+ * Resolve a bare command against well-known global-bin directories that are
+ * frequently NOT on the daemon's inherited PATH, so `where` (which only
+ * searches PATH) misses them. A daemon running under one Node install (e.g.
+ * nvm) never sees another npm prefix's bin dir — notably npm's Windows default
+ * prefix at %APPDATA%\npm, where `npm i -g @openai/codex` lands. Returns an
+ * absolute path on the first hit, or null. Mirrors findBinary()'s extraDirs in
+ * provider-cli-shared.ts; kept inline here so this lightweight module (loaded
+ * by pty-transport) need not pull in the heavier shared module.
+ */
+function resolveWin32GlobalBin(trimmed: string): string | null {
+  // Only resolve a bare command name — anything with a path separator is the
+  // caller's explicit location and must not be re-pointed at a global bin dir.
+  if (path.isAbsolute(trimmed) || trimmed.includes('/') || trimmed.includes('\\')) {
+    return null;
+  }
+  const extraDirs: string[] = [];
+  if (process.env.APPDATA) extraDirs.push(path.join(process.env.APPDATA, 'npm'));
+  try { extraDirs.push(path.dirname(process.execPath)); } catch { /* best-effort */ }
+  for (const dir of extraDirs) {
+    if (!dir) continue;
+    for (const ext of WIN_EXEC_EXT) {
+      const full = path.join(dir, trimmed + ext);
+      if (existsSync(full)) return full;
+    }
+  }
+  return null;
+}
+
+/**
+ * Resolve a launch command to an absolute executable path on Windows.
+ *
+ * node-pty's ConPTY backend resolves a bare/relative command against the
+ * *calling process's* `Path` env var and — critically — does NOT apply PATHEXT.
+ * So a provider command like `claude` never matches `claude.exe` and the native
+ * layer throws `File not found:` (empty), which crashes the daemon. We resolve
+ * it to an absolute `.exe` here (in the daemon process, which has the full PATH)
+ * before the command ever reaches node-pty.
+ *
+ * No-op on non-Windows and when the command is already an existing absolute path
+ * or cannot be resolved (caller keeps the original behaviour).
+ */
+export function resolveWin32Executable(command: string): string {
+  if (process.platform !== 'win32') return command;
+  const trimmed = (command || '').trim();
+  if (!trimmed) return command;
+
+  // Already an absolute path that exists — keep it.
+  if (path.isAbsolute(trimmed) && existsSync(trimmed)) return trimmed;
+
+  try {
+    const out = execFileSync('where', [trimmed], {
+      encoding: 'utf8',
+      windowsHide: true,
+    }).trim();
+    if (out) {
+      const matches = out.split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+      // Prefer a directly-launchable executable (.exe/.com) over .cmd/.bat shims.
+      const direct = matches.find((m) => DIRECT_EXEC_EXT.has(path.extname(m).toLowerCase()));
+      return direct || matches[0] || command;
+    }
+  } catch {
+    // `where` not found / non-zero exit — fall through to the global-bin scan.
+  }
+
+  // `where` found nothing on PATH. Before giving up (and letting node-pty crash
+  // with "File not found:" on the bare command), search npm's off-PATH global
+  // bin dir(s). This is the codex case: `npm i -g @openai/codex` installs to
+  // %APPDATA%\npm, which is absent from a nvm-launched daemon's PATH, so a spec
+  // binary of "codex" never resolved and the spawn ENOENT'd.
+  const globalBin = resolveWin32GlobalBin(trimmed);
+  if (globalBin) return globalBin;
+
+  return command;
+}