@adecore/agents 0.27.0 → 0.27.2

package/dist/chat/chat-session.d.ts

@@ -154,6 +154,7 @@ export declare class ChatSession {
         turnId: string;
     }>;
     private submitInput;
+    private steer;
     unqueue(messageId: string): ChatQueuedMessage | null;
     sendNow(messageId: string): boolean;
     private get queue();

package/dist/chat/chat-session.js

@@ -12,6 +12,8 @@ import { errorText } from '../error-text.js';
 import { systemClock } from '../outbox/outbox-worker.js';
 // Claude Code names a session about six seconds after its first prompt, and a first turn can run for minutes.
 const TITLE_RECHECK_MS = 10_000;
+// Well inside the 60 seconds a client gives a request; the steer itself goes on after it.
+const STEER_ANSWER_MS = 15_000;
 /* One per limited turn, so a second fork of the same turn writes no second note. */
 function continuedNoteId(turnId) {
     return `continued-${turnId}`;
@@ -383,9 +385,30 @@ export class ChatSession {
             return queued;
         }
         this.steering.add(message.id);
+        const steer = this.steer(message, text, extras, backend.steerTurn.bind(backend), turnId, queued);
+        // Claude takes a steer only between tool calls, so a long command would outlast the client's request.
+        const clock = this.options.clock ?? systemClock;
+        let timer = null;
+        const waited = new Promise((resolve) => {
+            timer = clock.setTimeout(() => resolve(null), STEER_ANSWER_MS);
+        });
+        try {
+            const answer = await Promise.race([steer, waited]);
+            if (answer !== null) {
+                return answer;
+            }
+            // Still in the queue until it is taken; a later failure pauses the queue as it does now.
+            steer.catch(() => undefined);
+            return queued;
+        }
+        finally {
+            clock.clearTimeout(timer);
+        }
+    }
+    async steer(message, text, extras, steerTurn, turnId, queued) {
         try {
             const references = this.options.references?.(extras.chats) ?? { ids: extras.chats ?? [], note: null };
-            const accepted = await backend.steerTurn({
+            const accepted = await steerTurn({
                 promptId: message.id,
                 text,
                 preamble: references.note,
@@ -1475,7 +1498,14 @@ export class ChatSession {
             return;
         }
         const pending = this.watchStart(turnId);
-        const backend = this.ensureBackend();
+        let backend;
+        try {
+            backend = this.ensureBackend();
+        }
+        catch (error) {
+            // What the host prepares for a launch (its folders, its instructions) can throw too; the turn already opened, so it fails.
+            backend = Promise.reject(error instanceof Error ? error : new Error(String(error)));
+        }
         const generation = this.generation;
         void Promise.all([backend, this.turnReady, this.options.save?.()])
             .then(([started]) => {

package/dist/chat/claude-backend.d.ts

@@ -32,6 +32,7 @@ export declare class ClaudeBackend implements ChatBackend {
     private readLines;
     private handleLine;
     private readLine;
+    private cancelledSteer;
     private awaitSteers;
     private clearSteerTimer;
     private rejectSteers;

package/dist/chat/claude-backend.js

@@ -7,6 +7,8 @@ import { buildUserMessage } from './input.js';
 // Claude may echo a steer only once a slow tool returns, so a running turn sets no deadline; after the turn ended, a message
 // it still holds opens the next turn at once or never arrives.
 const STEER_GRACE_MS = 30_000;
+// The request id of a `cancel_async_message` that withdraws a steer, followed by its uuid.
+const CANCEL_STEER = 'cancel-steer-';
 /*
  * One `claude -p` process on the stream-json protocol: flags from the selection and the modes,
  * frames in over stdout, frames out over stdin. The process stays alive between turns; the session
@@ -101,6 +103,14 @@ export class ClaudeBackend {
         this.interrupted = true;
         this.protocol.noteInterrupt();
         this.write({ type: 'control_request', request_id: `interrupt-${Date.now()}`, request: { subtype: 'interrupt' } });
+        // A steer the CLI has not taken in survives a plain interrupt and would run after the Stop; it goes back to the queue instead.
+        for (const promptId of this.steers.keys()) {
+            this.write({
+                type: 'control_request',
+                request_id: `${CANCEL_STEER}${promptId}`,
+                request: { subtype: 'cancel_async_message', message_uuid: promptId }
+            });
+        }
     }
     stopTask(taskId) {
         this.write(this.protocol.stopTaskRequest(taskId));
@@ -167,6 +177,9 @@ export class ClaudeBackend {
             return;
         }
         const echoed = typeof frame === 'object' && frame !== null ? frame : null;
+        if (echoed?.type === 'control_response' && this.cancelledSteer(echoed.response)) {
+            return;
+        }
         if (echoed?.type === 'user' && typeof echoed.uuid === 'string' && echoed.parent_tool_use_id == null) {
             this.steers.get(echoed.uuid)?.resolve(true);
             this.steers.delete(echoed.uuid);
@@ -195,6 +208,25 @@ export class ClaudeBackend {
             this.failed(error);
         }
     }
+    /* Whether this answers a withdrawn steer; one the CLI no longer held (already taken in) still waits for its echo. */
+    cancelledSteer(response) {
+        if (typeof response !== 'object' || response === null) {
+            return false;
+        }
+        const { request_id: requestId, response: body } = response;
+        if (typeof requestId !== 'string' || !requestId.startsWith(CANCEL_STEER)) {
+            return false;
+        }
+        const promptId = requestId.slice(CANCEL_STEER.length);
+        if (typeof body === 'object' && body !== null && body.cancelled === true) {
+            this.steers.get(promptId)?.resolve(false);
+            this.steers.delete(promptId);
+            if (this.steers.size === 0) {
+                this.clearSteerTimer();
+            }
+        }
+        return true;
+    }
     awaitSteers() {
         if (this.steers.size === 0 || this.steerTimer !== null) {
             return;

package/dist/chat/codex-backend.js

@@ -318,7 +318,8 @@ export class CodexBackend {
         }
         catch (error) {
             const rejected = error instanceof Error && error.name === 'CodexRpcError';
-            if (rejected && /no active turn|not.*active|turn.*mismatch|expected.*turn|method not found/i.test(error.message)) {
+            // A compact or review turn takes no steer (codex 0.162: "cannot steer a compact turn"); the message waits for the next turn.
+            if (rejected && /no active turn|not.*active|turn.*mismatch|expected.*turn|method not found|cannot steer|not steerable/i.test(error.message)) {
                 return false;
             }
             throw error;

package/dist/chat/projector.d.ts

@@ -21,6 +21,7 @@ export declare class ThreadProjector {
     private readonly pendingMetadata;
     private readonly backgroundCalls;
     private readonly unplacedCalls;
+    private readonly wokenRows;
     private thinking;
     constructor(thread: ChatThread, options: ProjectorOptions);
     reset(): void;

package/dist/chat/projector.js

@@ -100,6 +100,8 @@ export class ThreadProjector {
     backgroundCalls = new Set();
     // Agents a subagent opened whose call never reached the stream (a grandchild's own); only drill-in shows them.
     unplacedCalls = new Set();
+    // The row of an earlier process an agent woke under, by the ref of its own call in this one: its frames still name that call.
+    wokenRows = new Map();
     // The stretch of thinking still open: its item, and which refs already streamed into it.
     thinking = null;
     constructor(thread, options) {
@@ -549,7 +551,8 @@ export class ThreadProjector {
         events.push(this.thread.upsert({ ...tool, progress }));
     }
     subagent(generation, ref) {
-        const item = this.thread.get(this.itemId(generation, ref));
+        const id = this.itemId(generation, ref);
+        const item = this.thread.get(id) ?? this.thread.get(this.wokenRows.get(id) ?? '');
         return item?.kind === 'subagent' ? item : null;
     }
     /*
@@ -652,6 +655,10 @@ export class ThreadProjector {
         }
         // A settled agent that starts again under another call was woken by a message, and works on in the background.
         const resumed = event.resumed === true || (item.status !== 'running' && item.toolUseId !== event.ref);
+        const ownCall = this.itemId(generation, item.toolUseId);
+        if (resumed && item.id !== ownCall) {
+            this.wokenRows.set(ownCall, item.id);
+        }
         events.push(this.thread.upsert({
             ...item,
             description: item.description || event.description || '',

package/dist/tasks/wiring.js

@@ -104,9 +104,16 @@ export function wireTasks(deps) {
         coordinator,
         recover: async () => {
             for (const task of deps.tasks.all()) {
-                if (task.status === 'open') {
+                if (task.status !== 'open') {
+                    continue;
+                }
+                // One child whose record this version cannot read must not keep every later task from recovering.
+                try {
                     await recoverOpen(task);
                 }
+                catch (e) {
+                    console.error(`Recovering task ${task.id} failed:`, errorText(e));
+                }
             }
             await coordinator.settled();
             for (const task of deps.tasks.all()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/agents",
-  "version": "0.27.0",
+  "version": "0.27.2",
   "description": "Node-compatible agent chat hosts, providers, accounts, usage and durable task coordination.",
   "type": "module",
   "exports": {
@@ -81,8 +81,8 @@
     "test": "bun --conditions=source test"
   },
   "dependencies": {
-    "@adecore/agent-contracts": "0.27.0",
-    "@adecore/intelligent-ui": "0.27.0",
+    "@adecore/agent-contracts": "0.27.2",
+    "@adecore/intelligent-ui": "0.27.2",
     "zod": "^4.6.5"
   },
   "devDependencies": {

package/src/chat/chat-session.ts

@@ -116,6 +116,8 @@ export interface LimitResumeHooks {
 
 // Claude Code names a session about six seconds after its first prompt, and a first turn can run for minutes.
 const TITLE_RECHECK_MS = 10_000;
+// Well inside the 60 seconds a client gives a request; the steer itself goes on after it.
+const STEER_ANSWER_MS = 15_000;
 
 export interface ChatSendExtras {
     uiChoice?: ChatUiChoiceOrigin;
@@ -544,9 +546,37 @@ export class ChatSession {
             return queued;
         }
         this.steering.add(message.id);
+        const steer = this.steer(message, text, extras, backend.steerTurn.bind(backend), turnId, queued);
+        // Claude takes a steer only between tool calls, so a long command would outlast the client's request.
+        const clock = this.options.clock ?? systemClock;
+        let timer: unknown = null;
+        const waited = new Promise<null>((resolve) => {
+            timer = clock.setTimeout(() => resolve(null), STEER_ANSWER_MS);
+        });
+        try {
+            const answer = await Promise.race([steer, waited]);
+            if (answer !== null) {
+                return answer;
+            }
+            // Still in the queue until it is taken; a later failure pauses the queue as it does now.
+            steer.catch(() => undefined);
+            return queued;
+        } finally {
+            clock.clearTimeout(timer);
+        }
+    }
+
+    private async steer(
+        message: ChatQueuedMessage,
+        text: string,
+        extras: ChatSendExtras,
+        steerTurn: NonNullable<ChatBackend['steerTurn']>,
+        turnId: string,
+        queued: { queued: boolean; turnId: string }
+    ): Promise<{ queued: boolean; turnId: string }> {
         try {
             const references = this.options.references?.(extras.chats) ?? { ids: extras.chats ?? [], note: null };
-            const accepted = await backend.steerTurn({
+            const accepted = await steerTurn({
                 promptId: message.id,
                 text,
                 preamble: references.note,
@@ -1705,7 +1735,13 @@ export class ChatSession {
             return;
         }
         const pending = this.watchStart(turnId);
-        const backend = this.ensureBackend();
+        let backend: Promise<ChatBackend>;
+        try {
+            backend = this.ensureBackend();
+        } catch (error) {
+            // What the host prepares for a launch (its folders, its instructions) can throw too; the turn already opened, so it fails.
+            backend = Promise.reject(error instanceof Error ? error : new Error(String(error)));
+        }
         const generation = this.generation;
         void Promise.all([backend, this.turnReady, this.options.save?.()])
             .then(([started]) => {

package/src/chat/claude-backend.ts

@@ -9,6 +9,8 @@ import { buildUserMessage } from './input.ts';
 // Claude may echo a steer only once a slow tool returns, so a running turn sets no deadline; after the turn ended, a message
 // it still holds opens the next turn at once or never arrives.
 const STEER_GRACE_MS = 30_000;
+// The request id of a `cancel_async_message` that withdraws a steer, followed by its uuid.
+const CANCEL_STEER = 'cancel-steer-';
 
 export interface ClaudeBackendOptions {
     // Tools the CLI runs without asking, in every mode, as `--allowedTools` patterns (`Bash(git status)`).
@@ -116,6 +118,14 @@ export class ClaudeBackend implements ChatBackend {
         this.interrupted = true;
         this.protocol.noteInterrupt();
         this.write({ type: 'control_request', request_id: `interrupt-${Date.now()}`, request: { subtype: 'interrupt' } });
+        // A steer the CLI has not taken in survives a plain interrupt and would run after the Stop; it goes back to the queue instead.
+        for (const promptId of this.steers.keys()) {
+            this.write({
+                type: 'control_request',
+                request_id: `${CANCEL_STEER}${promptId}`,
+                request: { subtype: 'cancel_async_message', message_uuid: promptId }
+            });
+        }
     }
 
     stopTask(taskId: string): void {
@@ -193,6 +203,9 @@ export class ClaudeBackend implements ChatBackend {
             return;
         }
         const echoed = typeof frame === 'object' && frame !== null ? (frame as Record<string, unknown>) : null;
+        if (echoed?.type === 'control_response' && this.cancelledSteer(echoed.response)) {
+            return;
+        }
         if (echoed?.type === 'user' && typeof echoed.uuid === 'string' && echoed.parent_tool_use_id == null) {
             this.steers.get(echoed.uuid)?.resolve(true);
             this.steers.delete(echoed.uuid);
@@ -222,6 +235,26 @@ export class ClaudeBackend implements ChatBackend {
         }
     }
 
+    /* Whether this answers a withdrawn steer; one the CLI no longer held (already taken in) still waits for its echo. */
+    private cancelledSteer(response: unknown): boolean {
+        if (typeof response !== 'object' || response === null) {
+            return false;
+        }
+        const { request_id: requestId, response: body } = response as { request_id?: unknown; response?: unknown };
+        if (typeof requestId !== 'string' || !requestId.startsWith(CANCEL_STEER)) {
+            return false;
+        }
+        const promptId = requestId.slice(CANCEL_STEER.length);
+        if (typeof body === 'object' && body !== null && (body as { cancelled?: unknown }).cancelled === true) {
+            this.steers.get(promptId)?.resolve(false);
+            this.steers.delete(promptId);
+            if (this.steers.size === 0) {
+                this.clearSteerTimer();
+            }
+        }
+        return true;
+    }
+
     private awaitSteers(): void {
         if (this.steers.size === 0 || this.steerTimer !== null) {
             return;

package/src/chat/codex-backend.ts

@@ -338,7 +338,8 @@ export class CodexBackend implements ChatBackend {
             return true;
         } catch (error) {
             const rejected = error instanceof Error && error.name === 'CodexRpcError';
-            if (rejected && /no active turn|not.*active|turn.*mismatch|expected.*turn|method not found/i.test(error.message)) {
+            // A compact or review turn takes no steer (codex 0.162: "cannot steer a compact turn"); the message waits for the next turn.
+            if (rejected && /no active turn|not.*active|turn.*mismatch|expected.*turn|method not found|cannot steer|not steerable/i.test(error.message)) {
                 return false;
             }
             throw error;

package/src/chat/projector.ts

@@ -131,6 +131,8 @@ export class ThreadProjector {
     private readonly backgroundCalls = new Set<string>();
     // Agents a subagent opened whose call never reached the stream (a grandchild's own); only drill-in shows them.
     private readonly unplacedCalls = new Set<string>();
+    // The row of an earlier process an agent woke under, by the ref of its own call in this one: its frames still name that call.
+    private readonly wokenRows = new Map<string, string>();
     // The stretch of thinking still open: its item, and which refs already streamed into it.
     private thinking: { id: string; refs: Set<string>; last: string | null } | null = null;
 
@@ -610,7 +612,8 @@ export class ThreadProjector {
     }
 
     private subagent(generation: number, ref: string): ChatSubagentItem | null {
-        const item = this.thread.get(this.itemId(generation, ref));
+        const id = this.itemId(generation, ref);
+        const item = this.thread.get(id) ?? this.thread.get(this.wokenRows.get(id) ?? '');
         return item?.kind === 'subagent' ? item : null;
     }
 
@@ -719,6 +722,10 @@ export class ThreadProjector {
         }
         // A settled agent that starts again under another call was woken by a message, and works on in the background.
         const resumed = event.resumed === true || (item.status !== 'running' && item.toolUseId !== event.ref);
+        const ownCall = this.itemId(generation, item.toolUseId);
+        if (resumed && item.id !== ownCall) {
+            this.wokenRows.set(ownCall, item.id);
+        }
         events.push(
             this.thread.upsert({
                 ...item,

package/src/tasks/wiring.ts

@@ -181,8 +181,14 @@ export function wireTasks(deps: TaskWiringDeps): TaskWiring {
         coordinator,
         recover: async () => {
             for (const task of deps.tasks.all()) {
-                if (task.status === 'open') {
+                if (task.status !== 'open') {
+                    continue;
+                }
+                // One child whose record this version cannot read must not keep every later task from recovering.
+                try {
                     await recoverOpen(task);
+                } catch (e) {
+                    console.error(`Recovering task ${task.id} failed:`, errorText(e));
                 }
             }
             await coordinator.settled();