@borgee/agents-host 0.2.1 → 0.2.26

package/dist/providers/awaiting-user.js

@@ -0,0 +1,151 @@
+export const HOST_CONTROL_PREFIX = '[[BORGEE_CONTROL]] ';
+export const AWAITING_USER_CONTROL_PREFIX = HOST_CONTROL_PREFIX;
+function hasVisibleText(value) {
+    return value.trim().length > 0;
+}
+function stripTrailingCarriageReturn(value) {
+    return value.endsWith('\r') ? value.slice(0, -1) : value;
+}
+function matchControlLine(sourceText, trimTrailingWhitespace) {
+    const analyzedText = trimTrailingWhitespace
+        ? sourceText.replace(/[ \t\r\n]+$/u, '')
+        : sourceText;
+    const lastNewline = analyzedText.lastIndexOf('\n');
+    const lineStart = lastNewline === -1 ? 0 : lastNewline + 1;
+    const line = stripTrailingCarriageReturn(analyzedText.slice(lineStart));
+    const removalStart = lastNewline === -1 ? 0 : lastNewline;
+    if (line.startsWith(HOST_CONTROL_PREFIX)) {
+        return {
+            kind: 'footer',
+            analyzedText,
+            removalStart,
+            payload: line.slice(HOST_CONTROL_PREFIX.length),
+        };
+    }
+    if (line.length > 0 && HOST_CONTROL_PREFIX.startsWith(line)) {
+        return {
+            kind: 'plausible-prefix',
+            analyzedText,
+            removalStart,
+        };
+    }
+    return {
+        kind: 'none',
+        analyzedText,
+        removalStart,
+    };
+}
+function parseControlPayload(payload) {
+    let parsed;
+    try {
+        parsed = JSON.parse(payload);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        return null;
+    }
+    const record = parsed;
+    if (typeof record.kind !== 'string') {
+        return null;
+    }
+    if (record.kind === 'continue-to-peer' || record.kind === 'conclude-locally') {
+        return Object.keys(record).length === 1
+            ? { kind: record.kind }
+            : null;
+    }
+    if (record.kind === 'start-protocol') {
+        return Object.keys(record).length === 2
+            && typeof record.rounds === 'number'
+            && Number.isInteger(record.rounds)
+            && record.rounds > 0
+            ? {
+                kind: 'start-protocol',
+                rounds: record.rounds,
+            }
+            : null;
+    }
+    if (record.kind === 'awaiting-user') {
+        const keys = Object.keys(record);
+        if (keys.some((key) => key !== 'kind' && key !== 'question' && key !== 'reason')) {
+            return null;
+        }
+        if (typeof record.question !== 'string' || record.question.trim().length === 0) {
+            return null;
+        }
+        if (record.reason !== undefined
+            && (typeof record.reason !== 'string' || record.reason.trim().length === 0)) {
+            return null;
+        }
+        return {
+            kind: 'awaiting-user',
+            question: record.question.trim(),
+            ...(typeof record.reason === 'string' ? { reason: record.reason.trim() } : {}),
+        };
+    }
+    return null;
+}
+export function parseProviderReply(text) {
+    const match = matchControlLine(text, true);
+    if (match.kind !== 'footer' || match.payload === undefined) {
+        return { text };
+    }
+    const control = parseControlPayload(match.payload);
+    if (!control) {
+        return {
+            text: stripTrailingCarriageReturn(match.analyzedText.slice(0, match.removalStart)),
+            controlMalformed: true,
+        };
+    }
+    return {
+        text: stripTrailingCarriageReturn(match.analyzedText.slice(0, match.removalStart)),
+        control,
+        ...(control.kind === 'awaiting-user'
+            ? {
+                awaitingUser: {
+                    question: control.question,
+                    ...(control.reason ? { reason: control.reason } : {}),
+                },
+            }
+            : {}),
+    };
+}
+export function sanitizeAwaitingUserProgressText(text) {
+    const match = matchControlLine(text, true);
+    if (match.kind !== 'none') {
+        return stripTrailingCarriageReturn(match.analyzedText.slice(0, match.removalStart));
+    }
+    const rawMatch = matchControlLine(text, false);
+    if (rawMatch.kind === 'none') {
+        return text;
+    }
+    return stripTrailingCarriageReturn(rawMatch.analyzedText.slice(0, rawMatch.removalStart));
+}
+export class AwaitingUserProgressSanitizer {
+    onProgress;
+    lastPublished = null;
+    constructor(onProgress) {
+        this.onProgress = onProgress;
+    }
+    publish(text) {
+        if (!this.onProgress) {
+            return;
+        }
+        const sanitizedText = sanitizeAwaitingUserProgressText(text);
+        if (!hasVisibleText(sanitizedText) || sanitizedText === this.lastPublished) {
+            return;
+        }
+        this.lastPublished = sanitizedText;
+        this.onProgress({ text: sanitizedText });
+    }
+}
+export function createAwaitingUserProgressHandler(onProgress) {
+    if (!onProgress) {
+        return undefined;
+    }
+    const sanitizer = new AwaitingUserProgressSanitizer(onProgress);
+    return (update) => {
+        sanitizer.publish(update.text);
+    };
+}

package/dist/providers/claude/adapter.d.ts

@@ -1,9 +1,11 @@
 import type { ProviderAdapter } from '../provider-adapter.js';
 import type { ProviderGenerateOptions, ProviderInput, ProviderReply } from '../../types.js';
+import { ProviderTurnPreparer } from '../../context/turn-preparation.js';
 import { ClaudeCliClient } from './cli-client.js';
 export declare class ClaudeProviderAdapter implements ProviderAdapter {
     private readonly cli;
-    constructor(cli: ClaudeCliClient);
+    private readonly turnPreparer;
+    constructor(cli: ClaudeCliClient, turnPreparer: ProviderTurnPreparer);
     generateReply(input: ProviderInput, options?: ProviderGenerateOptions): Promise<ProviderReply>;
     dispose(): Promise<void>;
 }

package/dist/providers/claude/adapter.js

@@ -1,21 +1,17 @@
-import { buildPrompt } from '../../context/prompt.js';
+import { createAwaitingUserProgressHandler, parseProviderReply } from '../awaiting-user.js';
 export class ClaudeProviderAdapter {
     cli;
-    constructor(cli) {
+    turnPreparer;
+    constructor(cli, turnPreparer) {
         this.cli = cli;
+        this.turnPreparer = turnPreparer;
     }
     async generateReply(input, options) {
-        const prompt = buildPrompt({
-            agentName: input.agentName,
-            provider: input.provider,
-            channelId: input.channelId,
-            incomingAuthorId: input.incomingAuthorId,
-            incomingContent: input.incomingContent,
+        const preparedTurn = await this.turnPreparer.prepare(input);
+        const text = await this.cli.generateReply(preparedTurn, {
+            onProgress: createAwaitingUserProgressHandler(options?.onProgress),
         });
-        const text = await this.cli.generateReply(input.channelId, prompt, {
-            onProgress: options?.onProgress,
-        });
-        return { text };
+        return parseProviderReply(text);
     }
     async dispose() {
         await this.cli.dispose();

package/dist/providers/claude/cli-client.d.ts

@@ -1,22 +1,26 @@
 import spawn from 'cross-spawn';
-import type { ProviderGenerateOptions } from '../../types.js';
+import { type DebugLogger } from '../../debug.js';
+import type { PreparedProviderTurnInput, ProviderGenerateOptions } from '../../types.js';
 import type { ClaudeChannelSessionStore } from './session-store.js';
 interface ClaudeCliRuntime {
     spawn: typeof spawn;
+    cwd: string;
 }
 /**
  * CLI client for the Claude Code CLI (`claude`) non-interactive mode, with
- * native per-channel session continuity.
+ * native provider-session continuity.
  *
  * Claude session memory remains entirely inside the Claude CLI. This client
- * only pins one native session id per Borgee channel and serializes turns per
- * channel so `--resume` is never called concurrently for the same session.
+ * only pins one native session id per routed provider session and serializes
+ * turns per route so `--resume` is never called concurrently for the same
+ * native session.
  */
 export declare class ClaudeCliClient {
     private readonly command;
     private readonly args;
     private readonly sessionStore?;
     private readonly resolveSessionStoreAgentId;
+    private readonly logger;
     private readonly runtime;
     private readonly channels;
     private readonly persistedSessions;
@@ -24,7 +28,8 @@ export declare class ClaudeCliClient {
     private stopped;
     private sessionStoreLoadPromise;
     private sessionStoreWriteQueue;
-    constructor(command: string, args: string[], runtimeOverrides?: Partial<ClaudeCliRuntime>, sessionStore?: ClaudeChannelSessionStore | undefined, resolveSessionStoreAgentId?: () => string | undefined);
+    constructor(command: string, args: string[], runtimeOverrides?: Partial<ClaudeCliRuntime>, sessionStore?: ClaudeChannelSessionStore | undefined, resolveSessionStoreAgentId?: () => string | undefined, logger?: DebugLogger);
+    generateReply(turn: PreparedProviderTurnInput, options?: ProviderGenerateOptions): Promise<string>;
     generateReply(channelId: string, prompt: string, options?: ProviderGenerateOptions): Promise<string>;
     dispose(): Promise<void>;
     private getOrCreateChannelState;
@@ -37,6 +42,8 @@ export declare class ClaudeCliClient {
     private persistSession;
     private persistSessionBestEffort;
     private resetPersistedSession;
+    private resolveTurnCwd;
+    private resetSessionIfCwdChanged;
     private resetPersistedSessionBestEffort;
     private enqueueSessionStoreWrite;
     private run;

package/dist/providers/claude/cli-client.js

@@ -1,17 +1,75 @@
 import { randomUUID } from 'node:crypto';
+import { resolve } from 'node:path';
 import spawn from 'cross-spawn';
+import { HostLogger, summarizeChildStderr, summarizeError } from '../../debug.js';
 const DEFAULT_RUNTIME = {
     spawn,
+    cwd: process.cwd(),
 };
 const STREAM_JSON_ARGS = ['--verbose', '--output-format', 'stream-json', '--include-partial-messages'];
+class ClaudeCliProcessError extends Error {
+    exitCode;
+    signal;
+    stderrBytes;
+    stderrLineCount;
+    staleResume;
+    constructor(exitCode, signal, stderrBytes, stderrLineCount, staleResume = false) {
+        super(formatClaudeCliFailureMessage(exitCode, signal, stderrBytes, stderrLineCount));
+        this.name = 'ClaudeCliProcessError';
+        if (exitCode !== null) {
+            this.exitCode = exitCode;
+        }
+        if (signal !== null) {
+            this.signal = signal;
+        }
+        this.stderrBytes = stderrBytes;
+        this.stderrLineCount = stderrLineCount;
+        this.staleResume = staleResume;
+    }
+}
+function formatClaudeCliFailureMessage(exitCode, signal, stderrBytes, stderrLineCount) {
+    const processOutcome = signal ? `signal ${signal}` : `code ${String(exitCode ?? 'unknown')}`;
+    const lineLabel = stderrLineCount === 1 ? 'line' : 'lines';
+    return `Claude CLI failed with ${processOutcome} (stderr: ${stderrBytes} bytes across ${stderrLineCount} ${lineLabel})`;
+}
+function matchesStaleResumeText(text) {
+    const normalized = text.toLowerCase();
+    return normalized.includes('session not found')
+        || normalized.includes('cannot resume')
+        || normalized.includes('no conversation found with session id');
+}
 function isStaleResumeFailure(error) {
+    if (error instanceof ClaudeCliProcessError) {
+        return error.staleResume;
+    }
     const message = normalizeError(error).message.toLowerCase();
-    return message.includes('session not found') || message.includes('cannot resume');
+    return matchesStaleResumeText(message);
 }
 function normalizeError(error) {
     return error instanceof Error ? error : new Error(String(error));
 }
-function createDeferredTurn(prompt, options) {
+function parsePersistedSessionRecord(rawValue) {
+    const trimmed = rawValue.trim();
+    if (trimmed.startsWith('{')) {
+        const parsed = JSON.parse(trimmed);
+        if (typeof parsed.sessionId === 'string' && parsed.sessionId.trim().length > 0) {
+            return {
+                sessionId: parsed.sessionId,
+                cwd: typeof parsed.cwd === 'string' && parsed.cwd.trim().length > 0
+                    ? parsed.cwd
+                    : undefined,
+            };
+        }
+    }
+    return { sessionId: rawValue };
+}
+function serializePersistedSessionRecord(record) {
+    return JSON.stringify({
+        sessionId: record.sessionId,
+        ...(record.cwd ? { cwd: record.cwd } : {}),
+    });
+}
+function createDeferredTurn(channelId, prompt, sessionPersistence, promptContext, options) {
     let settled = false;
     let resolvePromise;
     let rejectPromise;
@@ -20,7 +78,10 @@ function createDeferredTurn(prompt, options) {
         rejectPromise = reject;
     });
     return {
+        channelId,
         prompt,
+        sessionPersistence,
+        promptContext,
         options,
         promise,
         resolve(value) {
@@ -46,6 +107,17 @@ function asString(value) {
 function hasVisibleText(value) {
     return typeof value === 'string' && value.trim().length > 0;
 }
+function isRelativePathLike(value) {
+    return value.startsWith('./') || value.startsWith('../');
+}
+function resolveClaudeLaunch(command, args, baseCwd) {
+    const resolvedCommand = isRelativePathLike(command) ? resolve(baseCwd, command) : command;
+    const resolvedArgs = args.map((arg) => (isRelativePathLike(arg) ? resolve(baseCwd, arg) : arg));
+    return {
+        command: resolvedCommand,
+        args: resolvedArgs,
+    };
+}
 function readTextBlocks(blocks) {
     if (!Array.isArray(blocks)) {
         return [];
@@ -150,19 +222,28 @@ class ClaudeStreamCollector {
         this.onProgress({ text });
     }
 }
+function resolveSessionRouting(turn) {
+    return {
+        channelId: turn.channelId,
+        key: turn.providerSessionRouting?.key ?? turn.channelId,
+        persistence: turn.providerSessionRouting?.persistence ?? 'persistent',
+    };
+}
 /**
  * CLI client for the Claude Code CLI (`claude`) non-interactive mode, with
- * native per-channel session continuity.
+ * native provider-session continuity.
  *
  * Claude session memory remains entirely inside the Claude CLI. This client
- * only pins one native session id per Borgee channel and serializes turns per
- * channel so `--resume` is never called concurrently for the same session.
+ * only pins one native session id per routed provider session and serializes
+ * turns per route so `--resume` is never called concurrently for the same
+ * native session.
  */
 export class ClaudeCliClient {
     command;
     args;
     sessionStore;
     resolveSessionStoreAgentId;
+    logger;
     runtime;
     channels = new Map();
     persistedSessions = new Map();
@@ -170,22 +251,33 @@ export class ClaudeCliClient {
     stopped = false;
     sessionStoreLoadPromise = null;
     sessionStoreWriteQueue = Promise.resolve();
-    constructor(command, args, runtimeOverrides = {}, sessionStore, resolveSessionStoreAgentId = () => undefined) {
+    constructor(command, args, runtimeOverrides = {}, sessionStore, resolveSessionStoreAgentId = () => undefined, logger = new HostLogger()) {
         this.command = command;
         this.args = args;
         this.sessionStore = sessionStore;
         this.resolveSessionStoreAgentId = resolveSessionStoreAgentId;
+        this.logger = logger;
         this.runtime = { ...DEFAULT_RUNTIME, ...runtimeOverrides };
     }
-    async generateReply(channelId, prompt, options) {
+    async generateReply(channelIdOrTurn, promptOrOptions, maybeOptions) {
         if (this.stopped) {
             throw new Error('Claude CLI backend stopped');
         }
-        const state = this.getOrCreateChannelState(channelId);
-        const turn = createDeferredTurn(prompt, options);
-        state.queue.push(turn);
-        this.processChannelQueue(channelId, state);
-        return turn.promise;
+        const preparedTurn = typeof channelIdOrTurn === 'string'
+            ? {
+                channelId: channelIdOrTurn,
+                prompt: typeof promptOrOptions === 'string' ? promptOrOptions : '',
+            }
+            : channelIdOrTurn;
+        const options = typeof channelIdOrTurn === 'string'
+            ? maybeOptions
+            : promptOrOptions;
+        const sessionRouting = resolveSessionRouting(preparedTurn);
+        const state = this.getOrCreateChannelState(sessionRouting.key, sessionRouting.persistence);
+        const pendingTurn = createDeferredTurn(preparedTurn.channelId, preparedTurn.prompt, sessionRouting.persistence, preparedTurn.promptContext, options);
+        state.queue.push(pendingTurn);
+        this.processChannelQueue(sessionRouting.key, state);
+        return pendingTurn.promise;
     }
     async dispose() {
         if (this.stopped)
@@ -200,11 +292,14 @@ export class ClaudeCliClient {
             state.queue = [];
             state.activeChild?.kill('SIGTERM');
         }
+        await this.sessionStoreWriteQueue;
+        await this.sessionStore?.close?.();
     }
-    getOrCreateChannelState(channelId) {
+    getOrCreateChannelState(channelId, sessionPersistence) {
         let state = this.channels.get(channelId);
         if (!state) {
             state = {
+                sessionPersistence,
                 processing: false,
                 queue: [],
                 sessionHydrated: false,
@@ -212,6 +307,9 @@ export class ClaudeCliClient {
             };
             this.channels.set(channelId, state);
         }
+        else if (state.sessionPersistence !== sessionPersistence) {
+            throw new Error(`Claude session routing persistence changed for key "${channelId}"`);
+        }
         return state;
     }
     processChannelQueue(channelId, state) {
@@ -227,7 +325,7 @@ export class ClaudeCliClient {
                         return;
                     }
                     try {
-                        if (await this.ensureSessionStoreLoaded()) {
+                        if (state.sessionPersistence === 'persistent' && await this.ensureSessionStoreLoaded()) {
                             this.hydrateChannelState(channelId, state);
                         }
                     }
@@ -254,6 +352,13 @@ export class ClaudeCliClient {
             }
             finally {
                 state.processing = false;
+                if (state.sessionPersistence === 'ephemeral' && !this.stopped && state.queue.length === 0) {
+                    state.sessionEstablished = false;
+                    state.sessionHydrated = false;
+                    state.sessionId = undefined;
+                    state.sessionCwd = undefined;
+                    this.channels.delete(channelId);
+                }
                 if (state.queue.length > 0 && !this.stopped) {
                     this.processChannelQueue(channelId, state);
                 }
@@ -261,6 +366,7 @@ export class ClaudeCliClient {
         })();
     }
     async runTurn(channelId, state, turn) {
+        await this.resetSessionIfCwdChanged(channelId, state, turn);
         return this.runTurnAttempt(channelId, state, turn, true);
     }
     async runTurnAttempt(channelId, state, turn, allowFreshRetryAfterStaleResume) {
@@ -270,15 +376,24 @@ export class ClaudeCliClient {
         const sessionId = state.sessionEstablished ? state.sessionId : randomUUID();
         const sessionArgs = state.sessionEstablished ? ['--resume', sessionId] : ['--session-id', sessionId];
         try {
-            const text = await this.run(state, [...this.args, ...sessionArgs, ...STREAM_JSON_ARGS], turn.prompt, turn.options);
+            const text = await this.run(state, [...this.args, ...sessionArgs, ...STREAM_JSON_ARGS], turn.prompt, turn.promptContext, turn.options);
             state.sessionId = sessionId;
             state.sessionEstablished = true;
-            await this.persistSessionBestEffort(channelId, sessionId);
+            state.sessionCwd = this.resolveTurnCwd(turn);
+            if (turn.sessionPersistence === 'persistent') {
+                await this.persistSessionBestEffort(channelId, sessionId, state.sessionCwd);
+            }
             return text;
         }
         catch (error) {
             if (state.sessionEstablished && isStaleResumeFailure(error)) {
-                await this.resetPersistedSessionBestEffort(channelId, state);
+                if (turn.sessionPersistence === 'persistent') {
+                    await this.resetPersistedSessionBestEffort(channelId, state);
+                }
+                else {
+                    state.sessionEstablished = false;
+                    state.sessionId = undefined;
+                }
                 if (allowFreshRetryAfterStaleResume) {
                     return this.runTurnAttempt(channelId, state, turn, false);
                 }
@@ -311,8 +426,8 @@ export class ClaudeCliClient {
                 try {
                     const stored = await this.sessionStore.load(agentId);
                     this.persistedSessions.clear();
-                    for (const [channelId, sessionId] of Object.entries(stored)) {
-                        this.persistedSessions.set(channelId, sessionId);
+                    for (const [channelId, sessionValue] of Object.entries(stored)) {
+                        this.persistedSessions.set(channelId, parsePersistedSessionRecord(sessionValue));
                     }
                     this.loadedSessionStoreAgentId = agentId;
                 }
@@ -330,41 +445,47 @@ export class ClaudeCliClient {
             return;
         }
         state.sessionHydrated = true;
-        const persistedSessionId = this.persistedSessions.get(channelId);
-        if (!persistedSessionId) {
+        const persistedSession = this.persistedSessions.get(channelId);
+        if (!persistedSession) {
             return;
         }
-        state.sessionId = persistedSessionId;
+        state.sessionId = persistedSession.sessionId;
+        state.sessionCwd = persistedSession.cwd;
         state.sessionEstablished = true;
     }
-    async persistSession(channelId, sessionId) {
+    async persistSession(channelId, sessionId, cwd) {
         if (!this.sessionStore || !this.loadedSessionStoreAgentId) {
             return;
         }
         await this.enqueueSessionStoreWrite(async () => {
-            if (this.persistedSessions.get(channelId) === sessionId) {
+            const current = this.persistedSessions.get(channelId);
+            if (current?.sessionId === sessionId && current.cwd === cwd) {
                 return;
             }
-            this.persistedSessions.set(channelId, sessionId);
-            await this.sessionStore.save(this.loadedSessionStoreAgentId, Object.fromEntries(this.persistedSessions));
+            this.persistedSessions.set(channelId, { sessionId, cwd });
+            await this.sessionStore.save(this.loadedSessionStoreAgentId, Object.fromEntries([...this.persistedSessions.entries()].map(([persistedChannelId, record]) => [
+                persistedChannelId,
+                serializePersistedSessionRecord(record),
+            ])));
         });
     }
-    async persistSessionBestEffort(channelId, sessionId) {
+    async persistSessionBestEffort(channelId, sessionId, cwd) {
         try {
-            await this.persistSession(channelId, sessionId);
+            await this.persistSession(channelId, sessionId, cwd);
         }
         catch (error) {
-            console.error('[agents-host] failed to persist Claude session map; keeping reply delivery', {
+            this.logger.error('failed to persist Claude session map; keeping reply delivery', {
                 agentId: this.loadedSessionStoreAgentId,
                 channelId,
                 sessionId,
-                error,
+                error: summarizeError(error),
             });
         }
     }
     async resetPersistedSession(channelId, state) {
         state.sessionEstablished = false;
         state.sessionId = undefined;
+        state.sessionCwd = undefined;
         if (!this.sessionStore || !this.loadedSessionStoreAgentId) {
             return;
         }
@@ -373,18 +494,40 @@ export class ClaudeCliClient {
                 return;
             }
             this.persistedSessions.delete(channelId);
-            await this.sessionStore.save(this.loadedSessionStoreAgentId, Object.fromEntries(this.persistedSessions));
+            await this.sessionStore.save(this.loadedSessionStoreAgentId, Object.fromEntries([...this.persistedSessions.entries()].map(([persistedChannelId, record]) => [
+                persistedChannelId,
+                serializePersistedSessionRecord(record),
+            ])));
         });
     }
+    resolveTurnCwd(turn) {
+        return turn.promptContext?.taskWorkspace?.rootPath ?? this.runtime.cwd;
+    }
+    async resetSessionIfCwdChanged(channelId, state, turn) {
+        if (!state.sessionEstablished) {
+            return;
+        }
+        const nextCwd = this.resolveTurnCwd(turn);
+        if (state.sessionCwd === nextCwd) {
+            return;
+        }
+        if (turn.sessionPersistence === 'persistent') {
+            await this.resetPersistedSessionBestEffort(channelId, state);
+            return;
+        }
+        state.sessionEstablished = false;
+        state.sessionId = undefined;
+        state.sessionCwd = undefined;
+    }
     async resetPersistedSessionBestEffort(channelId, state) {
         try {
             await this.resetPersistedSession(channelId, state);
         }
         catch (error) {
-            console.error('[agents-host] failed to clear stale Claude session map; retrying in-memory only', {
+            this.logger.error('failed to clear stale Claude session map; retrying in-memory only', {
                 agentId: this.loadedSessionStoreAgentId,
                 channelId,
-                error,
+                error: summarizeError(error),
             });
         }
     }
@@ -393,10 +536,12 @@ export class ClaudeCliClient {
         this.sessionStoreWriteQueue = queuedWrite.catch(() => undefined);
         await queuedWrite;
     }
-    async run(state, args, prompt, options) {
+    async run(state, args, prompt, promptContext, options) {
         return new Promise((resolve, reject) => {
-            const child = this.runtime.spawn(this.command, args, {
+            const launch = resolveClaudeLaunch(this.command, args, this.runtime.cwd);
+            const child = this.runtime.spawn(launch.command, launch.args, {
                 stdio: ['pipe', 'pipe', 'pipe'],
+                cwd: promptContext?.taskWorkspace?.rootPath ?? this.runtime.cwd,
             });
             state.activeChild = child;
             const collector = new ClaudeStreamCollector(options?.onProgress);
@@ -441,11 +586,12 @@ export class ClaudeCliClient {
             });
             child.stderr.on('data', (chunk) => {
                 stderr += chunk;
+                this.logger?.childStderr('claude stderr', summarizeChildStderr(chunk));
             });
             child.once('error', (error) => {
                 settleReject(error);
             });
-            child.once('close', (code) => {
+            child.once('close', (code, signal) => {
                 if (state.activeChild === child) {
                     state.activeChild = undefined;
                 }
@@ -460,7 +606,8 @@ export class ClaudeCliClient {
                     }
                 }
                 if (code !== 0) {
-                    settleReject(new Error(`Claude CLI failed with code ${code}: ${stderr.trim()}`));
+                    const stderrSummary = summarizeChildStderr(stderr);
+                    settleReject(new ClaudeCliProcessError(code, signal, stderrSummary.bytes, stderrSummary.lineCount, matchesStaleResumeText(stderr)));
                     return;
                 }
                 settleResolve(collector.getFinalText());