@adecore/agents 0.27.1 → 0.27.3

package/dist/chat/backend.d.ts

@@ -12,6 +12,7 @@ export interface BackendLaunch {
     generation: number;
     instructions: string | null;
     resumeNote: string | null;
+    resumeInstructions?: string | null;
     goal?: ChatGoal;
     folders?: readonly string[];
     projectConfig?: boolean;

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

@@ -29,6 +29,7 @@ export interface ChatCoreHooks {
     runtimeModeFor?(chatId: string, mode: RuntimeMode): RuntimeMode;
     instructionsFor?(chatId: string): string | null;
     resumeNoteFor?(chatId: string): string | null;
+    resumeInstructionsFor?(chatId: string): string | null;
     foldersFor?(chatId: string): readonly string[];
     projectConfigFor?(chatId: string): boolean;
     hiddenFor?(chatId: string): boolean;

package/dist/chat/chat-core.js

@@ -306,6 +306,7 @@ export class ChatCore {
             saveGeneratedImage: (ref, upload) => this.attachments.saveGenerated(payload.chatId, ref, upload),
             instructions: () => (this.hooks.instructionsFor ? this.hooks.instructionsFor(payload.chatId) : this.instructions),
             resumeNote: () => this.hooks.resumeNoteFor?.(payload.chatId) ?? null,
+            resumeInstructions: () => this.hooks.resumeInstructionsFor?.(payload.chatId) ?? null,
             folders: () => this.hooks.foldersFor?.(payload.chatId) ?? [],
             projectConfig: () => this.hooks.projectConfigFor?.(payload.chatId) ?? true,
             ...(promptNotes ? { promptNotes } : {}),

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

@@ -41,6 +41,7 @@ export interface ChatSessionOptions {
     saveGeneratedImage?: BackendLaunch['saveGeneratedImage'];
     instructions?(): string | null;
     resumeNote?(): string | null;
+    resumeInstructions?(): string | null;
     folders?(): readonly string[];
     projectConfig?(): boolean;
     promptNotes?: PromptNotes;
@@ -154,6 +155,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]) => {
@@ -1599,6 +1629,7 @@ export class ChatSession {
             saveGeneratedImage: this.options.saveGeneratedImage,
             instructions: this.options.instructions?.() ?? null,
             resumeNote: this.options.resumeNote?.() ?? null,
+            resumeInstructions: this.options.resumeInstructions?.() ?? null,
             ...(info.goal === undefined ? {} : { goal: info.goal }),
             ...(folders.length > 0 ? { folders } : {}),
             ...(projectConfig ? {} : { projectConfig }),

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.d.ts

@@ -39,6 +39,7 @@ export declare class CodexBackend implements ChatBackend {
     get pid(): number | null;
     start(): Promise<void>;
     private handshake;
+    private resumeContext;
     private readGoal;
     private turnInput;
     sendTurn(input: TurnInput): void;

package/dist/chat/codex-backend.js

@@ -68,7 +68,7 @@ export class CodexBackend {
     imageWrites = null;
     transport = null;
     threadId = '';
-    // Codex 0.154 ignores developer instructions on `thread/resume` (measured), so the first prompt of a resumed process carries them.
+    // Codex ignores developer instructions on `thread/resume` (measured on 0.154 and 0.163), so the first prompt of a resumed process carries them.
     contextPending = null;
     imageInputSupported = null;
     /* A turn asked for that Codex has not named yet; `turn/interrupt` needs that name. */
@@ -131,7 +131,7 @@ export class CodexBackend {
         if (this.launch.resume) {
             try {
                 result = await transport.request('thread/resume', { threadId: this.launch.resume, excludeTurns: true, ...params });
-                this.contextPending = this.launch.resumeNote;
+                this.contextPending = await this.resumeContext(transport, this.launch.resume);
             }
             catch (error) {
                 // A refusal means the thread is gone from Codex's store and a fresh one keeps the chat usable; a silence or an exit says nothing about the thread.
@@ -156,6 +156,26 @@ export class CodexBackend {
             // An app-server without goals, or with the feature turned off, has none to report.
         });
     }
+    /*
+     * A developer message outranks the thread's first instructions, where a note in front of the prompt loses to
+     * them; an app-server without `thread/inject_items` gets the instructions in front of the prompt after all.
+     */
+    async resumeContext(transport, threadId) {
+        const instructions = this.launch.resumeInstructions ?? null;
+        if (instructions !== null) {
+            try {
+                const items = [{ type: 'message', role: 'developer', content: [{ type: 'input_text', text: instructions }] }];
+                await transport.request('thread/inject_items', { threadId, items });
+            }
+            catch (error) {
+                if (!(error instanceof Error) || error.name !== 'CodexRpcError') {
+                    throw error;
+                }
+                return [instructions, this.launch.resumeNote].filter((part) => part !== null).join('\n\n');
+            }
+        }
+        return this.launch.resumeNote;
+    }
     async readGoal(transport) {
         const result = await transport.request('thread/goal/get', { threadId: this.threadId });
         const goal = codexGoal(isRecord(result) ? result.goal : null);
@@ -318,7 +338,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/dist/testing/fake-codex.d.ts

@@ -4,6 +4,7 @@ export declare const FAKE_CHILD_STEPS = 250;
 export declare const fakeCodexForks: Frame[];
 export interface FakeCodexOptions {
     resumeLead?: string;
+    injectItems?: boolean;
 }
 export declare function fakeCodexWith(options: FakeCodexOptions): FakeCli;
 export declare const fakeCodex: FakeCli;

package/dist/testing/fake-codex.js

@@ -451,6 +451,22 @@ export function fakeCodexWith(options) {
                     notify('thread/started', { thread });
                     return;
                 }
+                case 'thread/inject_items': {
+                    if (options.injectItems === false) {
+                        out({ id, error: { code: -32601, message: 'unknown method thread/inject_items' } });
+                        return;
+                    }
+                    // The newest developer message is the one the model follows, so `note?` answers with it.
+                    const items = Array.isArray(params.items) ? params.items : [];
+                    for (const injected of items) {
+                        const content = Array.isArray(injected.content) ? injected.content[0] : undefined;
+                        if (injected.role === 'developer' && typeof content?.text === 'string') {
+                            threadInstructions.set(String(params.threadId), content.text);
+                        }
+                    }
+                    out({ id, result: {} });
+                    return;
+                }
                 case 'thread/fork': {
                     const source = String(params.threadId);
                     const turns = threadTurns.get(source) ?? [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/agents",
-  "version": "0.27.1",
+  "version": "0.27.3",
   "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.1",
-    "@adecore/intelligent-ui": "0.27.1",
+    "@adecore/agent-contracts": "0.27.3",
+    "@adecore/intelligent-ui": "0.27.3",
     "zod": "^4.6.5"
   },
   "devDependencies": {

package/src/chat/backend.ts

@@ -40,6 +40,9 @@ export interface BackendLaunch {
     // The part of it a resumed thread has to hear again in front of its next prompt, for a CLI that ignores new
     // instructions on a resume; null when there is nothing to repeat.
     resumeNote: string | null;
+    // Instructions a resumed thread takes in as a developer message, for a CLI that keeps the ones its thread started
+    // with; absent or null when the thread holds them already.
+    resumeInstructions?: string | null;
     // The goal the chat last knew of, which a CLI that takes it up again from its own transcript on a resume still works toward.
     goal?: ChatGoal;
     // Folders outside `cwd` the agent may reach without asking. Claude Code takes them as `--add-dir`; Codex's

package/src/chat/chat-core.ts

@@ -119,6 +119,8 @@ export interface ChatCoreHooks {
     instructionsFor?(chatId: string): string | null;
     /* What of the instructions a resumed thread hears again in front of its next prompt, for a CLI that ignores them on a resume. */
     resumeNoteFor?(chatId: string): string | null;
+    /* Instructions a resumed thread takes in again as a developer message, for a CLI that keeps those its thread started with; null when it holds them. */
+    resumeInstructionsFor?(chatId: string): string | null;
     /*
      * Folders outside its working directory a chat's agent may reach without asking, absolute. Asked
      * before every turn, so a host can hand one over for as long as it is needed: a change starts the
@@ -495,6 +497,7 @@ export class ChatCore {
             saveGeneratedImage: (ref, upload) => this.attachments.saveGenerated(payload.chatId, ref, upload),
             instructions: () => (this.hooks.instructionsFor ? this.hooks.instructionsFor(payload.chatId) : this.instructions),
             resumeNote: () => this.hooks.resumeNoteFor?.(payload.chatId) ?? null,
+            resumeInstructions: () => this.hooks.resumeInstructionsFor?.(payload.chatId) ?? null,
             folders: () => this.hooks.foldersFor?.(payload.chatId) ?? [],
             projectConfig: () => this.hooks.projectConfigFor?.(payload.chatId) ?? true,
             ...(promptNotes ? { promptNotes } : {}),

package/src/chat/chat-session.ts

@@ -76,6 +76,7 @@ export interface ChatSessionOptions {
     // What the agent is told at the start of every process, and what of it a resumed thread hears again; see `BackendLaunch`.
     instructions?(): string | null;
     resumeNote?(): string | null;
+    resumeInstructions?(): string | null;
     // The folders beside the working directory, asked before every turn; a change starts the next turn in a new process.
     folders?(): readonly string[];
     // False runs the CLI without the configuration of the working folder; asked before every turn like the folders.
@@ -116,6 +117,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 +547,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 +1736,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]) => {
@@ -1840,6 +1877,7 @@ export class ChatSession {
             saveGeneratedImage: this.options.saveGeneratedImage,
             instructions: this.options.instructions?.() ?? null,
             resumeNote: this.options.resumeNote?.() ?? null,
+            resumeInstructions: this.options.resumeInstructions?.() ?? null,
             ...(info.goal === undefined ? {} : { goal: info.goal }),
             ...(folders.length > 0 ? { folders } : {}),
             ...(projectConfig ? {} : { projectConfig }),

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

@@ -81,7 +81,7 @@ export class CodexBackend implements ChatBackend {
     private imageWrites: Promise<void> | null = null;
     private transport: CodexTransport | null = null;
     private threadId = '';
-    // Codex 0.154 ignores developer instructions on `thread/resume` (measured), so the first prompt of a resumed process carries them.
+    // Codex ignores developer instructions on `thread/resume` (measured on 0.154 and 0.163), so the first prompt of a resumed process carries them.
     private contextPending: string | null = null;
     private imageInputSupported: boolean | null = null;
     /* A turn asked for that Codex has not named yet; `turn/interrupt` needs that name. */
@@ -148,7 +148,7 @@ export class CodexBackend implements ChatBackend {
         if (this.launch.resume) {
             try {
                 result = await transport.request('thread/resume', { threadId: this.launch.resume, excludeTurns: true, ...params });
-                this.contextPending = this.launch.resumeNote;
+                this.contextPending = await this.resumeContext(transport, this.launch.resume);
             } catch (error) {
                 // A refusal means the thread is gone from Codex's store and a fresh one keeps the chat usable; a silence or an exit says nothing about the thread.
                 if (!(error instanceof Error) || error.name !== 'CodexRpcError') {
@@ -172,6 +172,26 @@ export class CodexBackend implements ChatBackend {
         });
     }
 
+    /*
+     * A developer message outranks the thread's first instructions, where a note in front of the prompt loses to
+     * them; an app-server without `thread/inject_items` gets the instructions in front of the prompt after all.
+     */
+    private async resumeContext(transport: CodexTransport, threadId: string): Promise<string | null> {
+        const instructions = this.launch.resumeInstructions ?? null;
+        if (instructions !== null) {
+            try {
+                const items = [{ type: 'message', role: 'developer', content: [{ type: 'input_text', text: instructions }] }];
+                await transport.request('thread/inject_items', { threadId, items });
+            } catch (error) {
+                if (!(error instanceof Error) || error.name !== 'CodexRpcError') {
+                    throw error;
+                }
+                return [instructions, this.launch.resumeNote].filter((part) => part !== null).join('\n\n');
+            }
+        }
+        return this.launch.resumeNote;
+    }
+
     private async readGoal(transport: CodexTransport): Promise<ChatGoal | null> {
         const result = await transport.request('thread/goal/get', { threadId: this.threadId });
         const goal = codexGoal(isRecord(result) ? result.goal : null);
@@ -338,7 +358,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();

package/src/testing/fake-codex.ts

@@ -26,6 +26,8 @@ export const fakeCodexForks: Frame[] = [];
 export interface FakeCodexOptions {
     // How the note a host repeats in front of a resumed thread's first prompt starts; `pasted?` answers it back.
     resumeLead?: string;
+    // False answers `thread/inject_items` the way an app-server without it does.
+    injectItems?: boolean;
 }
 
 export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
@@ -490,6 +492,22 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
                     notify('thread/started', { thread });
                     return;
                 }
+                case 'thread/inject_items': {
+                    if (options.injectItems === false) {
+                        out({ id, error: { code: -32601, message: 'unknown method thread/inject_items' } });
+                        return;
+                    }
+                    // The newest developer message is the one the model follows, so `note?` answers with it.
+                    const items = Array.isArray(params.items) ? (params.items as Frame[]) : [];
+                    for (const injected of items) {
+                        const content = Array.isArray(injected.content) ? (injected.content[0] as { text?: unknown } | undefined) : undefined;
+                        if (injected.role === 'developer' && typeof content?.text === 'string') {
+                            threadInstructions.set(String(params.threadId), content.text);
+                        }
+                    }
+                    out({ id, result: {} });
+                    return;
+                }
                 case 'thread/fork': {
                     const source = String(params.threadId);
                     const turns = threadTurns.get(source) ?? [];