@myagentroam/agent 0.9.82 → 0.9.84

package/dist/model/contracts.d.ts

@@ -1,4 +1,13 @@
 import type { MarAgentModelConfiguration, MarAgentReasoningEffort, ModelCredentialAcquireReason } from './configuration.js';
+export interface ModelContinuationCheckpoint {
+    readonly version: 1;
+    readonly protocol: 'OPENAI_RESPONSES';
+    readonly configurationHash: string;
+    readonly responseId: string;
+    readonly requestPropertiesHash: string;
+    readonly inputPrefixLength: number;
+    readonly inputPrefixHash: string;
+}
 export interface ClientToolDefinition {
     name: string;
     description: string;
@@ -11,7 +20,7 @@ export interface ClientToolDefinition {
 export interface ModelMessage {
     role: 'user' | 'assistant' | 'tool' | 'tool_call' | 'provider';
     content: string;
-    contextKind?: 'environment';
+    contextKind?: 'environment' | 'private';
     callId?: string;
     name?: string;
     arguments?: unknown;
@@ -146,11 +155,18 @@ export interface ModelAdapter {
     readonly configuration: MarAgentModelConfiguration;
     start(request: ModelRequest, signal: AbortSignal): AsyncIterable<ModelEvent>;
     createTurnSession?(): ModelTurnSession;
+    /**
+     * Prepares an equivalent model rebind without mutating live state.
+     * The returned commit callback must be synchronous and non-throwing.
+     */
+    prepareReconfigure?(configuration: MarAgentModelConfiguration): (() => void) | undefined;
+    restoreContinuation?(checkpoint: ModelContinuationCheckpoint): boolean;
     close?(): Promise<void>;
 }
 export interface ModelTurnSession {
     start(request: ModelRequest, signal: AbortSignal): AsyncIterable<ModelEvent>;
     /** Drops incremental response state after a local context replacement. */
     resetContinuation?(): void;
+    continuationCheckpoint?(): ModelContinuationCheckpoint | undefined;
     close(): Promise<void>;
 }

package/dist/model/openai-responses.d.ts

@@ -1,7 +1,7 @@
 import { MarAgentError } from '../error.js';
 import { type MarAgentModelConfiguration, type ModelCredentialAcquireReason } from './configuration.js';
 import WebSocket from 'ws';
-import type { ModelAdapter, ModelAttemptDiagnostic, ModelEvent, ModelRequest, ModelTurnSession } from './contracts.js';
+import type { ModelAdapter, ModelAttemptDiagnostic, ModelContinuationCheckpoint, ModelEvent, ModelRequest, ModelTurnSession } from './contracts.js';
 export declare const OPENAI_RESPONSES_EARLY_EOF_REASON = "OPENAI_RESPONSES_EARLY_EOF";
 export declare const OPENAI_RESPONSES_WEBSOCKET_CONNECTION_LIMIT_REASON = "OPENAI_RESPONSES_WEBSOCKET_CONNECTION_LIMIT";
 type ResponsesRequestBody = Readonly<Record<string, unknown>> & {
@@ -11,6 +11,7 @@ interface ResponsesSessionState {
     socket?: WebSocket;
     endpoint?: string;
     credentialRevision?: number;
+    credentialFingerprint?: string;
     connectionId?: string;
     proxyType?: 'DIRECT' | 'SOCKS5';
     lastRequest?: ResponsesRequestBody;
@@ -18,18 +19,20 @@ interface ResponsesSessionState {
         readonly responseId: string;
         readonly outputItems: readonly Record<string, unknown>[];
     };
+    restoredContinuation?: ModelContinuationCheckpoint;
 }
 interface PreparedResponsesRequest {
     readonly fullBody: ResponsesRequestBody;
     readonly body: ResponsesRequestBody;
     readonly continuation: boolean;
-    readonly requiresExistingSocket: boolean;
 }
 export declare class OpenAiResponsesAdapter implements ModelAdapter {
     #private;
-    readonly configuration: MarAgentModelConfiguration;
     readonly prefixIdentity: `${string}-${string}-${string}-${string}-${string}`;
     constructor(configuration: MarAgentModelConfiguration);
+    get configuration(): MarAgentModelConfiguration;
+    prepareReconfigure(configuration: MarAgentModelConfiguration): (() => void) | undefined;
+    restoreContinuation(checkpoint: ModelContinuationCheckpoint): boolean;
     start(request: ModelRequest, signal: AbortSignal): AsyncIterable<ModelEvent>;
     createTurnSession(): ModelTurnSession;
     close(): Promise<void>;
@@ -47,6 +50,7 @@ declare class OpenAiResponsesTurnSession implements ModelTurnSession {
     start(request: ModelRequest, signal: AbortSignal): AsyncIterable<ModelEvent>;
     close(): Promise<void>;
     resetContinuation(): void;
+    continuationCheckpoint(): ModelContinuationCheckpoint | undefined;
     prepareRequest(request: ModelRequest): PreparedResponsesRequest;
     fullRequestBody(): ResponsesRequestBody;
     currentTurnState(): string | undefined;
@@ -61,7 +65,6 @@ declare class OpenAiResponsesTurnSession implements ModelTurnSession {
         readonly reason: ModelCredentialAcquireReason;
         readonly signal: AbortSignal;
         readonly continuation: boolean;
-        readonly requiresExistingSocket: boolean;
         readonly credentialAcquired: (revision: number) => void;
     }): Promise<WebSocket>;
     private connectWebSocket;

package/dist/model/openai-responses.js

@@ -13,13 +13,33 @@ const X_CODEX_TURN_STATE = 'x-codex-turn-state';
 const RESPONSES_LITE_HEADER = 'x-openai-internal-codex-responses-lite';
 const RESPONSES_LITE_METADATA = 'ws_request_header_x_openai_internal_codex_responses_lite';
 export class OpenAiResponsesAdapter {
-    configuration;
     prefixIdentity = randomUUID();
     #cachedState = {};
     #cacheLeased = false;
     #closed = false;
+    #configuration;
     constructor(configuration) {
-        this.configuration = configuration;
+        this.#configuration = configuration;
+    }
+    get configuration() {
+        return this.#configuration;
+    }
+    prepareReconfigure(configuration) {
+        if (!sameResponsesAdapterConfiguration(this.#configuration, configuration))
+            return undefined;
+        return () => {
+            this.#configuration = configuration;
+        };
+    }
+    restoreContinuation(checkpoint) {
+        if (this.#cacheLeased ||
+            this.#cachedState.lastRequest !== undefined ||
+            this.#cachedState.lastResponse !== undefined ||
+            checkpoint.protocol !== 'OPENAI_RESPONSES' ||
+            checkpoint.configurationHash !== responsesConfigurationHash(this.#configuration))
+            return false;
+        this.#cachedState.restoredContinuation = checkpoint;
+        return true;
     }
     async *start(request, signal) {
         const turn = new OpenAiResponsesTurnSession(this, {}, false, true);
@@ -53,14 +73,13 @@ export class OpenAiResponsesAdapter {
             return;
         }
         if (state.socket !== undefined && state.socket.readyState !== WebSocket.OPEN)
-            invalidateResponsesWebSocket(state, true);
+            invalidateResponsesWebSocket(state, false);
         this.#cachedState = state;
         this.#cacheLeased = false;
     }
     async *startTurn(request, signal, turn, prepared) {
         let useContinuation = prepared.continuation;
         let requestBody = prepared.body;
-        let requiresExistingSocket = prepared.requiresExistingSocket;
         let credentialReason = 'REQUEST';
         let unauthorizedRetryUsed = false;
         let invalidContinuationFallbackUsed = false;
@@ -87,7 +106,7 @@ export class OpenAiResponsesAdapter {
                 credentialReason: attemptCredentialReason
             });
             try {
-                for await (const event of this.startAttempt(request, signal, requestBody, useContinuation, credentialReason, requiresExistingSocket, turn)) {
+                for await (const event of this.startAttempt(request, signal, requestBody, useContinuation, credentialReason, turn)) {
                     if (!sawSemanticEvent && !isSemanticEvent(event)) {
                         prelude.push(event);
                         continue;
@@ -143,7 +162,6 @@ export class OpenAiResponsesAdapter {
                     invalidContinuationFallbackUsed = true;
                     useContinuation = false;
                     requestBody = prepared.fullBody;
-                    requiresExistingSocket = false;
                     turn.invalidateWebSocket();
                     credentialReason = 'RECONNECT';
                     await reportFailure(true, {
@@ -192,14 +210,13 @@ export class OpenAiResponsesAdapter {
                         : 'REQUEST';
                 useContinuation = false;
                 requestBody = prepared.fullBody;
-                requiresExistingSocket = false;
                 if (error instanceof MarAgentError && error.details?.transport === 'WEBSOCKET')
                     turn.invalidateWebSocket();
                 await waitForModelRetry(retryAfter(error), attempt, signal, delayMs);
             }
         }
     }
-    async *startAttempt(request, signal, body, continuation, credentialReason, requiresExistingSocket, turn) {
+    async *startAttempt(request, signal, body, continuation, credentialReason, turn) {
         let latestCredentialRevision;
         const fetchResponse = async (requestBody) => {
             const serializedBody = JSON.stringify(requestBody);
@@ -233,7 +250,6 @@ export class OpenAiResponsesAdapter {
                     reason: credentialReason,
                     signal,
                     continuation,
-                    requiresExistingSocket,
                     turn,
                     credentialAcquired: (revision) => (latestCredentialRevision = revision)
                 });
@@ -517,6 +533,15 @@ export class OpenAiResponsesAdapter {
             });
     }
 }
+function sameResponsesAdapterConfiguration(current, next) {
+    const { apiKey: currentApiKey, credentialProvider: currentCredentialProvider, imageGeneration: _currentImageGeneration, ...currentTransport } = current;
+    const { apiKey: nextApiKey, credentialProvider: nextCredentialProvider, imageGeneration: _nextImageGeneration, ...nextTransport } = next;
+    const credentialsAreRebindable = (currentCredentialProvider !== undefined && nextCredentialProvider !== undefined) ||
+        (currentApiKey !== undefined &&
+            nextApiKey !== undefined &&
+            currentApiKey.reveal() === nextApiKey.reveal());
+    return credentialsAreRebindable && isDeepStrictEqual(currentTransport, nextTransport);
+}
 class OpenAiResponsesTurnSession {
     adapter;
     state;
@@ -561,7 +586,7 @@ class OpenAiResponsesTurnSession {
                 for await (const event of this.adapter.startTurn({
                     ...request,
                     onAttemptDiagnostic: async (diagnostic) => request.onAttemptDiagnostic?.({ ...diagnostic, prewarm: true })
-                }, signal, this, { fullBody: warmBody, body: warmBody, continuation: false, requiresExistingSocket: false })) {
+                }, signal, this, { fullBody: warmBody, body: warmBody, continuation: false })) {
                     if (event.type === 'response.started' && event.responseId !== 'unknown')
                         warmId = event.responseId;
                     if (event.type === 'completed')
@@ -607,6 +632,7 @@ class OpenAiResponsesTurnSession {
                 (outputItems.length > 0 || !sawUnrepresentedOutput)) {
                 this.state.lastRequest = prepared.fullBody;
                 this.state.lastResponse = { responseId, outputItems };
+                delete this.state.restoredContinuation;
             }
             else
                 clearResponsesContinuation(this.state);
@@ -629,17 +655,31 @@ class OpenAiResponsesTurnSession {
     resetContinuation() {
         clearResponsesContinuation(this.state);
     }
+    continuationCheckpoint() {
+        const request = this.state.lastRequest;
+        const response = this.state.lastResponse;
+        if (request === undefined || response === undefined)
+            return this.state.restoredContinuation;
+        const baseline = [...request.input, ...response.outputItems];
+        return {
+            version: 1,
+            protocol: 'OPENAI_RESPONSES',
+            configurationHash: responsesConfigurationHash(this.adapter.configuration),
+            responseId: response.responseId,
+            requestPropertiesHash: responsesRequestPropertiesHash(request),
+            inputPrefixLength: baseline.length,
+            inputPrefixHash: hashResponsesValue(baseline)
+        };
+    }
     prepareRequest(request) {
         if (this.adapter.configuration.responsesTransport?.transport === 'WEBSOCKET' &&
             this.state.socket !== undefined &&
             this.state.socket.readyState !== WebSocket.OPEN)
-            invalidateResponsesWebSocket(this.state, true);
+            invalidateResponsesWebSocket(this.state, false);
         const fullBody = responsesRequestBody(this.adapter.configuration, request, request.messages, this.adapter.prefixIdentity);
         if (this.adapter.configuration.responsesPreviousResponseId) {
             const incremental = incrementalResponsesInput(this.state, fullBody);
-            if (incremental !== undefined &&
-                (this.adapter.configuration.responsesTransport?.transport !== 'WEBSOCKET' ||
-                    this.state.socket?.readyState === WebSocket.OPEN)) {
+            if (incremental !== undefined) {
                 const responseId = this.state.lastResponse.responseId;
                 delete this.state.lastResponse;
                 return {
@@ -649,8 +689,7 @@ class OpenAiResponsesTurnSession {
                         input: incremental,
                         previous_response_id: responseId
                     },
-                    continuation: true,
-                    requiresExistingSocket: this.adapter.configuration.responsesTransport?.transport === 'WEBSOCKET'
+                    continuation: true
                 };
             }
             if (this.allowExternalContinuation &&
@@ -664,16 +703,14 @@ class OpenAiResponsesTurnSession {
                         input: deltaBody.input,
                         previous_response_id: request.continuation.previousResponseId
                     },
-                    continuation: true,
-                    requiresExistingSocket: false
+                    continuation: true
                 };
             }
         }
         return {
             fullBody,
             body: fullBody,
-            continuation: false,
-            requiresExistingSocket: false
+            continuation: false
         };
     }
     fullRequestBody() {
@@ -714,14 +751,9 @@ class OpenAiResponsesTurnSession {
     async webSocketForRequest(input) {
         const endpoint = webSocketEndpoint(input.configuration.baseUrl);
         const existingSocket = this.state.socket;
-        if (input.requiresExistingSocket &&
-            (existingSocket?.readyState !== WebSocket.OPEN || this.state.endpoint !== endpoint)) {
-            invalidateResponsesWebSocket(this.state, true);
-            throw unavailableContinuationConnection();
-        }
         if (existingSocket !== undefined &&
             (existingSocket.readyState !== WebSocket.OPEN || this.state.endpoint !== endpoint))
-            invalidateResponsesWebSocket(this.state, true);
+            invalidateResponsesWebSocket(this.state, false);
         if (this.state.socket === undefined) {
             const handshakeCredential = await acquireResponsesCredential(input.configuration, input.reason);
             input.credentialAcquired(handshakeCredential.revision);
@@ -729,10 +761,9 @@ class OpenAiResponsesTurnSession {
         }
         const requestCredential = await acquireResponsesCredential(input.configuration, input.reason);
         input.credentialAcquired(requestCredential.revision);
-        if (requestCredential.revision !== this.state.credentialRevision) {
-            invalidateResponsesWebSocket(this.state, true);
-            if (input.continuation)
-                throw unavailableContinuationConnection();
+        if (requestCredential.revision !== this.state.credentialRevision ||
+            responsesCredentialFingerprint(requestCredential) !== this.state.credentialFingerprint) {
+            invalidateResponsesWebSocket(this.state, false);
             await this.connectWebSocket(endpoint, requestCredential, input.promptCacheKey, input.signal);
         }
         if (input.signal.aborted) {
@@ -787,6 +818,7 @@ class OpenAiResponsesTurnSession {
         this.state.socket = socket;
         this.state.endpoint = endpoint;
         this.state.credentialRevision = credential.revision;
+        this.state.credentialFingerprint = responsesCredentialFingerprint(credential);
         this.state.connectionId = connectionId;
         this.state.proxyType = proxyType;
     }
@@ -864,9 +896,18 @@ function uuidV5(namespace, value) {
 function incrementalResponsesInput(state, current) {
     const previous = state.lastRequest;
     const completion = state.lastResponse;
-    if (previous === undefined ||
-        completion === undefined ||
-        !responsesRequestPropertiesMatch(previous, current))
+    if (previous === undefined || completion === undefined) {
+        const restored = state.restoredContinuation;
+        if (restored === undefined ||
+            restored.requestPropertiesHash !== responsesRequestPropertiesHash(current) ||
+            current.input.length < restored.inputPrefixLength ||
+            restored.inputPrefixHash !==
+                hashResponsesValue(current.input.slice(0, restored.inputPrefixLength)))
+            return undefined;
+        state.lastResponse = { responseId: restored.responseId, outputItems: [] };
+        return current.input.slice(restored.inputPrefixLength);
+    }
+    if (!responsesRequestPropertiesMatch(previous, current))
         return undefined;
     const baseline = [...previous.input, ...completion.outputItems];
     if (current.input.length < baseline.length)
@@ -877,31 +918,53 @@ function incrementalResponsesInput(state, current) {
     return current.input.slice(baseline.length);
 }
 function responsesRequestPropertiesMatch(previous, current) {
-    const keys = [
-        'model',
-        'instructions',
-        'tools',
-        'tool_choice',
-        'parallel_tool_calls',
-        'reasoning',
-        'store',
-        'stream',
-        'include',
-        'prompt_cache_key',
-        'text',
-        'client_metadata'
-    ];
-    return keys.every((key) => isDeepStrictEqual(previous[key], current[key]));
+    return RESPONSES_REQUEST_PROPERTY_KEYS.every((key) => isDeepStrictEqual(previous[key], current[key]));
 }
 function clearResponsesContinuation(state) {
     delete state.lastRequest;
     delete state.lastResponse;
+    delete state.restoredContinuation;
+}
+const RESPONSES_REQUEST_PROPERTY_KEYS = [
+    'model',
+    'instructions',
+    'tools',
+    'tool_choice',
+    'parallel_tool_calls',
+    'reasoning',
+    'store',
+    'stream',
+    'include',
+    'prompt_cache_key',
+    'text',
+    'client_metadata'
+];
+function responsesRequestPropertiesHash(request) {
+    return hashResponsesValue(Object.fromEntries(RESPONSES_REQUEST_PROPERTY_KEYS.map((key) => [key, request[key]])));
+}
+function hashResponsesValue(value) {
+    return createHash('sha256').update(JSON.stringify(value)).digest('hex');
+}
+function responsesConfigurationHash(configuration) {
+    const { apiKey: _apiKey, credentialProvider: _credentialProvider, imageGeneration: _imageGeneration, ...identity } = configuration;
+    return hashResponsesValue(identity);
+}
+function responsesCredentialFingerprint(credential) {
+    return hashResponsesValue({
+        bearer: credential.bearer.reveal(),
+        headers: Object.fromEntries(Object.entries(credential.headers).map(([name, value]) => [
+            name,
+            typeof value === 'string' ? value : value.reveal()
+        ])),
+        socks5Url: credential.socks5Url?.reveal()
+    });
 }
 function invalidateResponsesWebSocket(state, clearContinuation) {
     const socket = state.socket;
     delete state.socket;
     delete state.endpoint;
     delete state.credentialRevision;
+    delete state.credentialFingerprint;
     delete state.connectionId;
     delete state.proxyType;
     if (clearContinuation)
@@ -911,16 +974,6 @@ function invalidateResponsesWebSocket(state, clearContinuation) {
         socket.readyState !== WebSocket.CLOSING)
         terminateWebSocket(socket);
 }
-function unavailableContinuationConnection() {
-    return new MarAgentError('previous_response_not_found', 'The previous response is unavailable on the current WebSocket connection.', {
-        details: {
-            reason: 'OPENAI_RESPONSES_CONTINUATION_CONNECTION_UNAVAILABLE',
-            transport: 'WEBSOCKET',
-            continuation: true
-        },
-        retryable: true
-    });
-}
 function turnStateFromEvent(event) {
     for (const headers of [
         record(event.headers),
@@ -958,7 +1011,6 @@ async function* webSocketResponseEvents(input) {
         reason: input.reason,
         signal: input.signal,
         continuation: input.continuation,
-        requiresExistingSocket: input.requiresExistingSocket,
         credentialAcquired: input.credentialAcquired
     });
     const body = input.turn.withTurnStateMetadata(input.body);

package/dist/prompts/compact.js

@@ -9,7 +9,7 @@ Preserve, when present:
 - confirmed decisions, constraints, interfaces, invariants, assumptions that still matter, and exact identifiers;
 - completed actions and edits with exact file paths, symbols, commands, migrations, or external state changes;
 - verification actually run and its result, important tool evidence, reproducible errors, failed approaches and what they proved;
-- unresolved questions, blockers, risks, uncommitted changes, Todo/plan state, pending approvals, and live/background process or subagent state;
+- unresolved questions, blockers, risks, uncommitted changes, Todo/plan state, and pending approvals;
 - the next concrete action and the evidence still required before completion.
 
 Distinguish clearly between completed, attempted, planned, inferred, and unverified work. Newer user instructions override older ones; retain superseded instructions only when needed to explain current state. Never invent completion, test results, file contents, permissions, or external effects.
@@ -17,6 +17,7 @@ Distinguish clearly between completed, attempted, planned, inferred, and unverif
 Remove aggressively:
 - greetings, acknowledgements, progress chatter, repeated instructions, repeated status, and conclusions already represented once;
 - user-level, project-level, or directory-level AGENTS.md instructions and constraints derived only from those files, because the next Execution reloads and replaces them separately;
+- retained process/Subagent inventory, IDs, status, commands, cwd, and reuse instructions, because Runtime reloads and replaces that state separately;
 - raw long logs, large source excerpts, verbose tool payloads, duplicated search/read output, and implementation detail recoverable from named files or commands;
 - abandoned hypotheses and failed attempts that do not constrain the next action;
 - hidden reasoning, secrets, credentials, authorization values, and unrelated conversation.
@@ -52,7 +53,7 @@ branch changed -> inherited_evidence=unverified
 - direct user/caller authorization、prohibition、exclusion 保留 exact action/scope，不概括成更宽泛边界。
 
 2. 当前状态 / Current state
-- 对象：file、symbol、feature、migration、test、worktree、process、subagent、selected Skill、Todo/plan、approval、external side effect。
+- 对象：file、symbol、feature、migration、test、worktree、selected Skill、Todo/plan、approval、external side effect。retained process/subagent inventory 由 Runtime 重建，不进入 IR。
 - 分离 completion（pending / in_progress / completed / blocked）、epistemic（observed / verified / inferred / proposed / disproved）、freshness（current / stale / superseded）、scope（turn / worktree / base / branch / external system）；仅在消歧时标注。
 - 明确 completed、not started、unverified、active。相同精度下选择更短状态原子；中文、English 均可，如 根因已证、edit=pending、tests=not run。
 - selected Skill | 保留仍适用的 skill name + 续作必需约束；Todo/plan | 保留 revision、item/status、当前最小 step。
@@ -70,7 +71,7 @@ branch changed -> inherited_evidence=unverified
 - 下一 Agent 无法使用、仅供 local storage validation 的 integrity hash：删除。
 
 5. 未闭环 / Open loops
-- unresolved、unverified、blocker、pending approval、活动 process/subagent、Todo/plan current step、仍需 evidence。
+- unresolved、unverified、blocker、pending approval、Todo/plan current step、仍需 evidence。
 - 只保留已确定的最小 next action + preconditions；不复制可重算的长 plan。
 
 编译规则：
@@ -85,7 +86,7 @@ observed HEAD、validated base、target commit、current worktree 不得折叠
 
 语言：标题/一般叙述跟随 latest active user instructions 和当前任务主语言；每条 record 按局部精度与密度选择中文、English 或 mixed phrasing。保留 established term/exact identifier，不为语言统一展开或翻译。English codebase 不等于 English handoff。
 
-删除 greetings、progress chatter、过程叙事、重复事实、无剩余约束的 superseded hypothesis、长日志、source body、verbose payload、可从精确 path/command 廉价恢复的正文。删除 user/project/directory AGENTS.md 正文及仅由这些文件派生的 constraint，包括其中 exclusions；下一 Execution 会重新加载并整体替换。不得保留 hidden reasoning、secret、credential、无关内容。
+删除 greetings、progress chatter、过程叙事、重复事实、无剩余约束的 superseded hypothesis、长日志、source body、verbose payload、可从精确 path/command 廉价恢复的正文。删除 user/project/directory AGENTS.md 正文及仅由这些文件派生的 constraint，包括其中 exclusions；下一 Execution 会重新加载并整体替换。删除 retained process/Subagent inventory、ID、status、command、cwd 和 reuse instruction；Runtime 会重新加载并替换。不得保留 hidden reasoning、secret、credential、无关内容。
 
 只输出 compact Markdown IR。`;
 }

package/dist/prompts/index.d.ts

@@ -1,8 +1,7 @@
 import type { ExecutionMode } from '../sdk/types.js';
 import { type ExecutionBudgetPromptState } from './execution-budget.js';
-import { type RetainedSessionResources } from './resources.js';
 import { type CurrentAgentModel, type SubagentModelOption } from './subagent.js';
-export declare const MAR_AGENT_PROMPT_VERSION = "1.49";
+export declare const MAR_AGENT_PROMPT_VERSION = "1.50";
 export declare function buildSystemPrompt(input: {
     mode: ExecutionMode;
     platform: string;
@@ -16,7 +15,6 @@ export declare function buildSystemPrompt(input: {
     tools: readonly string[];
     currentAgentModel?: CurrentAgentModel;
     subagentModels?: readonly SubagentModelOption[];
-    retainedSessionResources?: RetainedSessionResources;
     executionBudget?: ExecutionBudgetPromptState;
     highDensityCompaction?: boolean;
     extension?: string | undefined;

package/dist/prompts/index.js

@@ -3,10 +3,9 @@ import { environmentPrompt, identityPrompt, instructionPriorityPrompt, workspace
 import { executionBudgetPrompt } from './execution-budget.js';
 import { modePrompt } from './modes.js';
 import { outputStylePrompt } from './output.js';
-import { retainedSessionResourcesPrompt } from './resources.js';
 import { subagentModelOptionsPrompt, subagentPrompt, currentAgentModelPrompt } from './subagent.js';
 import { interactionPrompt, longRunningPrompt, safetyPrompt, toolUsagePrompt, workflowPrompt } from './workflow.js';
-export const MAR_AGENT_PROMPT_VERSION = '1.49';
+export const MAR_AGENT_PROMPT_VERSION = '1.50';
 export function buildSystemPrompt(input) {
     const toolNames = new Set(input.tools);
     const hasLongRunningCapability = [
@@ -28,9 +27,6 @@ export function buildSystemPrompt(input) {
         environmentPrompt(input),
         input.tools.length > 0 ? toolUsagePrompt(input.tools) : '',
         hasLongRunningCapability ? longRunningPrompt(input.tools) : '',
-        input.retainedSessionResources
-            ? retainedSessionResourcesPrompt(input.retainedSessionResources)
-            : '',
         input.executionBudget ? executionBudgetPrompt(input.executionBudget) : '',
         modePrompt(input.mode, {
             questionAvailable: toolNames.has('question'),

package/dist/prompts/resources.d.ts

@@ -12,4 +12,5 @@ export interface RetainedSessionResources {
         description: string;
     }[];
 }
-export declare function retainedSessionResourcesPrompt(input: RetainedSessionResources): string;
+export declare function retainedSessionResourcesSnapshot(input: RetainedSessionResources): string | undefined;
+export declare function retainedSessionResourcesUpdate(snapshot: string | undefined, previousSnapshot: string | undefined, previousMayContainResources?: boolean): string | undefined;

package/dist/prompts/resources.js

@@ -1,31 +1,42 @@
-export function retainedSessionResourcesPrompt(input) {
+export function retainedSessionResourcesSnapshot(input) {
     if (input.processes.length === 0 && input.subagents.length === 0)
-        return '';
+        return undefined;
+    const processes = [...input.processes].sort((left, right) => left.processId.localeCompare(right.processId));
+    const subagents = [...input.subagents].sort((left, right) => left.agentId.localeCompare(right.agentId));
     return [
         '# Retained Session resources',
         'These resources belong to this Session and survived the previous Execution. Reuse their stable IDs instead of starting duplicate processes or subagents.',
-        input.processes.length === 0
-            ? ''
-            : 'Cancelling a managed process releases that process resource.',
-        input.subagents.length === 0
+        processes.length === 0 ? '' : 'Cancelling a managed process releases that process resource.',
+        subagents.length === 0
             ? ''
             : 'agent_cancel stops only the current child turn and retains its Session for later messages or explicit deletion.',
         input.idleTtlMs === undefined
             ? ''
             : `When the Session becomes idle again, unclaimed resources are retained for up to ${input.idleTtlMs} ms.`,
-        input.processes.length === 0
+        processes.length === 0
             ? ''
             : [
                 'Managed processes:',
-                ...input.processes.map((process) => `- processId: ${process.processId}; status: ${process.status}; cwd: ${process.cwd}; command: ${process.command}`)
+                ...processes.map((process) => `- processId: ${process.processId}; status: ${process.status}; cwd: ${process.cwd}; command: ${process.command}`)
             ].join('\n'),
-        input.subagents.length === 0
+        subagents.length === 0
             ? ''
             : [
                 'Subagents:',
-                ...input.subagents.map((task) => `- agentId: ${task.agentId}; status: ${task.status}; description: ${task.description}`)
+                ...subagents.map((task) => `- agentId: ${task.agentId}; status: ${task.status}; description: ${task.description}`)
             ].join('\n')
     ]
         .filter(Boolean)
         .join('\n');
 }
+export function retainedSessionResourcesUpdate(snapshot, previousSnapshot, previousMayContainResources = false) {
+    if (!previousMayContainResources && snapshot === previousSnapshot)
+        return undefined;
+    if (!snapshot)
+        return previousSnapshot || previousMayContainResources
+            ? 'The previously provided retained Session resources no longer apply. No retained processes or subagents remain.'
+            : undefined;
+    return previousSnapshot || previousMayContainResources
+        ? `This replaces all previously provided retained Session resources.\n\n${snapshot}`
+        : snapshot;
+}

package/dist/runtime/compact.js

@@ -95,7 +95,9 @@ export function buildNativeCompactionMessages(messages, input = {}) {
     const focus = input.focus?.trim();
     const contract = input.highDensityCompaction ? highDensityCompactionPrompt() : compactionPrompt();
     return [
-        ...messages.map((message) => {
+        ...messages
+            .filter((message) => message.contextKind !== 'private')
+            .map((message) => {
             if (!message.images?.length)
                 return message;
             const textOnly = { ...message };

package/dist/runtime/context-projection.js

@@ -139,6 +139,7 @@ export function restoreModelContext(payload, providerModelId) {
                 role: 'provider',
                 provider: 'ANTHROPIC_MESSAGES',
                 providerModelId: modelId,
+                contextKind: 'private',
                 content: '',
                 item
             }

package/dist/sdk/agent.js

@@ -18,6 +18,7 @@ import { DEFAULT_COMPACTION_FOCUS, CompactionOperation, buildCompactionInput, bu
 import { buildSystemPrompt, MAR_AGENT_PROMPT_VERSION } from '../prompts/index.js';
 import { buildEnvironmentContext } from '../prompts/core.js';
 import { modelOutputContinuationMessage } from '../prompts/output.js';
+import { retainedSessionResourcesSnapshot, retainedSessionResourcesUpdate } from '../prompts/resources.js';
 import { environmentContextUpdate, restoreEnvironmentState } from '../runtime/environment-context.js';
 import { childSubagentInstruction } from '../prompts/subagent.js';
 import { sessionTitlePrompt } from '../prompts/title.js';
@@ -54,6 +55,7 @@ export async function createMarAgent(options) {
         throw new MarAgentError('MAR_AGENT_HOST_INCOMPATIBLE', 'Host mode does not match Agent mode.');
     const store = await JsonlSessionStore.open(description.homeDirectory);
     const active = new Map();
+    const activeExecutionAdapters = new Set();
     const executionResults = new Map();
     const sessionRuntimes = new Map();
     let disposed = false;
@@ -249,22 +251,24 @@ export async function createMarAgent(options) {
                     const sessionState = await store.readExecutionState(sessionId);
                     const todo = TodoStore.restore(sessionState.todo);
                     const contextRecords = sessionState.contextRecords;
-                    const contextualInstructionGeneration = latestContextualInstructionGeneration(contextRecords);
-                    const restoredContextualInstructions = sessionRuntime.contextualInstructions;
-                    let contextualInstructions;
-                    if (restoredContextualInstructions === undefined ||
-                        restoredContextualInstructions.generation !== contextualInstructionGeneration) {
-                        contextualInstructions = {
-                            generation: contextualInstructionGeneration,
+                    const contextualWorldStateGeneration = latestContextualWorldStateGeneration(contextRecords);
+                    const restoredContextualWorldState = sessionRuntime.contextualWorldState;
+                    let contextualWorldState;
+                    if (restoredContextualWorldState === undefined ||
+                        restoredContextualWorldState.generation !== contextualWorldStateGeneration) {
+                        contextualWorldState = {
+                            generation: contextualWorldStateGeneration,
                             initialized: false,
-                            snapshot: undefined,
+                            instructionSnapshot: undefined,
+                            resourceSnapshot: undefined,
                             entries: []
                         };
-                        sessionRuntime.contextualInstructions = contextualInstructions;
+                        sessionRuntime.contextualWorldState = contextualWorldState;
                     }
                     else
-                        contextualInstructions = restoredContextualInstructions;
+                        contextualWorldState = restoredContextualWorldState;
                     const compactMayContainAgentInstructions = contextRecords.some((record) => compactSummaryFromCheckpoint(record) !== undefined);
+                    const compactMayContainRetainedResources = compactHistoryMayContainRetainedResources(contextRecords);
                     const restored = await restoreMessages(store, sessionId, contextRecords, {
                         includeImages: mode !== 'compact'
                     });
@@ -351,6 +355,7 @@ export async function createMarAgent(options) {
                             const titleModel = [...executionModels.values()].find((model) => model.titleGeneration) ??
                                 executionModels.get(input.modelId ?? executionDefaultModelId);
                             titleAdapter = createAdapter(titleModel.id, executionModels);
+                            activeExecutionAdapters.add(titleAdapter);
                             titleTask = generateSessionTitle(titleAdapter, input.prompt, titleModel.defaultReasoningEffort, controller.signal, recordModelAttempt('TITLE')).catch(() => undefined);
                         }
                     }
@@ -367,12 +372,17 @@ export async function createMarAgent(options) {
                             turnId
                         });
                     selectedAdapter = sessionAdapter(input.modelId ?? executionDefaultModelId, executionModels);
+                    const selectedModel = executionModels.get(input.modelId ?? executionDefaultModelId);
+                    const restoredContinuation = latestModelContinuationCheckpoint(contextRecords, selectedModel.id);
+                    if (restoredContinuation !== undefined)
+                        selectedAdapter.restoreContinuation?.(restoredContinuation);
                     if (options.adapterFactory !== undefined &&
-                        selectedAdapter.createTurnSession === undefined)
+                        selectedAdapter.createTurnSession === undefined) {
                         executionScopedAdapters.add(selectedAdapter);
+                        activeExecutionAdapters.add(selectedAdapter);
+                    }
                     const selected = createModelTurnSession(selectedAdapter);
                     selectedTurn = selected;
-                    const selectedModel = executionModels.get(input.modelId ?? executionDefaultModelId);
                     let lastServerUsage = latestModelUsage(contextRecords, selectedModel.id);
                     const compactUserTokenLimit = Math.min(20_000, Math.floor(selectedModel.contextWindowTokens / 8));
                     const reasoningEffort = input.reasoningEffort ?? selectedModel.defaultReasoningEffort;
@@ -462,29 +472,29 @@ export async function createMarAgent(options) {
                         agentInstructionInsertIndex &&
                         messages[agentInstructionInsertIndex - 1]?.contextKind === 'environment')
                         agentInstructionInsertIndex--;
-                    if (!contextualInstructions.initialized ||
-                        contextualInstructions.snapshot !== currentInstructionSnapshot) {
-                        const content = renderAgentInstructions(instructionEntries, compactMayContainAgentInstructions || contextualInstructions.entries.length > 0);
-                        if (content !== undefined)
-                            contextualInstructions.entries.push({
-                                index: agentInstructionInsertIndex,
-                                content
-                            });
-                        contextualInstructions.snapshot = currentInstructionSnapshot;
-                        contextualInstructions.initialized = true;
-                    }
                     const tools = withCodeModeResultTypes(availableTools.filter((tool) => tool.name !== 'skill' || (instructionContext?.skills.size ?? 0) > 0));
                     const executionTools = tools;
-                    const hostResources = (await options.host.listSessionResources?.(sessionId)) ?? {
-                        processes: []
-                    };
-                    const retainedSessionResources = {
-                        ...(hostResources.idleTtlMs === undefined
-                            ? {}
-                            : { idleTtlMs: hostResources.idleTtlMs }),
-                        processes: hostResources.processes,
-                        subagents: subagents?.listSessionResources() ?? []
+                    const loadRetainedSessionResources = async () => {
+                        const hostResources = (await options.host.listSessionResources?.(sessionId)) ?? {
+                            processes: []
+                        };
+                        return {
+                            ...(hostResources.idleTtlMs === undefined
+                                ? {}
+                                : { idleTtlMs: hostResources.idleTtlMs }),
+                            processes: hostResources.processes,
+                            subagents: subagents?.listSessionResources() ?? []
+                        };
                     };
+                    let currentResourceSnapshot = retainedSessionResourcesSnapshot(await loadRetainedSessionResources());
+                    contextualWorldState = updateContextualWorldState(contextualWorldState, agentInstructionInsertIndex, {
+                        instructionSnapshot: currentInstructionSnapshot,
+                        instructionContent: renderAgentInstructions(instructionEntries, compactMayContainAgentInstructions ||
+                            contextualWorldState.instructionSnapshot !== undefined),
+                        resourceSnapshot: currentResourceSnapshot,
+                        previousMayContainResources: compactMayContainRetainedResources
+                    });
+                    sessionRuntime.contextualWorldState = contextualWorldState;
                     const buildExecutionSystemPrompt = (availableTools = executionTools, promptMode = mode) => buildSystemPrompt({
                         mode: promptMode,
                         platform: description.platform,
@@ -512,7 +522,6 @@ export async function createMarAgent(options) {
                                 reasoningEfforts: configuration.reasoningEfforts
                             }))
                             : [],
-                        retainedSessionResources,
                         highDensityCompaction: selectedModel.highDensityCompaction,
                         ...(rolloutBudget?.active
                             ? {
@@ -537,7 +546,9 @@ export async function createMarAgent(options) {
                     if (mode === 'compact') {
                         const compactSystemPrompt = initialSystemPrompt;
                         const compactHistory = [...messages];
-                        const projectedHistory = normalizeMessagesForModel(insertContextualInstructions(compactHistory, contextualInstructions.entries), { supportsImages: false });
+                        const projectedHistory = normalizeMessagesForModel(insertContextualWorldState(compactHistory, contextualWorldState.entries, {
+                            excludeResources: true
+                        }), { supportsImages: false });
                         const nativeMessages = buildNativeCompactionMessages(projectedHistory, {
                             focus: input.prompt,
                             highDensityCompaction: selectedModel.highDensityCompaction
@@ -593,7 +604,9 @@ export async function createMarAgent(options) {
                         let compactSummary = '';
                         const compactSystemPrompt = buildExecutionSystemPrompt(executionTools, 'run');
                         const compactHistory = retainCurrent ? messages.slice(0, -1) : messages;
-                        const projectedHistory = normalizeMessagesForModel(insertContextualInstructions(compactHistory, contextualInstructions.entries), { supportsImages: false });
+                        const projectedHistory = normalizeMessagesForModel(insertContextualWorldState(compactHistory, contextualWorldState.entries, {
+                            excludeResources: true
+                        }), { supportsImages: false });
                         const nativeCompactMessages = buildNativeCompactionMessages(projectedHistory, {
                             highDensityCompaction: selectedModel.highDensityCompaction
                         });
@@ -686,8 +699,14 @@ export async function createMarAgent(options) {
                             .filter((message) => message.kind === 'user_input')
                             .map((message) => message.content);
                         agentInstructionInsertIndex = Math.max(0, messages.length - 1);
-                        contextualInstructions = resetContextualInstructions(compactRecord.recordId, currentInstructionSnapshot, agentInstructionInsertIndex, renderAgentInstructions(instructionEntries, true));
-                        sessionRuntime.contextualInstructions = contextualInstructions;
+                        currentResourceSnapshot = retainedSessionResourcesSnapshot(await loadRetainedSessionResources());
+                        contextualWorldState = resetContextualWorldState(compactRecord.recordId, agentInstructionInsertIndex, {
+                            instructionSnapshot: currentInstructionSnapshot,
+                            instructionContent: renderAgentInstructions(instructionEntries, true),
+                            resourceSnapshot: currentResourceSnapshot,
+                            previousMayContainResources: compactSummary.includes('# Retained Session resources')
+                        });
+                        sessionRuntime.contextualWorldState = contextualWorldState;
                         sessionRuntime.responsesChain = undefined;
                         lastServerContextTokens = undefined;
                         lastServerUsage = undefined;
@@ -726,7 +745,7 @@ export async function createMarAgent(options) {
                             .update(stableJson({
                             modelId: selectedModel.id,
                             systemPrompt,
-                            contextualInstructions: contextualInstructions.entries,
+                            contextualWorldState: contextualWorldState.entries,
                             tools: roundTools,
                             reasoningEffort
                         }))
@@ -745,7 +764,7 @@ export async function createMarAgent(options) {
                             : undefined;
                         const modelMessages = mode === 'compact'
                             ? normalizeMessagesForModel(requestContextMessages, { supportsImages: false })
-                            : normalizeMessagesForModel(insertContextualInstructions(requestContextMessages, contextualInstructions.entries), {
+                            : normalizeMessagesForModel(insertContextualWorldState(requestContextMessages, contextualWorldState.entries), {
                                 supportsImages: selectedModel.inputCapabilities.includes('IMAGE')
                             });
                         let sawModelSemanticEvent = false;
@@ -807,6 +826,9 @@ export async function createMarAgent(options) {
                                         content: '',
                                         provider: event.provider,
                                         providerModelId: selectedModel.id,
+                                        ...(event.provider === 'ANTHROPIC_MESSAGES'
+                                            ? { contextKind: 'private' }
+                                            : {}),
                                         item: event.item
                                     };
                                     messages.push(message);
@@ -979,6 +1001,17 @@ export async function createMarAgent(options) {
                             };
                         else if (selectedModel.responsesPreviousResponseId)
                             sessionRuntime.responsesChain = undefined;
+                        const continuationCheckpoint = selected.continuationCheckpoint?.();
+                        if (mode !== 'compact' && continuationCheckpoint !== undefined)
+                            await store.append(sessionId, {
+                                type: 'responses.continuation',
+                                payload: {
+                                    modelId: selectedModel.id,
+                                    checkpoint: continuationCheckpoint
+                                },
+                                executionId,
+                                turnId
+                            });
                         if (pendingTools.length === 0 && mailbox.length > 0) {
                             await appendMailboxMessages();
                             finalAnswer = '';
@@ -1167,8 +1200,14 @@ export async function createMarAgent(options) {
                                 if (agentInstructionInsertIndex &&
                                     messages[agentInstructionInsertIndex - 1]?.contextKind === 'environment')
                                     agentInstructionInsertIndex--;
-                                contextualInstructions = resetContextualInstructions(latestContextualInstructionGeneration(committed.records), currentInstructionSnapshot, agentInstructionInsertIndex, renderAgentInstructions(instructionEntries, committed.records.some((record) => compactSummaryFromCheckpoint(record) !== undefined)));
-                                sessionRuntime.contextualInstructions = contextualInstructions;
+                                currentResourceSnapshot = retainedSessionResourcesSnapshot(await loadRetainedSessionResources());
+                                contextualWorldState = resetContextualWorldState(latestContextualWorldStateGeneration(committed.records), agentInstructionInsertIndex, {
+                                    instructionSnapshot: currentInstructionSnapshot,
+                                    instructionContent: renderAgentInstructions(instructionEntries, committed.records.some((record) => compactSummaryFromCheckpoint(record) !== undefined)),
+                                    resourceSnapshot: currentResourceSnapshot,
+                                    previousMayContainResources: compactHistoryMayContainRetainedResources(committed.records)
+                                });
+                                sessionRuntime.contextualWorldState = contextualWorldState;
                             }
                         }
                         if (controller.signal.aborted) {
@@ -1252,7 +1291,16 @@ export async function createMarAgent(options) {
                     await selectedTurn?.close().catch(() => undefined);
                     if (titleAdapter !== undefined && titleAdapter !== selectedAdapter)
                         executionScopedAdapters.add(titleAdapter);
-                    await closeModelAdapters(executionScopedAdapters).catch(() => undefined);
+                    try {
+                        await closeModelAdapters(executionScopedAdapters);
+                    }
+                    catch {
+                        // Execution cleanup is best effort.
+                    }
+                    finally {
+                        for (const adapter of executionScopedAdapters)
+                            activeExecutionAdapters.delete(adapter);
+                    }
                     subagents?.endParentExecution(executionId);
                     await releaseSession?.();
                     active.delete(`${sessionId}:${executionId}`);
@@ -1328,30 +1376,60 @@ export async function createMarAgent(options) {
             const activeSessions = activeSessionIds();
             if ([...activeSessions].some((sessionId) => sessionRuntimes.get(sessionId)?.sourceType !== 'subagent'))
                 throw new MarAgentError('MAR_AGENT_EXECUTION_ACTIVE', 'Models cannot be reconfigured while a main execution is active.');
-            const activeAdapters = new Set();
+            const activeAdapters = new Set(activeExecutionAdapters);
             for (const [sessionId, runtime] of sessionRuntimes)
                 if (activeSessions.has(sessionId))
                     for (const adapter of runtime.adapters.values())
                         activeAdapters.add(adapter);
             const inactiveRuntimes = [...sessionRuntimes].flatMap(([sessionId, runtime]) => activeSessions.has(sessionId) ? [] : [runtime]);
-            const adapters = inactiveRuntimes
-                .flatMap((runtime) => [...runtime.adapters.values()])
-                .filter((adapter) => !activeAdapters.has(adapter));
             reconfiguring = true;
             try {
+                const reconfigurationCommits = new Map();
+                for (const runtime of inactiveRuntimes)
+                    for (const [modelId, adapter] of runtime.adapters) {
+                        if (activeAdapters.has(adapter))
+                            continue;
+                        const configuration = next.models.get(modelId);
+                        const commit = configuration === undefined ? undefined : adapter.prepareReconfigure?.(configuration);
+                        if (commit !== undefined)
+                            reconfigurationCommits.set(adapter, commit);
+                    }
+                const retainedAdapters = new Set(reconfigurationCommits.keys());
+                const adapters = [
+                    ...new Set(inactiveRuntimes.flatMap((runtime) => [...runtime.adapters.values()]))
+                ].filter((adapter) => !activeAdapters.has(adapter) && !retainedAdapters.has(adapter));
+                for (const runtime of inactiveRuntimes) {
+                    for (const [modelId, adapter] of runtime.adapters)
+                        if (!retainedAdapters.has(adapter))
+                            runtime.adapters.delete(modelId);
+                    if (runtime.responsesChain !== undefined &&
+                        !retainedAdapters.has(runtime.adapters.get(runtime.responsesChain.modelId)))
+                        runtime.responsesChain = undefined;
+                }
                 await closeModelAdapters(adapters);
                 if (disposed)
                     throw new MarAgentError('MAR_AGENT_DISPOSED', 'Agent is disposed.');
+                for (const commit of reconfigurationCommits.values())
+                    commit();
                 models = next.models;
                 defaultModelId = next.defaultModelId;
                 modelGeneration++;
                 for (const provider of next.credentialProviders)
                     credentialProviders.add(provider);
                 for (const runtime of inactiveRuntimes) {
-                    runtime.responsesChain = undefined;
-                    runtime.adapters.clear();
                     runtime.adapterGeneration = modelGeneration;
                 }
+                const liveProviders = new Set(next.credentialProviders);
+                for (const adapter of activeExecutionAdapters)
+                    addModelCredentialProviders(liveProviders, adapter.configuration);
+                for (const runtime of sessionRuntimes.values())
+                    for (const adapter of runtime.adapters.values())
+                        addModelCredentialProviders(liveProviders, adapter.configuration);
+                const obsoleteProviders = [...credentialProviders].filter((provider) => !liveProviders.has(provider));
+                const providerCloseResults = await Promise.allSettled(obsoleteProviders.map((provider) => provider.close()));
+                for (const [index, result] of providerCloseResults.entries())
+                    if (result.status === 'fulfilled')
+                        credentialProviders.delete(obsoleteProviders[index]);
             }
             finally {
                 reconfiguring = false;
@@ -1494,9 +1572,46 @@ function createModelTurnSession(adapter) {
             }
         },
         resetContinuation: () => turn.resetContinuation?.(),
+        continuationCheckpoint: () => turn.continuationCheckpoint?.(),
         close: () => turn.close()
     };
 }
+function latestModelContinuationCheckpoint(records, modelId) {
+    let checkpoint;
+    for (const record of records) {
+        if (record.type === 'compact.completed' || record.type === 'context.gc.completed') {
+            checkpoint = undefined;
+            continue;
+        }
+        if (record.type !== 'responses.continuation')
+            continue;
+        const payload = record.payload;
+        if (payload === null || typeof payload !== 'object' || Array.isArray(payload))
+            continue;
+        const candidateModelId = payload.modelId;
+        const candidate = payload.checkpoint;
+        if (candidateModelId !== modelId || !isModelContinuationCheckpoint(candidate))
+            continue;
+        checkpoint = candidate;
+    }
+    return checkpoint;
+}
+function isModelContinuationCheckpoint(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const checkpoint = value;
+    return (checkpoint.version === 1 &&
+        checkpoint.protocol === 'OPENAI_RESPONSES' &&
+        isBoundedString(checkpoint.configurationHash, 64) &&
+        isBoundedString(checkpoint.responseId, 1_024) &&
+        isBoundedString(checkpoint.requestPropertiesHash, 64) &&
+        Number.isSafeInteger(checkpoint.inputPrefixLength) &&
+        checkpoint.inputPrefixLength >= 0 &&
+        isBoundedString(checkpoint.inputPrefixHash, 64));
+}
+function isBoundedString(value, maximumLength) {
+    return typeof value === 'string' && value.length > 0 && value.length <= maximumLength;
+}
 function modelAttemptFailureDiagnostic(diagnostic, summary) {
     if (summary === undefined)
         return diagnostic;
@@ -1508,7 +1623,16 @@ function modelAttemptFailureDiagnostic(diagnostic, summary) {
     };
 }
 async function closeModelAdapters(adapters) {
-    await Promise.all([...new Set(adapters)].flatMap((adapter) => adapter.close === undefined ? [] : [adapter.close()]));
+    const results = await Promise.allSettled([...new Set(adapters)].flatMap((adapter) => adapter.close === undefined ? [] : [adapter.close()]));
+    const failure = results.find((result) => result.status === 'rejected');
+    if (failure !== undefined)
+        throw failure.reason;
+}
+function addModelCredentialProviders(target, configuration) {
+    if (configuration.credentialProvider !== undefined)
+        target.add(configuration.credentialProvider);
+    if (configuration.imageGeneration !== undefined)
+        target.add(configuration.imageGeneration.credentialProvider);
 }
 function truncateUtf8(value, maximumBytes) {
     const bytes = Buffer.from(value);
@@ -1764,17 +1888,19 @@ function modelIdFromPayload(payload, key = 'modelId') {
     const value = payload[key];
     return typeof value === 'string' && value.length > 0 ? value : undefined;
 }
-function insertContextualInstructions(messages, entries) {
+function insertContextualWorldState(messages, entries, options = {}) {
     const result = [...messages];
     let offset = 0;
     for (const entry of entries) {
+        if (options.excludeResources && entry.kind === 'resources')
+            continue;
         const insertionIndex = Math.max(0, Math.min(entry.index + offset, result.length));
         result.splice(insertionIndex, 0, { role: 'user', content: entry.content });
         offset++;
     }
     return result;
 }
-function latestContextualInstructionGeneration(records) {
+function latestContextualWorldStateGeneration(records) {
     let generation;
     for (const record of records)
         if (record.type === 'context.gc.completed' ||
@@ -1782,12 +1908,39 @@ function latestContextualInstructionGeneration(records) {
             generation = record.recordId;
     return generation;
 }
-function resetContextualInstructions(generation, snapshot, index, content) {
+function compactHistoryMayContainRetainedResources(records) {
+    return records.some((record) => compactSummaryFromCheckpoint(record)?.includes('# Retained Session resources'));
+}
+function updateContextualWorldState(state, index, current) {
+    const entries = [...state.entries];
+    if (!state.initialized || state.instructionSnapshot !== current.instructionSnapshot) {
+        if (current.instructionContent !== undefined)
+            entries.push({ index, kind: 'instructions', content: current.instructionContent });
+    }
+    const resourceContent = retainedSessionResourcesUpdate(current.resourceSnapshot, state.initialized ? state.resourceSnapshot : undefined, !state.initialized && current.previousMayContainResources);
+    if (resourceContent !== undefined)
+        entries.push({ index, kind: 'resources', content: resourceContent });
+    return {
+        generation: state.generation,
+        initialized: true,
+        instructionSnapshot: current.instructionSnapshot,
+        resourceSnapshot: current.resourceSnapshot,
+        entries
+    };
+}
+function resetContextualWorldState(generation, index, current) {
+    const entries = [];
+    if (current.instructionContent !== undefined)
+        entries.push({ index, kind: 'instructions', content: current.instructionContent });
+    const resourceContent = retainedSessionResourcesUpdate(current.resourceSnapshot, undefined, current.previousMayContainResources);
+    if (resourceContent !== undefined)
+        entries.push({ index, kind: 'resources', content: resourceContent });
     return {
         generation,
         initialized: true,
-        snapshot,
-        entries: content === undefined ? [] : [{ index, content }]
+        instructionSnapshot: current.instructionSnapshot,
+        resourceSnapshot: current.resourceSnapshot,
+        entries
     };
 }
 function contextualInstructionInsertIndex(messages) {

package/dist/session/jsonl-store.js

@@ -302,7 +302,7 @@ export class JsonlSessionStore {
                 });
                 const retained = input.boundaryTurnId === null ? [] : records.slice(1, boundaryIndex + 1);
                 for (const record of retained) {
-                    if (record.type === 'context.gc.completed')
+                    if (record.type === 'context.gc.completed' || record.type === 'responses.continuation')
                         continue;
                     await this.append(target.id, {
                         type: record.type,
@@ -368,7 +368,9 @@ export class JsonlSessionStore {
                 : records.findLastIndex((record) => record.turnId === input.boundaryTurnId);
             if (input.boundaryTurnId !== null && boundaryIndex < 0)
                 throw new MarAgentError('MAR_AGENT_ROLLBACK_TARGET_INVALID', 'Session rollback target was not found.');
-            const retained = records.slice(0, boundaryIndex + 1);
+            const retained = records
+                .slice(0, boundaryIndex + 1)
+                .filter((record) => record.type !== 'responses.continuation');
             const staged = await stageRollbackSegments(this.sessionDirectory(sessionId), retained);
             const transactionId = randomUUID();
             let generatedTrash = [];

package/dist/subagent/session-controller.js

@@ -160,9 +160,9 @@ export class SubagentSessionController {
         if (waitFor === 'completion') {
             const completed = await this.#waitForCompletion(state, waitMs, options.signal);
             options.signal?.throwIfAborted();
-            const includeLatestMessage = completed ? this.#hasUnreadMessage(state) : false;
+            const includeLatestMessage = this.#hasUnreadMessage(state);
             const includeTerminalDetails = completed ? this.#observeTerminal(state) : false;
-            if (completed)
+            if (includeLatestMessage)
                 this.#observeLatestMessage(state);
             return {
                 ...this.#snapshot(state, { includeLatestMessage, includeTerminalDetails }),
@@ -244,12 +244,13 @@ export class SubagentSessionController {
         }
         const completed = await this.#waitForAnyCompletion(live, waitMs, options.signal);
         options.signal?.throwIfAborted();
-        const includeLatestMessage = completed ? this.#hasUnreadMessage(completed) : false;
-        const includeTerminalDetails = completed ? this.#observeTerminal(completed) : false;
-        if (completed)
-            this.#observeLatestMessage(completed);
+        const state = completed ?? this.#oldestUnreadMessage(live) ?? live.at(-1);
+        const includeLatestMessage = this.#hasUnreadMessage(state);
+        const includeTerminalDetails = completed ? this.#observeTerminal(state) : false;
+        if (includeLatestMessage)
+            this.#observeLatestMessage(state);
         return {
-            ...this.#snapshot(completed ?? live.at(-1), {
+            ...this.#snapshot(state, {
                 includeLatestMessage,
                 includeTerminalDetails
             }),

package/dist/tools/agent-wait.js

@@ -3,7 +3,7 @@ import { TOOL_EXECUTION_LIMITS } from './execution-limits.js';
 export const agentWaitToolDefinition = {
     name: 'agent_wait',
     parallelSafety: 'serial',
-    description: 'Read or wait a bounded time for a child agent result. waitFor defaults to "completion"; use "message" only when a fresh public commentary/final message would change the next decision. Omit agentId to wait for whichever live child returns first, matching Codex-style untargeted waiting and avoiding UUID transcription; provide the exact agentId returned by agent_start only when observing a specific child. If no child is live, untargeted waiting reads the most recently created child. For an exec processId, use exec with action:"poll" instead. Omitting waitMs waits up to 30 seconds by default; waitMs=0 returns the current snapshot immediately. Positive waits range up to 5 minutes, and positive values below 10 seconds are raised to 10 seconds. When blocked on a live child result, prefer one 300000 ms completion wait rather than repeated short waits. Every result includes waitOutcome as snapshot, message, completion, or timeout plus the real agentId and description. A message or first terminal completion result includes the newly observed latest public commentary/final message; snapshot, timeout, and repeated terminal results omit previously observed message text. latestActivity can still identify a public message or bounded tool started/completed/failed status. A queued or running result is not completion. A message wait consumes only the latest unread public message in the current Session runtime; tool activity does not wake it, and parent cancellation preserves unread progress for a later Execution. Do not use message waits as heartbeat checks or request progress merely to confirm that a child is still running. First terminal results include bounded summary, changedFiles, verification, and read evidence with path/line ranges; use that evidence to avoid repeating the full exploration, while independently checking consequential edits and claims.',
+    description: 'Read or wait a bounded time for a child agent result. waitFor defaults to "completion"; use "message" only when a fresh public commentary/final message would change the next decision. Omit agentId to wait for whichever live child returns first, matching Codex-style untargeted waiting and avoiding UUID transcription; provide the exact agentId returned by agent_start only when observing a specific child. If no child is live, untargeted waiting reads the most recently created child. For an exec processId, use exec with action:"poll" instead. Omitting waitMs waits up to 30 seconds by default; waitMs=0 returns the current snapshot immediately. Positive waits range up to 5 minutes, and positive values below 10 seconds are raised to 10 seconds. When blocked on a live child result, prefer one 300000 ms completion wait rather than repeated short waits. Every result includes waitOutcome as snapshot, message, completion, or timeout plus the real agentId and description. A message, timeout with unread progress, or first terminal completion result includes the newly observed latest public commentary/final message; snapshots and repeated observations omit previously observed message text. latestActivity can still identify a public message or bounded tool started/completed/failed status. A queued or running result is not completion. A message wait consumes only the latest unread public message in the current Session runtime; tool activity does not wake it, and parent cancellation preserves unread progress for a later Execution. Do not use message waits as heartbeat checks or request progress merely to confirm that a child is still running. First terminal results include bounded summary, changedFiles, verification, and read evidence with path/line ranges; use that evidence to avoid repeating the full exploration, while independently checking consequential edits and claims.',
     inputSchema: {
         type: 'object',
         properties: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/agent",
-  "version": "0.9.82",
+  "version": "0.9.84",
   "description": "Embeddable MAR coding agent SDK and CLI.",
   "license": "Apache-2.0",
   "type": "module",