@adecore/agents 0.27.2 → 0.27.4

package/dist/chat/backend.d.ts

@@ -10,8 +10,10 @@ export interface BackendLaunch {
     runtimeMode: RuntimeMode;
     resume: string | null;
     generation: number;
+    now?(): number;
     instructions: string | null;
     resumeNote: string | null;
+    resumeInstructions?: string | null;
     goal?: ChatGoal;
     folders?: readonly string[];
     projectConfig?: boolean;
@@ -196,6 +198,7 @@ export type BackendEvent = {
         lastUuid?: string;
     };
     limit?: ChatTurnLimit;
+    replaceProcess?: boolean;
 } | {
     type: 'failed';
     message: string;

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;
@@ -84,6 +85,7 @@ export declare class ChatSession {
     private readonly options;
     private readonly projector;
     private backend;
+    private replaceProcess;
     private starting;
     private pendingStart;
     private sendAfterStop;

package/dist/chat/chat-session.js

@@ -43,6 +43,7 @@ export class ChatSession {
     options;
     projector;
     backend = null;
+    replaceProcess = false;
     starting = null;
     pendingStart = null;
     sendAfterStop = false;
@@ -1564,7 +1565,8 @@ export class ChatSession {
     }
     requiresReplacement() {
         return (this.backend !== null &&
-            (JSON.stringify(this.info.selection) !== JSON.stringify(this.launchedSelection) ||
+            (this.replaceProcess ||
+                JSON.stringify(this.info.selection) !== JSON.stringify(this.launchedSelection) ||
                 this.info.runtimeMode !== this.launchedRuntimeMode ||
                 this.info.account !== this.launchedAccount ||
                 this.info.cwd !== this.launchedCwd ||
@@ -1626,9 +1628,11 @@ export class ChatSession {
             runtimeMode: info.runtimeMode,
             resume: info.agentSessionId,
             generation,
+            now: () => this.options.limitResume?.now() ?? (this.options.clock ?? systemClock).now(),
             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 }),
@@ -1649,6 +1653,7 @@ export class ChatSession {
         }
         const backend = made.backend;
         this.backend = backend;
+        this.replaceProcess = false;
         this.emit([this.thread.patchInfo({ running: true, effectiveRuntimeMode: undefined, permissionMode: undefined })]);
         let started;
         try {
@@ -1729,6 +1734,9 @@ export class ChatSession {
             if (event.promptId !== undefined) {
                 this.staleResults = 0;
             }
+            if (event.replaceProcess === true) {
+                this.replaceProcess = true;
+            }
             const promptId = event.promptId ?? this.submission?.input.promptId;
             if (promptId !== undefined) {
                 this.acceptPrompt(promptId);

package/dist/chat/claude-backend.js

@@ -32,7 +32,7 @@ export class ClaudeBackend {
         this.launch = launch;
         this.host = host;
         this.allowedTools = options.allowedTools ?? [];
-        this.protocol = new ClaudeProtocol(launch.goal ?? null);
+        this.protocol = new ClaudeProtocol(launch.goal ?? null, launch.now);
     }
     get running() {
         return this.child !== null;

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

@@ -3,6 +3,7 @@ import type { ApprovalDecision, BackendEvent } from './backend.ts';
 export declare function claudeGoalFromCommand(text: string, current: ChatGoal | null): ChatGoal | null | undefined;
 export declare function claudeGoalCheck(text: string, current: ChatGoal | null): ChatGoal | undefined;
 export declare class ClaudeProtocol {
+    private readonly now;
     private promptId;
     private readonly pending;
     private streamMessageId;
@@ -18,13 +19,14 @@ export declare class ClaudeProtocol {
     private readonly subagentModels;
     private apiError;
     private readonly refusedWindows;
+    private readonly refusedResets;
     private readonly stopRequests;
     private readonly steerIds;
     private goal;
     private goalAnswered;
     private interrupting;
     private readonly backgroundAgents;
-    constructor(goal?: ChatGoal | null);
+    constructor(goal?: ChatGoal | null, now?: () => number);
     noteInterrupt(): void;
     private setGoal;
     beginSteer(promptId: string): void;
@@ -50,6 +52,7 @@ export declare class ClaudeProtocol {
     private handleUser;
     private handleResult;
     private noteRefusal;
+    private expireRefusedResets;
     private limit;
     private handleControlRequest;
     private textRef;

package/dist/chat/claude-protocol.js

@@ -153,6 +153,7 @@ export function claudeGoalCheck(text, current) {
  * belongs to one process, so a resumed CLI that numbers its messages from the start gets its own.
  */
 export class ClaudeProtocol {
+    now;
     promptId = null;
     pending = new Map();
     streamMessageId = null;
@@ -174,6 +175,8 @@ export class ClaudeProtocol {
     // Only main-chain errors classify the turn; each plan window can refuse it independently.
     apiError = null;
     refusedWindows = new Map();
+    // Sparse refusals can omit a reset; cached metadata alone must never classify a later 429.
+    refusedResets = new Map();
     // The task each `stop_task` request named, so an error answer finds it again.
     stopRequests = new Map();
     steerIds = new Set();
@@ -184,8 +187,9 @@ export class ClaudeProtocol {
     interrupting = false;
     // Background subagents still at work; Claude Code holds a goal's check until they report.
     backgroundAgents = new Set();
-    constructor(goal = null) {
+    constructor(goal = null, now = () => Date.now()) {
         this.goal = goal;
+        this.now = now;
     }
     /* A stop is on its way; the turn it ends leaves the goal set but nobody working on it. */
     noteInterrupt() {
@@ -204,6 +208,7 @@ export class ClaudeProtocol {
         this.promptId = promptId;
         this.apiError = null;
         this.refusedWindows.clear();
+        this.expireRefusedResets();
         this.lastUuid = null;
     }
     handle(frame) {
@@ -713,6 +718,10 @@ export class ClaudeProtocol {
         const lastUuid = this.lastUuid;
         this.lastUuid = null;
         const limit = failed ? this.limit() : null;
+        const replaceProcess = failed && this.apiError === 'authentication_failed';
+        if (limit?.kind !== 'usage') {
+            this.refusedResets.clear();
+        }
         this.apiError = null;
         this.refusedWindows.clear();
         // Before the turn ends, so whoever settles work on that end already reads where the goal stands.
@@ -724,21 +733,41 @@ export class ClaudeProtocol {
             costUsd: num(frame.total_cost_usd),
             ...(failed ? { error: errors[0] ?? str(frame.result) ?? `The turn ended with ${str(frame.subtype) ?? 'an error'}` } : {}),
             ...(lastUuid === null ? {} : { native: { lastUuid } }),
-            ...(limit === null ? {} : { limit })
+            ...(limit === null ? {} : { limit }),
+            ...(replaceProcess ? { replaceProcess: true } : {})
         });
     }
     noteRefusal(info) {
         if (!isRecord(info) || typeof info.status !== 'string') {
             return;
         }
-        const window = str(info.rateLimitType) ?? 'unknown';
+        this.expireRefusedResets();
+        const namedWindow = str(info.rateLimitType);
+        const window = namedWindow ?? 'unknown';
         const overageAllowed = info.overageStatus === 'allowed' || info.overageStatus === 'allowed_warning' || info.isUsingOverage === true || info.overageInUse === true;
         if (info.status === 'rejected' && !overageAllowed) {
             const resetsAt = typeof info.resetsAt === 'number' ? info.resetsAt * 1000 : NaN;
-            this.refusedWindows.set(window, Number.isFinite(resetsAt) && resetsAt > 0 && resetsAt < 8.64e15 ? resetsAt : null);
+            const validReset = Number.isFinite(resetsAt) && resetsAt > this.now() && resetsAt < 8.64e15 ? resetsAt : null;
+            const reset = validReset ?? (info.resetsAt === undefined && namedWindow ? (this.refusedResets.get(window) ?? null) : null);
+            this.refusedWindows.set(window, reset);
+            if (namedWindow && reset !== null && reset > this.now()) {
+                this.refusedResets.set(window, reset);
+            }
+            else {
+                this.refusedResets.delete(window);
+            }
         }
         else if (info.status === 'allowed' || info.status === 'allowed_warning' || overageAllowed) {
             this.refusedWindows.delete(window);
+            this.refusedResets.delete(window);
+        }
+    }
+    expireRefusedResets() {
+        const now = this.now();
+        for (const [window, reset] of this.refusedResets) {
+            if (reset <= now) {
+                this.refusedResets.delete(window);
+            }
         }
     }
     /*
@@ -750,7 +779,7 @@ export class ClaudeProtocol {
         if (this.refusedWindows.size > 0) {
             let resetsAt = 0;
             for (const reset of this.refusedWindows.values()) {
-                if (reset === null) {
+                if (reset === null || reset <= this.now()) {
                     return { kind: 'usage' };
                 }
                 resetsAt = Math.max(resetsAt, reset);

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);

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.2",
+  "version": "0.27.4",
   "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.2",
-    "@adecore/intelligent-ui": "0.27.2",
+    "@adecore/agent-contracts": "0.27.4",
+    "@adecore/intelligent-ui": "0.27.4",
     "zod": "^4.6.5"
   },
   "devDependencies": {

package/src/chat/backend.ts

@@ -35,11 +35,16 @@ export interface BackendLaunch {
     // How often this chat started a CLI; a protocol that numbers its own requests from zero
     // needs it to keep the ids of one process apart from those of the one before.
     generation: number;
+    // Shares the host clock with expiry checks when a test advances time by hand.
+    now?(): number;
     // What the agent is told once, at the start of a process: a system prompt, or a new thread's developer instructions.
     instructions: string | null;
     // 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
@@ -179,6 +184,8 @@ export type BackendEvent =
           error?: string;
           native?: { turnId?: string; lastUuid?: string };
           limit?: ChatTurnLimit;
+          // The next prompt needs fresh process credentials, once native work and requests have settled.
+          replaceProcess?: boolean;
       }
     // The CLI could not be reached or refused the request; the turn ends and the chat needs a new one.
     | { type: 'failed'; message: string; processAlive?: boolean }

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.
@@ -169,6 +170,7 @@ export class ChatSession {
     private readonly options: ChatSessionOptions;
     private readonly projector: ThreadProjector;
     private backend: ChatBackend | null = null;
+    private replaceProcess = false;
     private starting: Promise<ChatBackend> | null = null;
     private pendingStart: { turnId: string; warning: unknown } | null = null;
     private sendAfterStop = false;
@@ -1804,7 +1806,8 @@ export class ChatSession {
     private requiresReplacement(): boolean {
         return (
             this.backend !== null &&
-            (JSON.stringify(this.info.selection) !== JSON.stringify(this.launchedSelection) ||
+            (this.replaceProcess ||
+                JSON.stringify(this.info.selection) !== JSON.stringify(this.launchedSelection) ||
                 this.info.runtimeMode !== this.launchedRuntimeMode ||
                 this.info.account !== this.launchedAccount ||
                 this.info.cwd !== this.launchedCwd ||
@@ -1873,9 +1876,11 @@ export class ChatSession {
             runtimeMode: info.runtimeMode,
             resume: info.agentSessionId,
             generation,
+            now: () => this.options.limitResume?.now() ?? (this.options.clock ?? systemClock).now(),
             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 }),
@@ -1895,6 +1900,7 @@ export class ChatSession {
         }
         const backend = made.backend;
         this.backend = backend;
+        this.replaceProcess = false;
         this.emit([this.thread.patchInfo({ running: true, effectiveRuntimeMode: undefined, permissionMode: undefined })]);
         let started: Promise<void>;
         try {
@@ -1978,6 +1984,9 @@ export class ChatSession {
             if (event.promptId !== undefined) {
                 this.staleResults = 0;
             }
+            if (event.replaceProcess === true) {
+                this.replaceProcess = true;
+            }
             const promptId = event.promptId ?? this.submission?.input.promptId;
             if (promptId !== undefined) {
                 this.acceptPrompt(promptId);

package/src/chat/claude-backend.ts

@@ -41,7 +41,7 @@ export class ClaudeBackend implements ChatBackend {
         this.launch = launch;
         this.host = host;
         this.allowedTools = options.allowedTools ?? [];
-        this.protocol = new ClaudeProtocol(launch.goal ?? null);
+        this.protocol = new ClaudeProtocol(launch.goal ?? null, launch.now);
     }
 
     get running(): boolean {

package/src/chat/claude-protocol.ts

@@ -187,6 +187,7 @@ export function claudeGoalCheck(text: string, current: ChatGoal | null): ChatGoa
  * belongs to one process, so a resumed CLI that numbers its messages from the start gets its own.
  */
 export class ClaudeProtocol {
+    private readonly now: () => number;
     private promptId: string | null = null;
     private readonly pending = new Map<string, Pending>();
     private streamMessageId: string | null = null;
@@ -208,6 +209,8 @@ export class ClaudeProtocol {
     // Only main-chain errors classify the turn; each plan window can refuse it independently.
     private apiError: string | null = null;
     private readonly refusedWindows = new Map<string, number | null>();
+    // Sparse refusals can omit a reset; cached metadata alone must never classify a later 429.
+    private readonly refusedResets = new Map<string, number>();
 
     // The task each `stop_task` request named, so an error answer finds it again.
     private readonly stopRequests = new Map<string, string>();
@@ -221,8 +224,9 @@ export class ClaudeProtocol {
     // Background subagents still at work; Claude Code holds a goal's check until they report.
     private readonly backgroundAgents = new Set<string>();
 
-    constructor(goal: ChatGoal | null = null) {
+    constructor(goal: ChatGoal | null = null, now: () => number = () => Date.now()) {
         this.goal = goal;
+        this.now = now;
     }
 
     /* A stop is on its way; the turn it ends leaves the goal set but nobody working on it. */
@@ -245,6 +249,7 @@ export class ClaudeProtocol {
         this.promptId = promptId;
         this.apiError = null;
         this.refusedWindows.clear();
+        this.expireRefusedResets();
         this.lastUuid = null;
     }
 
@@ -765,6 +770,10 @@ export class ClaudeProtocol {
         const lastUuid = this.lastUuid;
         this.lastUuid = null;
         const limit = failed ? this.limit() : null;
+        const replaceProcess = failed && this.apiError === 'authentication_failed';
+        if (limit?.kind !== 'usage') {
+            this.refusedResets.clear();
+        }
         this.apiError = null;
         this.refusedWindows.clear();
         // Before the turn ends, so whoever settles work on that end already reads where the goal stands.
@@ -776,7 +785,8 @@ export class ClaudeProtocol {
             costUsd: num(frame.total_cost_usd),
             ...(failed ? { error: errors[0] ?? str(frame.result) ?? `The turn ended with ${str(frame.subtype) ?? 'an error'}` } : {}),
             ...(lastUuid === null ? {} : { native: { lastUuid } }),
-            ...(limit === null ? {} : { limit })
+            ...(limit === null ? {} : { limit }),
+            ...(replaceProcess ? { replaceProcess: true } : {})
         });
     }
 
@@ -784,14 +794,33 @@ export class ClaudeProtocol {
         if (!isRecord(info) || typeof info.status !== 'string') {
             return;
         }
-        const window = str(info.rateLimitType) ?? 'unknown';
+        this.expireRefusedResets();
+        const namedWindow = str(info.rateLimitType);
+        const window = namedWindow ?? 'unknown';
         const overageAllowed =
             info.overageStatus === 'allowed' || info.overageStatus === 'allowed_warning' || info.isUsingOverage === true || info.overageInUse === true;
         if (info.status === 'rejected' && !overageAllowed) {
             const resetsAt = typeof info.resetsAt === 'number' ? info.resetsAt * 1000 : NaN;
-            this.refusedWindows.set(window, Number.isFinite(resetsAt) && resetsAt > 0 && resetsAt < 8.64e15 ? resetsAt : null);
+            const validReset = Number.isFinite(resetsAt) && resetsAt > this.now() && resetsAt < 8.64e15 ? resetsAt : null;
+            const reset = validReset ?? (info.resetsAt === undefined && namedWindow ? (this.refusedResets.get(window) ?? null) : null);
+            this.refusedWindows.set(window, reset);
+            if (namedWindow && reset !== null && reset > this.now()) {
+                this.refusedResets.set(window, reset);
+            } else {
+                this.refusedResets.delete(window);
+            }
         } else if (info.status === 'allowed' || info.status === 'allowed_warning' || overageAllowed) {
             this.refusedWindows.delete(window);
+            this.refusedResets.delete(window);
+        }
+    }
+
+    private expireRefusedResets(): void {
+        const now = this.now();
+        for (const [window, reset] of this.refusedResets) {
+            if (reset <= now) {
+                this.refusedResets.delete(window);
+            }
         }
     }
 
@@ -804,7 +833,7 @@ export class ClaudeProtocol {
         if (this.refusedWindows.size > 0) {
             let resetsAt = 0;
             for (const reset of this.refusedWindows.values()) {
-                if (reset === null) {
+                if (reset === null || reset <= this.now()) {
                     return { kind: 'usage' };
                 }
                 resetsAt = Math.max(resetsAt, reset);

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);

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) ?? [];