@myagentroam/agent 0.10.48 → 0.10.49

package/dist/agent-core/extensions/session-input.d.ts

@@ -111,6 +111,11 @@ export interface CoreSessionBackend {
     handled(input: CoreSubmitInput, call: CoreOperationContext, value?: unknown): CoreSessionReceipt;
 }
 export interface SessionInputEntry {
+    /** SDK-owned admission barrier, never accepted from Extension input. */
+    nativeSteer?: {
+        readonly ready: Promise<void>;
+        recordId?: string;
+    };
     readonly request: CoreSessionRequest;
     readonly source: CoreOperationContext;
     readonly action: CoreSessionAction;
@@ -129,6 +134,9 @@ export declare class SessionInputCoordinator {
     readonly diagnose: (receipt: CoreSessionReceipt) => void;
     constructor(diagnose?: (receipt: CoreSessionReceipt) => void);
     get hasPending(): boolean;
+    get boundarySize(): number;
+    get hasIdleBarrier(): boolean;
+    restoreSteer(recordId: string, text: string, source: CoreOperationContext): void;
     get hasBoundaryPending(): boolean;
     get executing(): boolean;
     get hasBoundaryCompactPending(): boolean;
@@ -144,6 +152,8 @@ export declare class SessionInputCoordinator {
         readonly executionId: string;
         readonly turnId: string;
         readonly signal: AbortSignal;
+        /** An already authorized idle launch restores older durable input before its own prompt. */
+        readonly restoring?: true;
     }, limit?: number): Promise<boolean>;
     idle(): Promise<void>;
     retire(instanceId?: string): Promise<void>;

package/dist/agent-core/extensions/session-input.js

@@ -36,6 +36,29 @@ export class SessionInputCoordinator {
     get hasPending() {
         return this.#pending.length > 0;
     }
+    get boundarySize() {
+        return this.#pending.length;
+    }
+    get hasIdleBarrier() {
+        return this.#pending.some((entry) => entry.receipt.status !== 'cancelled' &&
+            !entry.source.signal.aborted &&
+            entry.request.kind === 'submit' &&
+            entry.request.input.delivery === 'idle');
+    }
+    restoreSteer(recordId, text, source) {
+        const index = this.#pending.findIndex((entry) => entry.nativeSteer?.recordId === recordId);
+        const previous = this.#pending[index];
+        if (previous &&
+            !previous.source.signal.aborted &&
+            !['cancelled', 'failed'].includes(previous.receipt.status))
+            return;
+        const entry = this.#record({ kind: 'submit', input: { text } }, source, (request, call, next) => next(request, call), 'accepted');
+        entry.nativeSteer = { recordId, ready: Promise.resolve() };
+        if (index >= 0)
+            this.#pending[index] = entry;
+        else
+            this.#pending.unshift(entry);
+    }
     get hasBoundaryPending() {
         const head = this.#pending.find((entry) => entry.receipt.status !== 'cancelled' && !entry.source.signal.aborted);
         return !!head && (head.request.kind !== 'submit' || head.request.input.delivery !== 'idle');
@@ -169,13 +192,19 @@ export class SessionInputCoordinator {
         return entry;
     }
     drain(leaf, execution, limit = Number.POSITIVE_INFINITY) {
-        if (this.#draining)
+        if (this.#draining && (!this.executing || !execution?.restoring))
             return this.executing ? Promise.resolve(false) : this.#draining;
-        this.#draining = (async () => {
+        const drain = async () => {
             let changed = false;
             let consumed = 0;
             while (this.#pending.length && consumed++ < limit) {
                 const head = this.#pending[0];
+                // Accepted guidance is never permission to launch a new idle execution.
+                if (!execution && head.nativeSteer) {
+                    this.#pending.shift();
+                    this.#finish(head, 'cancelled');
+                    continue;
+                }
                 // An idle prompt is a new Turn, not a mailbox delivery into the active Turn.
                 // Preserve the single FIFO: entries behind it cannot overtake it.
                 if (execution &&
@@ -208,7 +237,10 @@ export class SessionInputCoordinator {
                 changed ||= applied;
             }
             return changed;
-        })().finally(() => {
+        };
+        if (this.#draining)
+            return drain();
+        this.#draining = drain().finally(() => {
             this.#draining = undefined;
         });
         return this.#draining;
@@ -223,6 +255,14 @@ export class SessionInputCoordinator {
         let effects = 0;
         let committed;
         try {
+            if (entry.nativeSteer) {
+                await entry.nativeSteer.ready;
+                call.signal.throwIfAborted();
+                if (!entry.nativeSteer.recordId) {
+                    this.#finish(entry, 'handled', { changed: false });
+                    return false;
+                }
+            }
             const outcome = await this.#current.run(entry, () => entry.action(entry.request, call, async (request, effective) => {
                 validateCoreSessionRequest(request);
                 effective.signal.throwIfAborted();
@@ -254,6 +294,8 @@ export class SessionInputCoordinator {
             committed = physicalCommits.get(entry) ?? committed;
             changed ||= (committed?.modelChanged ?? committed?.changed) || !!entry.receipt.changed;
             this.#finish(entry, call.signal.aborted ? 'cancelled' : 'failed', committed, error instanceof MarAgentError ? error.code : 'MAR_AGENT_SESSION_INPUT_FAILED');
+            if (entry.nativeSteer?.recordId)
+                throw error;
         }
         finally {
             physicalCommits.delete(entry);

package/dist/agent-core/runtime/compaction/retained-context.js

@@ -22,6 +22,8 @@ export function restoreCompactTail(value) {
         input.contextKind === 'compact_control')
         return undefined;
     if ((input.role === 'assistant' || input.role === 'user') && typeof input.content === 'string') {
+        if (input.inputRef !== undefined)
+            return restoreModelContext(input);
         const projected = restoreModelContext(input);
         const metadata = parseModelInputMetadata(input.metadata);
         const contextKind = ['environment', 'contextual', 'summary'].includes(String(input.contextKind))

package/dist/agent-core/runtime/context/projection.js

@@ -1,4 +1,6 @@
 import { anthropicThinkingBlock } from '../../model/anthropic-thinking.js';
+import { appliedInputRecord } from '../../session/deferred-input.js';
+import { inputMetadataFromRecord } from '../../session/jsonl-store.js';
 import { contextGcRecordSourceHash, contextGcTargetKey, latestValidContextGcCheckpoint } from '../../session/context-gc-checkpoint.js';
 import { TOOL_EXECUTION_LIMITS } from '../../tools/execution-limits.js';
 import { replaceReadContextItems } from '../../tools/local/read-context.js';
@@ -19,7 +21,14 @@ export function buildContextProjection(records, workspace, checkpointCache) {
         }
         if (record.type !== 'model.context' || !isRecord(record.payload))
             continue;
-        const message = restoreModelContext(record.payload, activeModelId);
+        const applied = appliedInputRecord(record);
+        const message = applied
+            ? {
+                role: 'user',
+                content: record.payload.content,
+                metadata: inputMetadataFromRecord(applied)
+            }
+            : restoreModelContext(record.payload, activeModelId);
         if (message)
             rawEntries.push({ record, message });
     }
@@ -133,6 +142,14 @@ export function filterPairedContext(messages, messageSources) {
     };
 }
 export function restoreModelContext(payload, providerModelId) {
+    if (payload.inputRef !== undefined) {
+        const input = appliedInputRecord({ type: 'model.context', payload });
+        return {
+            role: 'user',
+            content: payload.content,
+            metadata: inputMetadataFromRecord(input)
+        };
+    }
     const nativeItem = payload.role === 'provider' && payload.provider === 'OPENAI_RESPONSES' && isRecord(payload.item)
         ? payload.item
         : undefined;

package/dist/agent-core/runtime/context/restore.d.ts

@@ -13,6 +13,7 @@ export declare function restoreMessages(store: JsonlSessionStore, sessionId: str
         isError: boolean;
         result?: unknown;
     }>;
+    pendingInputs: Map<string, import("../../session/jsonl-store.js").SessionRecord>;
     environmentState: EnvironmentContextState | undefined;
     userMessages: CompactUserInput[];
     messages: ModelMessage[];

package/dist/agent-core/runtime/context/restore.js

@@ -1,4 +1,5 @@
 import { MarAgentError } from '../../error.js';
+import { appliedInputRecord, pendingDeferredInputs } from '../../session/deferred-input.js';
 import { compactSummaryFromCheckpoint, replacementHistoryFromCheckpoint, inputMetadataFromRecord } from '../../session/jsonl-store.js';
 import { compactedHistoryMessages, continuationMessage } from '../compaction/history.js';
 import { restoreCompactTail } from '../compaction/retained-context.js';
@@ -14,9 +15,12 @@ export async function restoreMessages(store, sessionId, records, options) {
     let ignoredImages = 0;
     let currentTurnUserIndex;
     let environmentState;
+    const pendingInputs = pendingDeferredInputs(records);
     for (const record of records) {
         const messageStart = messages.length;
-        const payload = record.payload;
+        const applied = appliedInputRecord(record);
+        const inputRecord = applied ?? record;
+        const payload = inputRecord.payload;
         if ((record.type === 'tool.completed' || record.type === 'tool.failed') &&
             typeof payload.callId === 'string') {
             const result = record.type === 'tool.failed' ? payload.message : payload.data;
@@ -26,10 +30,12 @@ export async function restoreMessages(store, sessionId, records, options) {
             });
         }
         const compactSummary = compactSummaryFromCheckpoint(record);
-        if ((record.type === 'turn.user' || record.type === 'extension.input') &&
+        if ((applied ||
+            ((record.type === 'turn.user' || record.type === 'extension.input') &&
+                payload.deferred !== true)) &&
             typeof payload.prompt === 'string') {
             const content = typeof payload.modelText === 'string' ? payload.modelText : payload.prompt;
-            const metadata = inputMetadataFromRecord(record);
+            const metadata = inputMetadataFromRecord(inputRecord);
             userMessages.push({ content, metadata });
             let images = [];
             if (options.includeImages)
@@ -101,6 +107,16 @@ export async function restoreMessages(store, sessionId, records, options) {
                         continue;
                     const message = restoreCompactTail(item);
                     if (message) {
+                        if (options.includeImages && item.inputRef !== undefined) {
+                            const input = appliedInputRecord({
+                                ...record,
+                                type: 'model.context',
+                                payload: item
+                            });
+                            const images = await store.readInputImages(sessionId, input.payload.images);
+                            if (images.length)
+                                message.images = images;
+                        }
                         messages.push(message);
                         if (message.role === 'user' && message.contextKind === undefined)
                             userMessages.push({
@@ -136,6 +152,7 @@ export async function restoreMessages(store, sessionId, records, options) {
     const completedToolCalls = new Set(messages.filter((message) => message.role === 'tool').map((message) => message.callId));
     return {
         toolOutcomes,
+        pendingInputs,
         environmentState,
         userMessages,
         messages: messages.filter((message) => {

package/dist/agent-core/runtime/event-projection.js

@@ -11,6 +11,7 @@ export function toolEventSummary(text) {
 /** Keep streaming deltas live-only; exec output has one durable copy in model context records. */
 export function eventForPersistence(event) {
     if (event.type === 'message.delta' ||
+        event.type === 'input.received' ||
         (event.type === 'context.compacting' && event.async !== true && event.stage === undefined) ||
         event.type === 'model.performance' ||
         event.type === 'message.performance')

package/dist/agent-core/runtime/events.d.ts

@@ -14,6 +14,11 @@ export interface CompactSnapshotAnchor {
     readonly id: string;
 }
 export type MarAgentEvent = MarAgentEventBase & ({
+    type: 'input.received';
+    entry: Extract<import('../session/catalog.js').MarAgentHistoryEntry, {
+        kind: 'user';
+    }>;
+} | {
     type: 'execution.started';
     mode: ExecutionMode;
     permissionMode?: import('../tools/permissions.js').PermissionMode;

package/dist/agent-core/sdk/native-steer.d.ts

@@ -0,0 +1,19 @@
+import type { CoreOperationContext } from '../extensions/operation.js';
+import { type CorePromptInput, type CorePromptResult } from '../extensions/prompt-input.js';
+import type { SessionInputCoordinator } from '../extensions/session-input.js';
+import type { SessionRecord } from '../session/jsonl-store.js';
+import type { SteerInput, SteerResult } from './types.js';
+/** Admission reserves the existing FIFO before any asynchronous Hook or writer work. */
+export declare function createNativeSteer(input: {
+    readonly executionId: string;
+    readonly inputs: SessionInputCoordinator;
+    readonly signal: AbortSignal;
+    isOpen(): boolean;
+    operation<T>(action: (call: CoreOperationContext) => T): T;
+    admit(content: CorePromptInput, call: CoreOperationContext, write: (content: CorePromptInput, call: CoreOperationContext) => Promise<CorePromptResult>): Promise<unknown>;
+    receive(content: CorePromptInput, clientMessageId: string, call: CoreOperationContext): Promise<SessionRecord>;
+    notify(entry: Extract<SteerResult, {
+        status: 'accepted';
+    }>['entry']): Promise<unknown>;
+    diagnose(): void;
+}): (request: SteerInput) => Promise<SteerResult>;

package/dist/agent-core/sdk/native-steer.js

@@ -0,0 +1,83 @@
+import { MarAgentError } from '../error.js';
+import { captureCorePromptInput } from '../extensions/prompt-input.js';
+import { imageMetadata } from '../session/catalog.js';
+/** Admission reserves the existing FIFO before any asynchronous Hook or writer work. */
+export function createNativeSteer(input) {
+    const retries = new Map();
+    let admissionTail = Promise.resolve();
+    return async (request) => {
+        if (request.expectedExecutionId !== input.executionId)
+            return Promise.resolve({ status: 'notAccepted' });
+        const previous = retries.get(request.clientMessageId);
+        if (previous)
+            return previous;
+        if (!input.isOpen() || input.signal.aborted || input.inputs.hasIdleBarrier)
+            return Promise.resolve({ status: 'notAccepted' });
+        if (typeof request.clientMessageId !== 'string' ||
+            !request.clientMessageId.trim() ||
+            request.clientMessageId.length > 512)
+            return Promise.reject(new MarAgentError('MAR_AGENT_SESSION_INPUT_INVALID', 'A stable client message ID is required.'));
+        const content = captureCorePromptInput({
+            text: request.prompt,
+            ...(request.modelText === undefined ? {} : { modelText: request.modelText }),
+            ...(request.images === undefined ? {} : { images: request.images })
+        });
+        const result = Promise.withResolvers();
+        const ready = Promise.withResolvers();
+        const entry = input.operation((call) => input.inputs.accept({ kind: 'submit', input: content }, call, (request, effective, next) => next(request, effective), 'accepted'));
+        entry.nativeSteer = { ready: ready.promise };
+        const aborted = () => ready.resolve();
+        input.signal.addEventListener('abort', aborted, { once: true });
+        let committed = false;
+        const admission = admissionTail
+            .catch(() => undefined)
+            .then(() => input.operation((call) => input.admit(content, call, async (actual, effective) => {
+            if (committed)
+                return {};
+            effective.signal.throwIfAborted();
+            if (!input.isOpen()) {
+                result.resolve({ status: 'notAccepted' });
+                return {};
+            }
+            const record = await input.receive(actual, request.clientMessageId, effective);
+            committed = true;
+            entry.nativeSteer.recordId = record.recordId;
+            const payload = record.payload;
+            const images = imageMetadata(payload.images);
+            const historyEntry = {
+                kind: 'user',
+                recordId: record.recordId,
+                sequence: record.sequence,
+                timestamp: record.timestamp,
+                sessionId: record.sessionId,
+                executionId: record.executionId,
+                turnId: record.turnId,
+                text: payload.prompt,
+                clientMessageId: request.clientMessageId,
+                ...(images.length ? { images } : {})
+            };
+            // Neither Hook post-processing nor a failed observer can revoke the writer's receipt.
+            void input.notify(historyEntry).catch(() => input.diagnose());
+            ready.resolve();
+            result.resolve({ status: 'accepted', entry: historyEntry });
+            return {};
+        })));
+        void admission
+            .then(() => {
+            if (!committed)
+                result.resolve({ status: 'handled' });
+        }, (error) => {
+            if (!committed)
+                result.reject(error);
+            else
+                input.diagnose();
+        })
+            .finally(() => {
+            ready.resolve();
+            input.signal.removeEventListener('abort', aborted);
+        });
+        admissionTail = result.promise;
+        retries.set(request.clientMessageId, result.promise);
+        return result.promise;
+    };
+}

package/dist/agent-core/sdk/session.d.ts

@@ -16,6 +16,7 @@ import { createSessionToolScheduler } from '../tools/scheduler.js';
 import { TodoStore } from '../tools/agent/todo.js';
 import type { CreateMarAgentOptions, ExecutionResult, MarAgentSession } from './types.js';
 export interface SessionRuntime {
+    steer?: (input: import('./types.js').SteerInput) => Promise<import('./types.js').SteerResult>;
     todo?: TodoStore;
     readonly scheduleTool: ReturnType<typeof createSessionToolScheduler>;
     readonly sourceType: 'user' | 'subagent';

package/dist/agent-core/sdk/session.js

@@ -1,6 +1,7 @@
 import { isProviderContextOverflow, recoverModelStream } from '../model/recovery.js';
 import { estimatedRequestTokens } from '../runtime/context/request-budget.js';
 import { restoreMessages } from '../runtime/context/restore.js';
+import { createNativeSteer } from './native-steer.js';
 import { lastConfigurationEffort, latestModelUsage, reasoningEffortBaseline, shouldUseNativeCompaction } from '../runtime/context/usage.js';
 import { splitContextualPrompt } from '../runtime/context/contextual-blocks.js';
 import { contextualInstructionInsertIndex, insertContextualWorldState, latestContextualWorldStateGeneration, parsePersistedContextualWorldState, persistContextualWorldState, resetContextualWorldState, updateContextualWorldState, updatePromptWorldState } from '../runtime/context/world-state.js';
@@ -274,6 +275,7 @@ export function createSessionOpener(services) {
             for (const message of internal.initialMailbox ?? [])
                 acceptParent(message);
             let acceptsMailbox = sessionSource.type === 'subagent' && mode !== 'compact';
+            let acceptsSteer = false;
             let sequence = 0;
             let emitTail = Promise.resolve();
             let releaseSession;
@@ -411,6 +413,7 @@ export function createSessionOpener(services) {
                         includeImages: mode !== 'compact'
                     });
                     const messages = restored.messages;
+                    const pendingInputs = restored.pendingInputs;
                     liveModelMessages = messages;
                     const restoredRecordIds = new Set(contextRecords.map((record) => record.recordId));
                     for (const pending of pendingAppends)
@@ -472,7 +475,7 @@ export function createSessionOpener(services) {
                                 messages.push({ role: 'user', content: text, contextKind: 'contextual' });
                         });
                     };
-                    const appendMailboxMessages = async () => inputs.drain(async (entry, request, call) => {
+                    const appendMailboxMessages = async (restoring = false) => inputs.drain(async (entry, request, call) => {
                         call.signal.throwIfAborted();
                         if (request.kind === 'compact') {
                             if (request.input.async) {
@@ -486,6 +489,63 @@ export function createSessionOpener(services) {
                             const result = await appendExtensionMessage(entry, request, call);
                             return { ...result, executionId };
                         }
+                        if (entry.nativeSteer?.recordId) {
+                            const received = pendingInputs.get(entry.nativeSteer.recordId);
+                            if (!received)
+                                return { changed: false, modelChanged: false };
+                            return withRecordProjection(async () => {
+                                call.signal.throwIfAborted();
+                                const payload = received.payload;
+                                const images = await store.readInputImages(sessionId, payload.images);
+                                if (images.length && !selectedModel.inputCapabilities.includes('IMAGE'))
+                                    throw new MarAgentError('MAR_AGENT_INPUT_CAPABILITY_UNSUPPORTED', 'Selected model does not support image input.');
+                                const percent = smartContextTokens === undefined
+                                    ? undefined
+                                    : (smartContextTokens * 100) / selectedModel.contextWindowTokens;
+                                const eligible = sessionSource.type === 'user' &&
+                                    percent !== undefined &&
+                                    percent >= AGENT_EXECUTION_POLICY.smartCompactionPercent &&
+                                    percent < AGENT_EXECUTION_POLICY.automaticCompactionPercent;
+                                const actual = {
+                                    ...payload,
+                                    ...(eligible ? { smartCompaction: true } : {})
+                                };
+                                const content = (actual.modelText ?? actual.prompt);
+                                const applied = await store.append(sessionId, {
+                                    type: 'model.context',
+                                    payload: {
+                                        role: 'user',
+                                        content,
+                                        inputRef: received.recordId,
+                                        input: actual
+                                    },
+                                    executionId,
+                                    turnId
+                                }, { signal: call.signal });
+                                const outcome = {
+                                    changed: true,
+                                    modelChanged: true,
+                                    executionId,
+                                    recordId: received.recordId
+                                };
+                                recordSessionInputCommit(entry, outcome);
+                                pendingInputs.delete(received.recordId);
+                                const metadata = inputMetadataFromRecord({ ...received, payload: actual });
+                                const message = {
+                                    role: 'user',
+                                    content,
+                                    metadata,
+                                    ...(images.length ? { images } : {})
+                                };
+                                messages.push(message);
+                                messageSources.set(message, applied);
+                                compactionUserMessages.push({ content, metadata });
+                                smartInput = { recordId: received.recordId, eligible, requested: false };
+                                for (const text of (payload.modelContext ?? payload.context ?? []))
+                                    messages.push({ role: 'user', content: text, contextKind: 'contextual' });
+                                return outcome;
+                            });
+                        }
                         const parent = entry.parentMessage;
                         let outcome;
                         const content = {
@@ -528,7 +588,12 @@ export function createSessionOpener(services) {
                             parent?.delivery?.applied();
                         });
                         return outcome;
-                    }, { executionId, turnId, signal: controller.signal });
+                    }, {
+                        executionId,
+                        turnId,
+                        signal: controller.signal,
+                        ...(restoring ? { restoring: true } : {})
+                    }, inputs.boundarySize);
                     const recordEnvironment = async () => {
                         const message = environmentContextUpdate(executionEnvironment, recordedEnvironment);
                         if (!message)
@@ -698,6 +763,12 @@ export function createSessionOpener(services) {
                         entry: 'native-api',
                         signal: controller.signal
                     }, run);
+                    if (mode !== 'compact') {
+                        // Missing entries prepend in reverse order; warm entries retain their FIFO position.
+                        for (const record of [...pendingInputs.values()].reverse()) {
+                            operation((call) => inputs.restoreSteer(record.recordId, record.payload.prompt, call));
+                        }
+                    }
                     await operation((call) => coreExtensions.ready(call));
                     const captureTools = () => operation((call) => {
                         return coreExtensions.capture(call, false, sourceBindings.filter((binding) => !supplementalBindings.includes(binding) || binding.available?.(call) !== false));
@@ -1061,6 +1132,8 @@ export function createSessionOpener(services) {
                                 : message), mode === 'compact' ? [] : contextualWorldState.entries, mode !== 'compact' && selectedModel.inputCapabilities.includes('IMAGE'), baseTools().some((tool) => tool.name === 'code_exec'), permissionPolicy.mode === 'auto')
                     };
                     if (mode !== 'compact') {
+                        if (pendingInputs.size)
+                            await appendMailboxMessages(true);
                         let entered = false;
                         const writeInput = async (content, call) => {
                             call.signal.throwIfAborted();
@@ -1113,6 +1186,45 @@ export function createSessionOpener(services) {
                             await emit({ type: 'execution.completed' });
                             return { executionId, status: 'completed', finalAnswer: '', inputHandled: true };
                         }
+                        acceptsSteer = true;
+                        sessionRuntime.steer = createNativeSteer({
+                            executionId,
+                            inputs,
+                            signal: controller.signal,
+                            isOpen: () => acceptsSteer,
+                            operation,
+                            admit: (content, call, write) => invokeCorePromptSubmission(coreExtensions.hooks, content, call, write),
+                            receive: (content, clientMessageId, call) => withRecordProjection(async () => {
+                                call.signal.throwIfAborted();
+                                if (content.images?.length && !selectedModel.inputCapabilities.includes('IMAGE'))
+                                    throw new MarAgentError('MAR_AGENT_INPUT_CAPABILITY_UNSUPPORTED', 'Selected model does not support image input.');
+                                const images = content.images?.length
+                                    ? await store.persistInputImages(sessionId, content.images)
+                                    : [];
+                                const record = await store.append(sessionId, {
+                                    type: 'turn.user',
+                                    payload: {
+                                        deferred: true,
+                                        prompt: content.text,
+                                        ...(content.modelText === undefined
+                                            ? {}
+                                            : { modelText: content.modelText }),
+                                        ...(content.context === undefined ? {} : { context: content.context }),
+                                        ...(content.modelContext === undefined
+                                            ? {}
+                                            : { modelContext: content.modelContext }),
+                                        clientMessageId,
+                                        ...(images.length ? { images } : {})
+                                    },
+                                    executionId,
+                                    turnId
+                                }, { signal: call.signal });
+                                pendingInputs.set(record.recordId, record);
+                                return record;
+                            }),
+                            notify: (entry) => emit({ type: 'input.received', entry }),
+                            diagnose: () => coreExtensions.diagnose({ code: 'MAR_AGENT_STEER_POST_COMMIT_FAILED', sessionId })
+                        });
                     }
                     if (mode !== 'compact' &&
                         useEffortUpdates &&
@@ -1360,7 +1472,22 @@ export function createSessionOpener(services) {
                                 const record = await store.compact(sessionId, {
                                     summary: actual,
                                     replacementHistory,
-                                    retainedModelContext,
+                                    retainedModelContext: retainedModelContext.map((message) => {
+                                        const source = messageSources.get(message);
+                                        const saved = source?.type === 'model.context' &&
+                                            source.payload.inputRef
+                                            ? source.payload
+                                            : source?.type === 'compact.completed'
+                                                ? (source.payload.retainedModelContext ?? []).find((item) => item.inputRef === message.metadata?.recordId)
+                                                : undefined;
+                                        return saved
+                                            ? {
+                                                ...saved,
+                                                ...(message.metadata ? { metadata: message.metadata } : {})
+                                            }
+                                            : message;
+                                    }),
+                                    pendingInputs: [...pendingInputs.values()],
                                     snapshotMessageCount: prefix.length,
                                     ...(anchorRecordId ? { snapshotRecordId: anchorRecordId } : {}),
                                     automatic: mode !== 'compact',
@@ -1714,6 +1841,7 @@ export function createSessionOpener(services) {
                                 append: appendMailboxMessages,
                                 close: () => {
                                     acceptsMailbox = false;
+                                    acceptsSteer = false;
                                 }
                             }
                         });
@@ -1750,6 +1878,9 @@ export function createSessionOpener(services) {
                 catch (error) {
                     finalAnswer = executionLoop?.finalAnswer ?? finalAnswer;
                     acceptsMailbox = false;
+                    acceptsSteer = false;
+                    delete sessionRuntime.steer;
+                    await sessionRuntime.recordProjection?.catch(() => undefined);
                     await compactCoordinator.close(error);
                     compactRequests.close(new MarAgentError('MAR_AGENT_CANCELLED', 'Execution ended.'));
                     if (sessionRuntime.compactRequests === compactRequests)
@@ -2078,6 +2209,7 @@ export function createSessionOpener(services) {
             id: sessionId,
             run: (input) => execution('run', input),
             plan: (input) => execution('plan', input),
+            steer: (input) => sessionRuntime.steer?.(input) ?? Promise.resolve({ status: 'notAccepted' }),
             compact: (input = {}) => sessionRuntime.compactRequests?.request(input) ??
                 execution('compact', {
                     prompt: input.prompt ?? DEFAULT_COMPACTION_FOCUS,

package/dist/agent-core/sdk/types.d.ts

@@ -24,11 +24,29 @@ export interface ExecutionHandle extends AsyncIterable<MarAgentEvent> {
 export type CompactInput = Partial<RunInput> & {
     readonly async?: boolean;
 };
+export interface SteerInput {
+    readonly expectedExecutionId: string;
+    readonly prompt: string;
+    readonly modelText?: string;
+    readonly clientMessageId: string;
+    readonly images?: RunInput['images'];
+}
+export type SteerResult = {
+    readonly status: 'accepted';
+    readonly entry: Extract<import('../session/catalog.js').MarAgentHistoryEntry, {
+        kind: 'user';
+    }>;
+} | {
+    readonly status: 'handled';
+} | {
+    readonly status: 'notAccepted';
+};
 /** A persisted Session permits one active main execution at a time. */
 export interface MarAgentSession {
     readonly id: string;
     run(input: RunInput): ExecutionHandle;
     plan(input: RunInput): ExecutionHandle;
+    steer(input: SteerInput): Promise<SteerResult>;
     compact(input?: CompactInput): ExecutionHandle;
     cancel(executionId: string): Promise<void>;
 }

package/dist/agent-core/session/catalog.d.ts

@@ -23,6 +23,7 @@ export interface MarAgentHistoryImageMetadata extends MarAgentImageMetadata {
 }
 export type MarAgentHistoryEntry = {
     kind: 'user';
+    recordId?: string;
     sequence: number;
     timestamp: string;
     sessionId: string;
@@ -86,3 +87,4 @@ export interface MarAgentSessionCatalog {
 export declare function openMarAgentSessionCatalog(input: {
     homeDirectory: string;
 }): Promise<MarAgentSessionCatalog>;
+export declare function imageMetadata(value: unknown): MarAgentHistoryImageMetadata[];

package/dist/agent-core/session/catalog.js

@@ -25,6 +25,7 @@ export async function openMarAgentSessionCatalog(input) {
                     return [
                         {
                             kind: 'user',
+                            ...(record.payload.deferred === true ? { recordId: record.recordId } : {}),
                             sequence: record.sequence,
                             timestamp: record.timestamp,
                             sessionId: record.sessionId,
@@ -118,7 +119,7 @@ function parseCursor(cursor) {
 function isRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
-function imageMetadata(value) {
+export function imageMetadata(value) {
     if (!Array.isArray(value))
         return [];
     return value.flatMap((image) => isRecord(image) &&

package/dist/agent-core/session/deferred-input.d.ts

@@ -0,0 +1,5 @@
+import type { SessionRecord } from './jsonl-store.js';
+/** The application is self-contained; the receive record may precede the Compact window. */
+export declare function appliedInputRecord(record: SessionRecord): SessionRecord | undefined;
+/** Only the last checkpoint and its tail are needed, never a historical consume index. */
+export declare function pendingDeferredInputs(records: readonly SessionRecord[]): Map<string, SessionRecord>;

package/dist/agent-core/session/deferred-input.js

@@ -0,0 +1,74 @@
+import { MarAgentError } from '../error.js';
+/** The application is self-contained; the receive record may precede the Compact window. */
+export function appliedInputRecord(record) {
+    if (record.type !== 'model.context' || !record.payload || typeof record.payload !== 'object')
+        return undefined;
+    const payload = record.payload;
+    if (payload.inputRef === undefined)
+        return undefined;
+    const input = payload.input;
+    if (payload.role !== 'user' ||
+        typeof payload.content !== 'string' ||
+        typeof payload.inputRef !== 'string' ||
+        !payload.inputRef ||
+        !input ||
+        typeof input !== 'object' ||
+        Array.isArray(input) ||
+        typeof input.prompt !== 'string' ||
+        input.deferred !== true ||
+        payload.content !==
+            (input.modelText ?? input.prompt))
+        throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Deferred input application is invalid.');
+    return { ...record, type: 'turn.user', recordId: payload.inputRef, payload: input };
+}
+/** Only the last checkpoint and its tail are needed, never a historical consume index. */
+export function pendingDeferredInputs(records) {
+    const pending = new Map();
+    const applied = new Set();
+    for (const record of records) {
+        const payload = (record.payload ?? {});
+        if (record.type === 'compact.completed' && typeof payload.summary === 'string') {
+            pending.clear();
+            applied.clear();
+            if (payload.pendingInputs !== undefined) {
+                if (!Array.isArray(payload.pendingInputs))
+                    corrupt();
+                for (const item of payload.pendingInputs) {
+                    if (!item ||
+                        item.type !== 'turn.user' ||
+                        item.sessionId !== record.sessionId ||
+                        typeof item.recordId !== 'string' ||
+                        !Number.isSafeInteger(item.sequence) ||
+                        item.sequence < 1 ||
+                        item.sequence >= record.sequence ||
+                        !item.payload ||
+                        item.payload.deferred !== true ||
+                        typeof item.payload.prompt !== 'string' ||
+                        pending.has(item.recordId))
+                        corrupt();
+                    pending.set(item.recordId, item);
+                }
+            }
+        }
+        else if (record.type === 'turn.user' && payload.deferred === true) {
+            if (typeof payload.prompt !== 'string' ||
+                pending.has(record.recordId) ||
+                applied.has(record.recordId))
+                corrupt();
+            pending.set(record.recordId, record);
+        }
+        else {
+            const input = appliedInputRecord(record);
+            if (!input)
+                continue;
+            if (applied.has(input.recordId))
+                corrupt();
+            applied.add(input.recordId);
+            pending.delete(input.recordId);
+        }
+    }
+    return new Map([...pending].sort(([, a], [, b]) => a.sequence - b.sequence));
+}
+function corrupt() {
+    throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Deferred input state is invalid.');
+}

package/dist/agent-core/session/jsonl-store.d.ts

@@ -193,6 +193,7 @@ export declare class JsonlSessionStore {
         summary: string;
         replacementHistory?: readonly CompactHistoryMessage[];
         retainedModelContext?: readonly ModelMessage[];
+        pendingInputs?: readonly SessionRecord[];
         snapshotRecordId?: string;
         snapshotMessageCount?: number;
         environment?: EnvironmentContextState;

package/dist/agent-core/session/jsonl-store.js

@@ -599,16 +599,18 @@ export class JsonlSessionStore {
                     }
                 ];
                 const retained = input.boundaryTurnId === null ? [] : records.slice(1, boundaryIndex + 1);
+                const forkIdentities = new Map();
                 for (const record of retained) {
                     if (record.type === 'context.gc.completed' || record.type === 'responses.continuation')
                         continue;
+                    const identity = { recordId: randomUUID(), sequence: copied.length + 1 };
+                    forkIdentities.set(record.recordId, identity);
                     copied.push({
                         schemaVersion: 1,
-                        recordId: randomUUID(),
-                        sequence: copied.length + 1,
+                        ...identity,
                         sessionId: target.id,
                         type: record.type,
-                        payload: forkedPayload(record.type, record.payload, sourceSessionId, target.id, input.title),
+                        payload: forkedPayload(record.type, record.payload, sourceSessionId, target.id, input.title, forkIdentities),
                         ...(record.executionId === undefined ? {} : { executionId: record.executionId }),
                         ...(record.turnId === undefined ? {} : { turnId: record.turnId }),
                         timestamp: record.timestamp
@@ -1306,6 +1308,7 @@ export class JsonlSessionStore {
             type: 'compact.completed',
             payload: {
                 summary: input.summary,
+                ...(input.pendingInputs?.length ? { pendingInputs: input.pendingInputs } : {}),
                 ...(input.snapshotRecordId === undefined
                     ? {}
                     : { snapshotRecordId: input.snapshotRecordId }),
@@ -2380,12 +2383,39 @@ function sessionTreeIds(sessions, sessionId) {
     }
     return ids;
 }
-function forkedPayload(type, value, sourceSessionId, targetSessionId, title) {
+function forkedPayload(type, value, sourceSessionId, targetSessionId, title, identities) {
     if (value === null || typeof value !== 'object' || Array.isArray(value))
         return value;
     const payload = { ...value };
     if (payload.sessionId === sourceSessionId)
         payload.sessionId = targetSessionId;
+    const application = (input) => {
+        if (typeof input.inputRef !== 'string')
+            return input;
+        const identity = identities.get(input.inputRef);
+        if (!identity)
+            throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Fork input reference is missing.');
+        return {
+            ...input,
+            inputRef: identity.recordId,
+            ...(isObject(input.metadata)
+                ? { metadata: { ...input.metadata, recordId: identity.recordId } }
+                : {})
+        };
+    };
+    if (type === 'model.context')
+        return application(payload);
+    if (type === 'compact.completed') {
+        if (Array.isArray(payload.retainedModelContext))
+            payload.retainedModelContext = payload.retainedModelContext.map((item) => isObject(item) ? application(item) : item);
+        if (Array.isArray(payload.pendingInputs))
+            payload.pendingInputs = payload.pendingInputs.map((record) => {
+                const identity = identities.get(record.recordId);
+                if (!identity)
+                    throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Fork pending input reference is missing.');
+                return { ...record, ...identity, sessionId: targetSessionId };
+            });
+    }
     if (type === 'session.title.updated') {
         payload.title = title;
         payload.automatic = false;

package/dist/agent-core/subagent/session-controller.d.ts

@@ -123,7 +123,7 @@ export declare class SubagentSessionController implements SubagentController {
     cancel(agentId: string): Promise<SubagentTaskSnapshot>;
     listSessionResources(): {
         agentId: string;
-        status: "completed" | "failed" | "cancelled" | "running" | "queued" | "interrupted";
+        status: "completed" | "failed" | "cancelled" | "running" | "interrupted" | "queued";
         description: string;
     }[];
     dispose(): Promise<void>;

package/dist/index.d.ts

@@ -38,7 +38,7 @@ export type { CoreModelsApi, CoreModelDescription, CoreModelTextBlock, CoreGener
 export type { CoreDataApi, CoreJsonValue, CoreCheckpoint, CoreCheckpointApi, CoreStateApi, CoreStateChange, CoreStoreApi, CoreStoreCommit } from './agent-core/extensions/data.js';
 export { generateSessionTitle, type GenerateSessionTitleInput } from './shared/auto-title.js';
 export type { CoreProcessesApi, CoreProcessesBackend, CoreProcessInput, CoreProcessRunInput, CoreProcessHandle, CoreProcessExit, CoreProcessResult, CoreProcessCompletion } from './agent-core/extensions/processes.js';
-export type { CreateMarAgentOptions, CreateSessionInput, ExecutionHandle, CompactInput, MarAgent, MarAgentSession, SessionTitleUpdateInput } from './agent-core/sdk/types.js';
+export type { CreateMarAgentOptions, CreateSessionInput, ExecutionHandle, CompactInput, SteerInput, SteerResult, MarAgent, MarAgentSession, SessionTitleUpdateInput } from './agent-core/sdk/types.js';
 export { openMarAgentSessionCatalog, type MarAgentContextUsage, type MarAgentHistoryEntry, type MarAgentHistoryPage, type MarAgentSessionCatalog, type MarAgentSessionDeleteResult, type MarAgentSessionImage, type MarAgentSessionPage, type MarAgentSessionSummary } from './agent-core/session/catalog.js';
 export type { SessionListInput, SessionSource } from './agent-core/session/types.js';
 export type { ApplyPatchFileResult, ApplyPatchResult, ApplyPatchPartialResult, ClientToolDefinition, MarAgentToolArtifact, MarAgentToolImageArtifact, McpCatalogTool, McpToolCallContext, McpToolCatalog, McpToolCatalogContext, ToolCall, ToolCaller, ToolExecutionContext, ToolExecutionResult } from './agent-core/tools/contracts.js';

package/package.json

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