@adecore/agents 0.20.0 → 0.20.1

package/dist/chat/backend.d.ts

@@ -194,6 +194,7 @@ export interface ChatBackend {
     readonly pid: number | null;
     start(): Promise<void>;
     sendTurn(input: TurnInput): void;
+    steerTurn?(input: TurnInput): Promise<boolean>;
     compact(): void;
     interrupt(): void;
     respondApproval(requestId: string, decision: ApprovalDecision, message?: string): boolean;

package/dist/chat/chat-core.js

@@ -546,7 +546,7 @@ export class ChatCore {
             throw new ChatError('invalid-attachments', checked.error.issues[0].message);
         }
         const attachments = await Promise.all(uploads.map((upload) => this.attachments.save(chatId, upload)));
-        return session.send(text, { ...extras, ...(attachments.length > 0 ? { attachments } : {}) });
+        return session.sendInput(text, { ...extras, ...(attachments.length > 0 ? { attachments } : {}) });
     }
     /* The file behind an attachment id: what this chat's thread or queue says it is, or a visual's page. */
     attachment(chatId, id) {

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

@@ -58,6 +58,7 @@ export interface LimitResumeHooks {
     owed(): boolean;
 }
 export interface ChatSendExtras {
+    delivery?: 'steer' | 'queue';
     mentions?: string[];
     skills?: string[];
     chats?: string[];
@@ -93,6 +94,7 @@ export declare class ChatSession {
     private readonly orphans;
     private pendingPreambles;
     private submission;
+    private readonly steering;
     constructor(options: ChatSessionOptions);
     get id(): string;
     get info(): ChatInfo;
@@ -110,6 +112,11 @@ export declare class ChatSession {
         queued: boolean;
         turnId: string;
     };
+    sendInput(text: string, extras?: ChatSendExtras): Promise<{
+        queued: boolean;
+        turnId: string;
+    }>;
+    private submitInput;
     unqueue(messageId: string): ChatQueuedMessage | null;
     sendNow(messageId: string): boolean;
     private get queue();

package/dist/chat/chat-session.js

@@ -69,6 +69,7 @@ export class ChatSession {
     orphans = new Set();
     pendingPreambles;
     submission = null;
+    steering = new Set();
     constructor(options) {
         this.options = options;
         this.pendingPreambles = options.preambles ?? [];
@@ -133,9 +134,7 @@ export class ChatSession {
         return this.thread.info;
     }
     /*
-     * A message while a turn runs joins the queue instead of being refused; the host sends it when
-     * that turn settles. One queue for both providers: Claude's steer and Codex's own queue have
-     * different semantics, and one rule is easier to reason about than a rule per CLI.
+     * Internal follow-ups wait for a new turn. User input goes through `sendInput`, which can steer native work.
      */
     send(text, extras = {}) {
         const turnId = newId('turn');
@@ -162,11 +161,74 @@ export class ChatSession {
         this.dispatch(text, extras, turnId);
         return { queued: false, turnId };
     }
+    sendInput(text, extras = {}) {
+        return this.submitInput(text, extras);
+    }
+    async submitInput(text, extras) {
+        const backend = this.backend;
+        const turnId = this.info.activeTurnId;
+        if (extras.delivery !== 'steer' ||
+            this.info.queuePaused ||
+            text.startsWith('/') ||
+            !this.busy ||
+            !turnId ||
+            !backend?.steerTurn ||
+            this.pendingStart ||
+            this.replacementWaits()) {
+            return this.send(text, extras);
+        }
+        const queued = this.send(text, extras);
+        const message = this.queue.find((entry) => entry.turnId === queued.turnId);
+        if (!message) {
+            return queued;
+        }
+        this.steering.add(message.id);
+        try {
+            const references = this.options.references?.(extras.chats) ?? { ids: extras.chats ?? [], note: null };
+            const accepted = await backend.steerTurn({
+                promptId: message.id,
+                text,
+                preamble: references.note,
+                attachments: extras.attachments ?? [],
+                mentions: extras.mentions ?? [],
+                skills: extras.skills ?? []
+            });
+            if (!accepted) {
+                return queued;
+            }
+            this.emit([
+                this.thread.upsert({
+                    id: `user-${message.id}`,
+                    kind: 'user',
+                    createdAt: message.createdAt,
+                    turnId,
+                    text,
+                    mentions: extras.mentions,
+                    skills: extras.skills,
+                    chats: references.ids,
+                    attachments: extras.attachments
+                }),
+                this.thread.patchInfo({ queue: this.queue.filter((entry) => entry.id !== message.id) })
+            ]);
+            this.options.persist();
+            return { queued: false, turnId };
+        }
+        catch (error) {
+            // A lost acknowledgement does not prove rejection. Keep the message for an explicit retry.
+            this.pauseQueue(true);
+            this.options.persist();
+            throw error;
+        }
+        finally {
+            this.steering.delete(message.id);
+            this.drainQueue();
+        }
+    }
     /* Drops a queued message and hands it back; null when nothing waits under that id, as once it went out. */
     unqueue(messageId) {
         const queue = this.queue;
         const message = queue.find((entry) => entry.id === messageId);
-        if (!message) {
+        if (!message || this.steering.has(message.id)) {
             return null;
         }
         this.setQueue(queue.filter((entry) => entry.id !== messageId));
@@ -176,7 +238,7 @@ export class ChatSession {
     sendNow(messageId) {
         const queue = this.queue;
         const message = queue.find((entry) => entry.id === messageId);
-        if (!message) {
+        if (!message || this.steering.has(message.id)) {
             return false;
         }
         this.setQueue([message, ...queue.filter((entry) => entry.id !== messageId)]);
@@ -201,6 +263,7 @@ export class ChatSession {
         const limited = limitedTurn(this.thread.list());
         const explicit = asked || this.sendAfterReplacement;
         if (!next ||
+            this.steering.size > 0 ||
             this.busy ||
             (!explicit && (this.info.queuePaused || (limited !== null && (limited.limit.kind === 'usage' || this.info.resumeAt !== undefined))))) {
             return;

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

@@ -11,11 +11,14 @@ export declare class ClaudeBackend implements ChatBackend {
     private child;
     private stdinClosed;
     private interrupted;
+    private readonly steers;
+    private active;
     constructor(launch: BackendLaunch, host: BackendHost, options?: ClaudeBackendOptions);
     get running(): boolean;
     get pid(): number | null;
     start(): Promise<void>;
     sendTurn(input: TurnInput): void;
+    steerTurn(input: TurnInput): Promise<boolean>;
     compact(): void;
     interrupt(): void;
     stopTask(taskId: string): void;
@@ -27,6 +30,7 @@ export declare class ClaudeBackend implements ChatBackend {
     private readLines;
     private handleLine;
     private readLine;
+    private rejectSteers;
     private failed;
     private respond;
     private write;

package/dist/chat/claude-backend.js

@@ -20,6 +20,8 @@ export class ClaudeBackend {
     stdinClosed = false;
     // The person asked to stop; the result frame that follows closes the turn as aborted.
     interrupted = false;
+    steers = new Map();
+    active = false;
     constructor(launch, host, options = {}) {
         this.launch = launch;
         this.host = host;
@@ -60,9 +62,28 @@ export class ClaudeBackend {
         // The prefix is what the CLI must see first (ultrathink), then the note about the links, then what was typed.
         const prefix = `${promptPrefix(this.launch.selection)}${input.preamble === null ? '' : `${input.preamble}\n\n`}`;
         const promptId = input.promptId ?? randomUUID();
+        this.active = true;
         this.protocol.beginPrompt(promptId);
         this.write(buildUserMessage({ text: input.text, attachments: input.attachments, prefix, skills: input.skills, promptId }));
     }
+    steerTurn(input) {
+        if (!this.child || !this.active || this.stdinClosed) {
+            return Promise.resolve(false);
+        }
+        const promptId = input.promptId ?? randomUUID();
+        return new Promise((resolve, reject) => {
+            this.steers.set(promptId, { resolve, reject });
+            this.protocol.beginSteer(promptId);
+            try {
+                const prefix = `${promptPrefix(this.launch.selection)}${input.preamble === null ? '' : `${input.preamble}\n\n`}`;
+                this.write(buildUserMessage({ text: input.text, attachments: input.attachments, prefix, skills: input.skills, promptId }));
+            }
+            catch (error) {
+                this.steers.delete(promptId);
+                reject(error instanceof Error ? error : new Error(errorText(error)));
+            }
+        });
+    }
     /* Claude Code folds its context through a slash command, so the session sends it as a turn. */
     compact() {
         this.sendTurn({ text: '/compact', preamble: null, attachments: [], mentions: [], skills: [] });
@@ -100,6 +121,7 @@ export class ClaudeBackend {
         this.child?.endAfterGrace();
     }
     dispose() {
+        this.rejectSteers('Claude stopped before acknowledging your message');
         const child = this.child;
         this.child = null;
         return child?.end() ?? Promise.resolve();
@@ -146,7 +168,15 @@ export class ClaudeBackend {
         catch {
             return;
         }
+        const echoed = typeof frame === 'object' && frame !== null ? frame : null;
+        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);
+        }
         for (const event of this.protocol.handle(frame)) {
+            if (event.type === 'turn.done') {
+                this.active = false;
+            }
             if (event.type === 'turn.done' && this.interrupted) {
                 this.interrupted = false;
                 this.host.onEvent({ ...event, state: 'aborted' });
@@ -163,7 +193,15 @@ export class ClaudeBackend {
             this.failed(error);
         }
     }
+    rejectSteers(reason) {
+        this.active = false;
+        for (const pending of this.steers.values()) {
+            pending.reject(new Error(reason));
+        }
+        this.steers.clear();
+    }
     failed(error) {
+        this.rejectSteers(`Claude transport failed: ${errorText(error)}`);
         this.protocol.forgetPending();
         try {
             this.host.onEvent({ type: 'failed', message: `Claude transport failed: ${errorText(error)}`, processAlive: this.running });
@@ -208,6 +246,7 @@ export class ClaudeBackend {
             return;
         }
         this.child = null;
+        this.rejectSteers('Claude exited before acknowledging your message');
         this.protocol.forgetPending();
         this.host.onEvent({ type: 'exit', exitCode, ...(stderr === null ? {} : { stderr }) });
     }

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

@@ -15,6 +15,8 @@ export declare class ClaudeProtocol {
     private readonly subagentModels;
     private apiError;
     private readonly refusedWindows;
+    private readonly steerIds;
+    beginSteer(promptId: string): void;
     beginPrompt(promptId: string): void;
     handle(frame: unknown): BackendEvent[];
     approvalResponse(requestId: string, decision: ApprovalDecision, message?: string): unknown | null;

package/dist/chat/claude-protocol.js

@@ -117,7 +117,12 @@ export class ClaudeProtocol {
     // Only main-chain errors classify the turn; each plan window can refuse it independently.
     apiError = null;
     refusedWindows = new Map();
+    steerIds = new Set();
+    beginSteer(promptId) {
+        this.steerIds.add(promptId);
+    }
     beginPrompt(promptId) {
+        this.steerIds.clear();
         this.promptId = promptId;
         this.apiError = null;
         this.refusedWindows.clear();
@@ -538,7 +543,10 @@ export class ClaudeProtocol {
     handleResult(frame, events) {
         const echoed = Array.isArray(frame.user_message_uuids) ? frame.user_message_uuids.filter((value) => typeof value === 'string') : [];
         const origin = str(frame.origin) ?? (isRecord(frame.origin) ? str(frame.origin.kind) : null);
-        if (this.promptId !== null && (echoed.length > 0 ? !echoed.includes(this.promptId) : origin !== null && origin !== 'human' && origin !== 'user')) {
+        if (this.promptId !== null &&
+            (echoed.length > 0
+                ? !echoed.includes(this.promptId) && !echoed.some((id) => this.steerIds.has(id))
+                : origin !== null && origin !== 'human' && origin !== 'user')) {
             if (typeof frame.total_cost_usd === 'number') {
                 events.push({ type: 'usage', costUsd: num(frame.total_cost_usd) });
             }
@@ -549,6 +557,9 @@ export class ClaudeProtocol {
         }
         const promptId = this.promptId !== null && echoed.includes(this.promptId) ? this.promptId : null;
         this.promptId = null;
+        for (const id of echoed) {
+            this.steerIds.delete(id);
+        }
         const failed = frame.is_error === true || (typeof frame.subtype === 'string' && frame.subtype.startsWith('error'));
         const errors = Array.isArray(frame.errors) ? frame.errors.filter((error) => typeof error === 'string') : [];
         const lastUuid = this.lastUuid;

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

@@ -22,7 +22,9 @@ export declare class CodexBackend implements ChatBackend {
     get running(): boolean;
     get pid(): number | null;
     start(): Promise<void>;
+    private turnInput;
     sendTurn(input: TurnInput): void;
+    steerTurn(input: TurnInput): Promise<boolean>;
     private acceptPrompt;
     private fail;
     private respond;

package/dist/chat/codex-backend.js

@@ -114,7 +114,7 @@ export class CodexBackend {
             this.emit(event);
         }
     }
-    sendTurn(input) {
+    turnInput(input) {
         const images = input.attachments.filter((attachment) => attachmentImageMime(attachment) !== null);
         if (images.length > 0 && this.imageInputSupported === false) {
             throw new Error(`${this.launch.modelName} does not support image input. Choose a model that accepts images.`);
@@ -140,18 +140,40 @@ export class CodexBackend {
         if (note !== '') {
             parts.push(`\n\n${note}`);
         }
+        return [...textInput(parts.join('')), ...images.map((attachment) => ({ type: 'localImage', path: attachment.path }))];
+    }
+    sendTurn(input) {
+        const nativeInput = this.turnInput(input);
         const effort = this.launch.selection.options.effort;
         const tier = codexServiceTier(this.launch.selection);
         this.turnUnnamed = true;
         this.promptId = input.promptId ?? null;
         this.request('turn/start', {
             threadId: this.threadId,
-            input: [...textInput(parts.join('')), ...images.map((attachment) => ({ type: 'localImage', path: attachment.path }))],
+            input: nativeInput,
             model: this.launch.selection.model,
             ...(typeof effort === 'string' ? { effort } : {}),
             ...(tier === null ? {} : { serviceTier: tier })
         }, () => this.acceptPrompt(input.promptId));
     }
+    async steerTurn(input) {
+        const transport = this.transport;
+        const turnId = this.protocol.turnId;
+        if (!transport || !turnId || this.turnUnnamed) {
+            return false;
+        }
+        try {
+            await transport.request('turn/steer', { threadId: this.threadId, expectedTurnId: turnId, input: this.turnInput(input) });
+            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)) {
+                return false;
+            }
+            throw error;
+        }
+    }
     acceptPrompt(promptId) {
         if (promptId !== undefined && this.promptId === promptId) {
             this.emit({ type: 'turn.accepted', promptId });
@@ -282,9 +304,9 @@ export class CodexBackend {
         this.request('turn/steer', { threadId: this.threadId, expectedTurnId: turnId, input: textInput(answer.text) });
         return true;
     }
-    /* Codex asks its async question once and waits; forgetting it locally is all a dismissal is. */
     dismissRequest(requestId) {
-        return this.protocol.dismissQuestion(requestId);
+        const answer = this.protocol.dismissQuestionAnswer(requestId);
+        return answer?.kind === 'respond' ? this.respond(requestId, answer.rpcId, answer.result) : this.protocol.dismissQuestion(requestId);
     }
     declineRequest(requestId, _message) {
         const answer = this.protocol.declineRequest(requestId);

package/dist/chat/codex-protocol.d.ts

@@ -29,6 +29,7 @@ export declare class CodexProtocol {
         result: unknown;
     } | null;
     questionAnswer(requestId: string, answers: Record<string, string>): CodexAnswer | null;
+    dismissQuestionAnswer(requestId: string): CodexAnswer | null;
     dismissQuestion(requestId: string): boolean;
     forgetPending(): void;
     declineRequest(requestId: string): {

package/dist/chat/codex-protocol.js

@@ -315,6 +315,13 @@ export class CodexProtocol {
     /* The reply that settles an approval, or null when nothing waits under that id. */
     approvalDecision(requestId, decision) {
         const pending = this.pending.get(requestId);
+        if (pending?.type === 'permissions') {
+            this.pending.delete(requestId);
+            return {
+                rpcId: pending.rpcId,
+                result: { permissions: decision === 'deny' ? {} : pending.permissions, scope: decision === 'allow-always' ? 'session' : 'turn' }
+            };
+        }
         if (pending?.type === 'elicitation') {
             this.pending.delete(requestId);
             return { rpcId: pending.rpcId, result: elicitationAnswer(decision, pending.persist) };
@@ -346,6 +353,10 @@ export class CodexProtocol {
         }
         return { kind: 'respond', rpcId: pending.rpcId, result: { answers: byId } };
     }
+    dismissQuestionAnswer(requestId) {
+        const pending = this.pending.get(requestId);
+        return pending?.type === 'question' && pending.async === true && pending.rpcId !== null ? this.questionAnswer(requestId, {}) : null;
+    }
     /* Drops an asynchronous question the person walked away from; a blocking one has to be answered. */
     dismissQuestion(requestId) {
         const pending = this.pending.get(requestId);
@@ -427,8 +438,39 @@ export class CodexProtocol {
             if (questions.length === 0) {
                 return;
             }
-            this.pending.set(requestId, { ...this.owner(params), type: 'question', rpcId, questionIds: questions.map((question) => question.id) });
-            events.push({ type: 'question.requested', requestId, questions, ...(this.isChildRequest(params) ? { background: true } : {}) });
+            this.pending.set(requestId, {
+                ...this.owner(params),
+                type: 'question',
+                rpcId,
+                questionIds: questions.map((question) => question.id),
+                async: params.isBlocking === false
+            });
+            events.push({
+                type: 'question.requested',
+                requestId,
+                questions,
+                ...(params.isBlocking === false ? { async: true } : {}),
+                ...(this.isChildRequest(params) ? { background: true } : {})
+            });
+            return;
+        }
+        if (method === 'item/permissions/requestApproval') {
+            if (!isRecord(params.permissions)) {
+                return;
+            }
+            const permissions = params.permissions;
+            this.pending.set(requestId, { ...this.owner(params), type: 'permissions', rpcId, permissions });
+            events.push({
+                type: 'approval.requested',
+                requestId,
+                ref: str(params.itemId),
+                toolName: 'RequestPermissions',
+                input: { cwd: params.cwd, permissions },
+                description: this.requestDescription(params, str(params.reason)),
+                canAllowAlways: true,
+                allowAlways: { label: 'Allow for this session', description: 'Grant these permissions for the rest of this session.' },
+                ...(this.isChildRequest(params) ? { background: true } : {})
+            });
             return;
         }
         if (method === 'mcpServer/elicitation/request') {

package/dist/host/handlers.js

@@ -31,7 +31,7 @@ export function chatHandlers(chats, providers) {
             chats.detach(payload.chatId, clientId);
             return {};
         },
-        'chat.send': (payload) => chats.send(payload.chatId, payload.text, { mentions: payload.mentions, skills: payload.skills, chats: payload.chats }, payload.attachments),
+        'chat.send': (payload) => chats.send(payload.chatId, payload.text, { delivery: payload.delivery, mentions: payload.mentions, skills: payload.skills, chats: payload.chats }, payload.attachments),
         'chat.unqueue': (payload) => ({ message: chats.unqueue(payload.chatId, payload.messageId) }),
         'chat.sendNow': (payload) => {
             chats.sendNow(payload.chatId, payload.messageId);

package/package.json

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

package/src/chat/backend.ts

@@ -175,6 +175,8 @@ export interface ChatBackend {
     // Starts the process if it has not started; resolves once the CLI can take a turn.
     start(): Promise<void>;
     sendTurn(input: TurnInput): void;
+    // Resolves after native acceptance; false means the turn ended before the input could join it.
+    steerTurn?(input: TurnInput): Promise<boolean>;
     compact(): void;
     interrupt(): void;
     // False when nothing waits under that id, so the caller can answer the client with an error.

package/src/chat/chat-core.ts

@@ -700,7 +700,7 @@ export class ChatCore {
             throw new ChatError('invalid-attachments', checked.error.issues[0]!.message);
         }
         const attachments = await Promise.all(uploads.map((upload) => this.attachments.save(chatId, upload)));
-        return session.send(text, { ...extras, ...(attachments.length > 0 ? { attachments } : {}) });
+        return session.sendInput(text, { ...extras, ...(attachments.length > 0 ? { attachments } : {}) });
     }
 
     /* The file behind an attachment id: what this chat's thread or queue says it is, or a visual's page. */

package/src/chat/chat-session.ts

@@ -98,6 +98,7 @@ export interface LimitResumeHooks {
 const TITLE_RECHECK_MS = 10_000;
 
 export interface ChatSendExtras {
+    delivery?: 'steer' | 'queue';
     mentions?: string[];
     skills?: string[];
     chats?: string[];
@@ -175,6 +176,7 @@ export class ChatSession {
     private readonly orphans = new Set<string>();
     private pendingPreambles: readonly string[];
     private submission: { turnId: string; input: TurnInput } | null = null;
+    private readonly steering = new Set<string>();
 
     constructor(options: ChatSessionOptions) {
         this.options = options;
@@ -249,9 +251,7 @@ export class ChatSession {
     }
 
     /*
-     * A message while a turn runs joins the queue instead of being refused; the host sends it when
-     * that turn settles. One queue for both providers: Claude's steer and Codex's own queue have
-     * different semantics, and one rule is easier to reason about than a rule per CLI.
+     * Internal follow-ups wait for a new turn. User input goes through `sendInput`, which can steer native work.
      */
     send(text: string, extras: ChatSendExtras = {}): { queued: boolean; turnId: string } {
         const turnId = newId('turn');
@@ -279,11 +279,76 @@ export class ChatSession {
         return { queued: false, turnId };
     }
 
+    sendInput(text: string, extras: ChatSendExtras = {}): Promise<{ queued: boolean; turnId: string }> {
+        return this.submitInput(text, extras);
+    }
+
+    private async submitInput(text: string, extras: ChatSendExtras): Promise<{ queued: boolean; turnId: string }> {
+        const backend = this.backend;
+        const turnId = this.info.activeTurnId;
+        if (
+            extras.delivery !== 'steer' ||
+            this.info.queuePaused ||
+            text.startsWith('/') ||
+            !this.busy ||
+            !turnId ||
+            !backend?.steerTurn ||
+            this.pendingStart ||
+            this.replacementWaits()
+        ) {
+            return this.send(text, extras);
+        }
+        const queued = this.send(text, extras);
+        const message = this.queue.find((entry) => entry.turnId === queued.turnId);
+        if (!message) {
+            return queued;
+        }
+        this.steering.add(message.id);
+        try {
+            const references = this.options.references?.(extras.chats) ?? { ids: extras.chats ?? [], note: null };
+            const accepted = await backend.steerTurn({
+                promptId: message.id,
+                text,
+                preamble: references.note,
+                attachments: extras.attachments ?? [],
+                mentions: extras.mentions ?? [],
+                skills: extras.skills ?? []
+            });
+            if (!accepted) {
+                return queued;
+            }
+            this.emit([
+                this.thread.upsert({
+                    id: `user-${message.id}`,
+                    kind: 'user',
+                    createdAt: message.createdAt,
+                    turnId,
+                    text,
+                    mentions: extras.mentions,
+                    skills: extras.skills,
+                    chats: references.ids,
+                    attachments: extras.attachments
+                }),
+                this.thread.patchInfo({ queue: this.queue.filter((entry) => entry.id !== message.id) })
+            ]);
+            this.options.persist();
+            return { queued: false, turnId };
+        } catch (error) {
+            // A lost acknowledgement does not prove rejection. Keep the message for an explicit retry.
+            this.pauseQueue(true);
+            this.options.persist();
+            throw error;
+        } finally {
+            this.steering.delete(message.id);
+            this.drainQueue();
+        }
+    }
+
     /* Drops a queued message and hands it back; null when nothing waits under that id, as once it went out. */
     unqueue(messageId: string): ChatQueuedMessage | null {
         const queue = this.queue;
         const message = queue.find((entry) => entry.id === messageId);
-        if (!message) {
+        if (!message || this.steering.has(message.id)) {
             return null;
         }
         this.setQueue(queue.filter((entry) => entry.id !== messageId));
@@ -294,7 +359,7 @@ export class ChatSession {
     sendNow(messageId: string): boolean {
         const queue = this.queue;
         const message = queue.find((entry) => entry.id === messageId);
-        if (!message) {
+        if (!message || this.steering.has(message.id)) {
             return false;
         }
         this.setQueue([message, ...queue.filter((entry) => entry.id !== messageId)]);
@@ -323,6 +388,7 @@ export class ChatSession {
         const explicit = asked || this.sendAfterReplacement;
         if (
             !next ||
+            this.steering.size > 0 ||
             this.busy ||
             (!explicit && (this.info.queuePaused || (limited !== null && (limited.limit.kind === 'usage' || this.info.resumeAt !== undefined))))
         ) {

package/src/chat/claude-backend.ts

@@ -27,6 +27,8 @@ export class ClaudeBackend implements ChatBackend {
     private stdinClosed = false;
     // The person asked to stop; the result frame that follows closes the turn as aborted.
     private interrupted = false;
+    private readonly steers = new Map<string, { resolve(accepted: boolean): void; reject(reason: Error): void }>();
+    private active = false;
 
     constructor(launch: BackendLaunch, host: BackendHost, options: ClaudeBackendOptions = {}) {
         this.launch = launch;
@@ -72,10 +74,29 @@ export class ClaudeBackend implements ChatBackend {
         // The prefix is what the CLI must see first (ultrathink), then the note about the links, then what was typed.
         const prefix = `${promptPrefix(this.launch.selection)}${input.preamble === null ? '' : `${input.preamble}\n\n`}`;
         const promptId = input.promptId ?? randomUUID();
+        this.active = true;
         this.protocol.beginPrompt(promptId);
         this.write(buildUserMessage({ text: input.text, attachments: input.attachments, prefix, skills: input.skills, promptId }));
     }
 
+    steerTurn(input: TurnInput): Promise<boolean> {
+        if (!this.child || !this.active || this.stdinClosed) {
+            return Promise.resolve(false);
+        }
+        const promptId = input.promptId ?? randomUUID();
+        return new Promise((resolve, reject) => {
+            this.steers.set(promptId, { resolve, reject });
+            this.protocol.beginSteer(promptId);
+            try {
+                const prefix = `${promptPrefix(this.launch.selection)}${input.preamble === null ? '' : `${input.preamble}\n\n`}`;
+                this.write(buildUserMessage({ text: input.text, attachments: input.attachments, prefix, skills: input.skills, promptId }));
+            } catch (error) {
+                this.steers.delete(promptId);
+                reject(error instanceof Error ? error : new Error(errorText(error)));
+            }
+        });
+    }
+
     /* Claude Code folds its context through a slash command, so the session sends it as a turn. */
     compact(): void {
         this.sendTurn({ text: '/compact', preamble: null, attachments: [], mentions: [], skills: [] });
@@ -120,6 +141,7 @@ export class ClaudeBackend implements ChatBackend {
     }
 
     dispose(): Promise<void> {
+        this.rejectSteers('Claude stopped before acknowledging your message');
         const child = this.child;
         this.child = null;
         return child?.end() ?? Promise.resolve();
@@ -165,7 +187,15 @@ export class ClaudeBackend implements ChatBackend {
         } catch {
             return;
         }
+        const echoed = typeof frame === 'object' && frame !== null ? (frame as Record<string, unknown>) : null;
+        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);
+        }
         for (const event of this.protocol.handle(frame)) {
+            if (event.type === 'turn.done') {
+                this.active = false;
+            }
             if (event.type === 'turn.done' && this.interrupted) {
                 this.interrupted = false;
                 this.host.onEvent({ ...event, state: 'aborted' });
@@ -183,7 +213,16 @@ export class ClaudeBackend implements ChatBackend {
         }
     }
 
+    private rejectSteers(reason: string): void {
+        this.active = false;
+        for (const pending of this.steers.values()) {
+            pending.reject(new Error(reason));
+        }
+        this.steers.clear();
+    }
+
     private failed(error: unknown): void {
+        this.rejectSteers(`Claude transport failed: ${errorText(error)}`);
         this.protocol.forgetPending();
         try {
             this.host.onEvent({ type: 'failed', message: `Claude transport failed: ${errorText(error)}`, processAlive: this.running });
@@ -229,6 +268,7 @@ export class ClaudeBackend implements ChatBackend {
             return;
         }
         this.child = null;
+        this.rejectSteers('Claude exited before acknowledging your message');
         this.protocol.forgetPending();
         this.host.onEvent({ type: 'exit', exitCode, ...(stderr === null ? {} : { stderr }) });
     }

package/src/chat/claude-protocol.ts

@@ -147,7 +147,14 @@ export class ClaudeProtocol {
     private apiError: string | null = null;
     private readonly refusedWindows = new Map<string, number | null>();
 
+    private readonly steerIds = new Set<string>();
+
+    beginSteer(promptId: string): void {
+        this.steerIds.add(promptId);
+    }
+
     beginPrompt(promptId: string): void {
+        this.steerIds.clear();
         this.promptId = promptId;
         this.apiError = null;
         this.refusedWindows.clear();
@@ -575,7 +582,12 @@ export class ClaudeProtocol {
     private handleResult(frame: Frame, events: BackendEvent[]): void {
         const echoed = Array.isArray(frame.user_message_uuids) ? frame.user_message_uuids.filter((value): value is string => typeof value === 'string') : [];
         const origin = str(frame.origin) ?? (isRecord(frame.origin) ? str(frame.origin.kind) : null);
-        if (this.promptId !== null && (echoed.length > 0 ? !echoed.includes(this.promptId) : origin !== null && origin !== 'human' && origin !== 'user')) {
+        if (
+            this.promptId !== null &&
+            (echoed.length > 0
+                ? !echoed.includes(this.promptId) && !echoed.some((id) => this.steerIds.has(id))
+                : origin !== null && origin !== 'human' && origin !== 'user')
+        ) {
             if (typeof frame.total_cost_usd === 'number') {
                 events.push({ type: 'usage', costUsd: num(frame.total_cost_usd) });
             }
@@ -586,6 +598,9 @@ export class ClaudeProtocol {
         }
         const promptId = this.promptId !== null && echoed.includes(this.promptId) ? this.promptId : null;
         this.promptId = null;
+        for (const id of echoed) {
+            this.steerIds.delete(id);
+        }
         const failed = frame.is_error === true || (typeof frame.subtype === 'string' && frame.subtype.startsWith('error'));
         const errors = Array.isArray(frame.errors) ? frame.errors.filter((error): error is string => typeof error === 'string') : [];
         const lastUuid = this.lastUuid;

package/src/chat/codex-backend.ts

@@ -126,7 +126,7 @@ export class CodexBackend implements ChatBackend {
         }
     }
 
-    sendTurn(input: TurnInput): void {
+    private turnInput(input: TurnInput): unknown[] {
         const images = input.attachments.filter((attachment) => attachmentImageMime(attachment) !== null);
         if (images.length > 0 && this.imageInputSupported === false) {
             throw new Error(`${this.launch.modelName} does not support image input. Choose a model that accepts images.`);
@@ -151,6 +151,11 @@ export class CodexBackend implements ChatBackend {
         if (note !== '') {
             parts.push(`\n\n${note}`);
         }
+        return [...textInput(parts.join('')), ...images.map((attachment) => ({ type: 'localImage', path: attachment.path }))];
+    }
+
+    sendTurn(input: TurnInput): void {
+        const nativeInput = this.turnInput(input);
         const effort = this.launch.selection.options.effort;
         const tier = codexServiceTier(this.launch.selection);
         this.turnUnnamed = true;
@@ -159,7 +164,7 @@ export class CodexBackend implements ChatBackend {
             'turn/start',
             {
                 threadId: this.threadId,
-                input: [...textInput(parts.join('')), ...images.map((attachment) => ({ type: 'localImage', path: attachment.path }))],
+                input: nativeInput,
                 model: this.launch.selection.model,
                 ...(typeof effort === 'string' ? { effort } : {}),
                 ...(tier === null ? {} : { serviceTier: tier })
@@ -168,6 +173,24 @@ export class CodexBackend implements ChatBackend {
         );
     }
 
+    async steerTurn(input: TurnInput): Promise<boolean> {
+        const transport = this.transport;
+        const turnId = this.protocol.turnId;
+        if (!transport || !turnId || this.turnUnnamed) {
+            return false;
+        }
+        try {
+            await transport.request('turn/steer', { threadId: this.threadId, expectedTurnId: turnId, input: this.turnInput(input) });
+            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)) {
+                return false;
+            }
+            throw error;
+        }
+    }
+
     private acceptPrompt(promptId: string | undefined): void {
         if (promptId !== undefined && this.promptId === promptId) {
             this.emit({ type: 'turn.accepted', promptId });
@@ -308,9 +331,9 @@ export class CodexBackend implements ChatBackend {
         return true;
     }
 
-    /* Codex asks its async question once and waits; forgetting it locally is all a dismissal is. */
     dismissRequest(requestId: string): boolean {
-        return this.protocol.dismissQuestion(requestId);
+        const answer = this.protocol.dismissQuestionAnswer(requestId);
+        return answer?.kind === 'respond' ? this.respond(requestId, answer.rpcId, answer.result) : this.protocol.dismissQuestion(requestId);
     }
 
     declineRequest(requestId: string, _message: string): boolean {

package/src/chat/codex-protocol.ts

@@ -138,7 +138,8 @@ type RequestOwner = { threadId: string | null; turnId: string | null };
 type Pending = RequestOwner &
     (
         | { type: 'approval'; rpcId: CodexRpcId; kind: 'command' | 'fileChange'; amendment: string[] | null; decisions: string[] }
-        | { type: 'question'; rpcId: CodexRpcId | null; questionIds: string[] }
+        | { type: 'question'; rpcId: CodexRpcId | null; questionIds: string[]; async?: boolean }
+        | { type: 'permissions'; rpcId: CodexRpcId; permissions: Frame }
         | { type: 'elicitation'; rpcId: CodexRpcId; persist: ElicitationPersist | null }
     );
 
@@ -361,6 +362,13 @@ export class CodexProtocol {
     /* The reply that settles an approval, or null when nothing waits under that id. */
     approvalDecision(requestId: string, decision: ApprovalDecision): { rpcId: CodexRpcId; result: unknown } | null {
         const pending = this.pending.get(requestId);
+        if (pending?.type === 'permissions') {
+            this.pending.delete(requestId);
+            return {
+                rpcId: pending.rpcId,
+                result: { permissions: decision === 'deny' ? {} : pending.permissions, scope: decision === 'allow-always' ? 'session' : 'turn' }
+            };
+        }
         if (pending?.type === 'elicitation') {
             this.pending.delete(requestId);
             return { rpcId: pending.rpcId, result: elicitationAnswer(decision, pending.persist) };
@@ -394,6 +402,11 @@ export class CodexProtocol {
         return { kind: 'respond', rpcId: pending.rpcId, result: { answers: byId } };
     }
 
+    dismissQuestionAnswer(requestId: string): CodexAnswer | null {
+        const pending = this.pending.get(requestId);
+        return pending?.type === 'question' && pending.async === true && pending.rpcId !== null ? this.questionAnswer(requestId, {}) : null;
+    }
+
     /* Drops an asynchronous question the person walked away from; a blocking one has to be answered. */
     dismissQuestion(requestId: string): boolean {
         const pending = this.pending.get(requestId);
@@ -485,8 +498,39 @@ export class CodexProtocol {
             if (questions.length === 0) {
                 return;
             }
-            this.pending.set(requestId, { ...this.owner(params), type: 'question', rpcId, questionIds: questions.map((question) => question.id) });
-            events.push({ type: 'question.requested', requestId, questions, ...(this.isChildRequest(params) ? { background: true } : {}) });
+            this.pending.set(requestId, {
+                ...this.owner(params),
+                type: 'question',
+                rpcId,
+                questionIds: questions.map((question) => question.id),
+                async: params.isBlocking === false
+            });
+            events.push({
+                type: 'question.requested',
+                requestId,
+                questions,
+                ...(params.isBlocking === false ? { async: true } : {}),
+                ...(this.isChildRequest(params) ? { background: true } : {})
+            });
+            return;
+        }
+        if (method === 'item/permissions/requestApproval') {
+            if (!isRecord(params.permissions)) {
+                return;
+            }
+            const permissions = params.permissions;
+            this.pending.set(requestId, { ...this.owner(params), type: 'permissions', rpcId, permissions });
+            events.push({
+                type: 'approval.requested',
+                requestId,
+                ref: str(params.itemId),
+                toolName: 'RequestPermissions',
+                input: { cwd: params.cwd, permissions },
+                description: this.requestDescription(params, str(params.reason)),
+                canAllowAlways: true,
+                allowAlways: { label: 'Allow for this session', description: 'Grant these permissions for the rest of this session.' },
+                ...(this.isChildRequest(params) ? { background: true } : {})
+            });
             return;
         }
         if (method === 'mcpServer/elicitation/request') {

package/src/host/handlers.ts

@@ -60,7 +60,12 @@ export function chatHandlers(chats: ChatCore, providers: ProviderRegistry): { [T
             return {};
         },
         'chat.send': (payload) =>
-            chats.send(payload.chatId, payload.text, { mentions: payload.mentions, skills: payload.skills, chats: payload.chats }, payload.attachments),
+            chats.send(
+                payload.chatId,
+                payload.text,
+                { delivery: payload.delivery, mentions: payload.mentions, skills: payload.skills, chats: payload.chats },
+                payload.attachments
+            ),
         'chat.unqueue': (payload) => ({ message: chats.unqueue(payload.chatId, payload.messageId) }),
         'chat.sendNow': (payload) => {
             chats.sendNow(payload.chatId, payload.messageId);