@myagentroam/agent 0.11.38 → 0.11.40

package/dist/runtime/context/gc-candidates-web.js

@@ -1,5 +1,5 @@
 import { contextGcTargetKey } from '../../session/context-gc-checkpoint.js';
-import { contextGcWebOutputReplacement } from '../../session/context-gc-replacements.js';
+import { contextGcWebOutputReplacement, contextGcToolOutputReplacement, isGenericContextGcTool } from '../../session/context-gc-replacements.js';
 import { CONTEXT_GC_POLICY } from './gc-economics.js';
 import { successfulRolloutsAfter, targetFor, isRecord } from './gc-candidates.js';
 export function collectWebCandidates(input, groups, existingTargets, candidateSavings) {
@@ -53,6 +53,58 @@ export function collectWebCandidates(input, groups, existingTargets, candidateSa
     }
     return { eligible, protectedTokens, retryAfterRollouts };
 }
+/** Generic successful tool results share output economics, without inferring resource state. */
+export function collectToolOutputCandidates(input, groups, existingTargets, candidateSavings) {
+    const eligible = [];
+    let protectedTokens = 0;
+    let retryAfterRollouts = Infinity;
+    for (const group of groups.values()) {
+        if (!isGenericContextGcTool(group.toolName) ||
+            group.evidenceOnly ||
+            !group.call ||
+            !group.result ||
+            group.failed ||
+            !group.completed ||
+            group.call.message.role !== 'tool_call' ||
+            group.result.message.role !== 'tool' ||
+            typeof group.result.message.content !== 'string' ||
+            !isRecord(group.completed.payload) ||
+            group.completed.payload.type !== 'tool.completed' ||
+            group.completed.payload.callId !== group.callId ||
+            group.completed.payload.toolName !== group.toolName ||
+            typeof group.completed.payload.truncated !== 'boolean')
+            continue;
+        const target = targetFor(group.result.record, group.result.message);
+        if (!target || existingTargets.has(contextGcTargetKey(target)))
+            continue;
+        const evidenceSequence = group.result.record.sequence;
+        const observedRollouts = successfulRolloutsAfter(input.records, evidenceSequence, input.modelId, input.contextWindowTokens);
+        const candidate = {
+            replacements: [
+                {
+                    kind: 'TOOL_OUTPUT',
+                    toolName: group.toolName,
+                    callId: group.callId,
+                    target,
+                    replacementContent: contextGcToolOutputReplacement(group.toolName, group.result.message.content, group.completed.payload.truncated),
+                    evidenceSequence
+                }
+            ],
+            observedRollouts,
+            evidenceSequence
+        };
+        const reclaimedTokens = candidateSavings(candidate);
+        if (reclaimedTokens <= 0)
+            continue;
+        if (observedRollouts >= CONTEXT_GC_POLICY.largeExecProtectionRollouts)
+            eligible.push(candidate);
+        else {
+            protectedTokens += reclaimedTokens;
+            retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.largeExecProtectionRollouts - observedRollouts);
+        }
+    }
+    return { eligible, protectedTokens, retryAfterRollouts };
+}
 function isContextGcWebToolName(value) {
     return value === 'web_search' || value === 'web_fetch';
 }

package/dist/runtime/context/gc-candidates.js

@@ -44,15 +44,7 @@ export function buildToolGroups(records, messages, sources) {
             continue;
         const record = sources[index];
         for (const entry of message.calls ?? []) {
-            if (![
-                'apply_patch',
-                'exec',
-                'exec_wait',
-                'agent_start',
-                'agent_wait',
-                'agent_message',
-                'agent_cancel'
-            ].includes(entry.toolName) ||
+            if (!['apply_patch', 'exec', 'exec_wait'].includes(entry.toolName) ||
                 (entry.status === 'completed' &&
                     message.observations.some((value) => value.type === 'tool_result' && value.source.callId === entry.callId)))
                 continue;

package/dist/runtime/context/gc.js

@@ -5,9 +5,8 @@ import { CONTEXT_GC_POLICY, COMPACT_CREDIT_ACTIVATION_RATIO, COMPACT_THRESHOLD_R
 import { buildToolGroups, countSuccessfulNormalRollouts, isRecord } from './gc-candidates.js';
 import { collectCodeModeCandidates } from './gc-candidates-code.js';
 import { collectStageACandidates } from './gc-candidates-read-patch.js';
-import { collectSubagentCandidates } from './gc-candidates-subagent.js';
 import { collectExecCandidates } from './gc-candidates-exec.js';
-import { collectWebCandidates } from './gc-candidates-web.js';
+import { collectToolOutputCandidates, collectWebCandidates } from './gc-candidates-web.js';
 export { CONTEXT_GC_POLICY, evaluateContextGcEconomics, contextGcMinimumGrossReductionRate, contextGcMinimumReclaimedTokens, contextGcEligibleUsage, contextGcMarginalCacheInvestmentPaysBack, contextGcImminentCompactAvoidanceCredit, contextGcAppliedCompactCreditCostUnits } from './gc-economics.js';
 export function planContextGc(input) {
     return inspectContextGc(input).plan;
@@ -110,9 +109,8 @@ function inspectTextGc(input) {
             : [])
     ]));
     const stageA = collectStageACandidates(input, groups, existing, existingTargets, candidateSavings);
-    const subagent = collectSubagentCandidates(input, groups, existingTargets, candidateSavings);
-    const deterministicCandidates = [...stageA.eligible, ...subagent.eligible];
-    const deterministicProtectedTokens = stageA.protectedTokens + subagent.protectedTokens;
+    const deterministicCandidates = stageA.eligible;
+    const deterministicProtectedTokens = stageA.protectedTokens;
     const stageAPlan = evaluateCandidateSet(input, existing, deterministicCandidates, {
         stage: 'STAGE_A',
         contextUsageTokens,
@@ -125,10 +123,12 @@ function inspectTextGc(input) {
         const exec = collectExecCandidates(input, groups, existingTargets, candidateSavings);
         const codeMode = collectCodeModeCandidates(input, groups, existingTargets, candidateSavings);
         const web = collectWebCandidates(input, groups, existingTargets, candidateSavings);
+        const tools = collectToolOutputCandidates(input, groups, existingTargets, candidateSavings);
         const protectedCandidateTokens = deterministicProtectedTokens +
             exec.protectedTokens +
             codeMode.protectedTokens +
-            web.protectedTokens;
+            web.protectedTokens +
+            tools.protectedTokens;
         const stageAPlanWithProtectedCandidates = evaluateCandidateSet(input, existing, deterministicCandidates, {
             stage: 'STAGE_A',
             contextUsageTokens,
@@ -137,7 +137,7 @@ function inspectTextGc(input) {
             normalRolloutOrdinal,
             protectedCandidateTokens
         }) ?? stageAPlan;
-        const marginal = mergeMarginalLargeOutputCandidates(input, existing, deterministicCandidates, [...exec.eligible, ...codeMode.eligible, ...web.eligible], stageAPlanWithProtectedCandidates, {
+        const marginal = mergeMarginalLargeOutputCandidates(input, existing, deterministicCandidates, [...exec.eligible, ...codeMode.eligible, ...web.eligible, ...tools.eligible], stageAPlanWithProtectedCandidates, {
             contextUsageTokens,
             usageRatio,
             usageRecord,
@@ -147,7 +147,7 @@ function inspectTextGc(input) {
         const plan = checkpointEligible
             ? finalizePlan(input, marginal ?? stageAPlanWithProtectedCandidates)
             : undefined;
-        const retryAfterRollouts = Math.min(exec.retryAfterRollouts, codeMode.retryAfterRollouts, web.retryAfterRollouts);
+        const retryAfterRollouts = Math.min(exec.retryAfterRollouts, codeMode.retryAfterRollouts, web.retryAfterRollouts, tools.retryAfterRollouts);
         if (!plan && checkpointEligible)
             return {};
         return {
@@ -160,11 +160,19 @@ function inspectTextGc(input) {
     const exec = collectExecCandidates(input, groups, existingTargets, candidateSavings);
     const codeMode = collectCodeModeCandidates(input, groups, existingTargets, candidateSavings);
     const web = collectWebCandidates(input, groups, existingTargets, candidateSavings);
+    const tools = collectToolOutputCandidates(input, groups, existingTargets, candidateSavings);
     const protectedCandidateTokens = deterministicProtectedTokens +
         exec.protectedTokens +
         codeMode.protectedTokens +
-        web.protectedTokens;
-    const combined = evaluateCandidateSet(input, existing, [...deterministicCandidates, ...exec.eligible, ...codeMode.eligible, ...web.eligible], {
+        web.protectedTokens +
+        tools.protectedTokens;
+    const combined = evaluateCandidateSet(input, existing, [
+        ...deterministicCandidates,
+        ...exec.eligible,
+        ...codeMode.eligible,
+        ...web.eligible,
+        ...tools.eligible
+    ], {
         stage: 'STAGE_A_AND_EXEC',
         contextUsageTokens,
         usageRatio,
@@ -176,7 +184,7 @@ function inspectTextGc(input) {
         const plan = finalizePlan(input, combined);
         return plan ? { plan } : {};
     }
-    const retryAfterRollouts = Math.min(stageA.retryAfterRollouts, subagent.retryAfterRollouts, exec.retryAfterRollouts, codeMode.retryAfterRollouts, web.retryAfterRollouts);
+    const retryAfterRollouts = Math.min(stageA.retryAfterRollouts, exec.retryAfterRollouts, codeMode.retryAfterRollouts, web.retryAfterRollouts, tools.retryAfterRollouts);
     // A worthwhile mixed set retains every positive protected candidate's retry
     // hint even when the checkpoint interval prevents a durable draft.
     return protectedCandidateTokens > 0 &&

package/dist/runtime/context/projection.js

@@ -101,6 +101,7 @@ export function applyContextGcReplacementsToMessages(messages, messageSources, r
                 next = { ...next, arguments: structuredClone(replacement.replacementArguments) };
             else if ((replacement.kind === 'EXEC_OUTPUT' ||
                 replacement.kind === 'CODE_MODE_OUTPUT' ||
+                replacement.kind === 'TOOL_OUTPUT' ||
                 replacement.kind === 'SUBAGENT_OUTPUT' ||
                 replacement.kind === 'WEB_OUTPUT') &&
                 next.role === 'tool')

package/dist/runtime/events.d.ts

@@ -104,7 +104,7 @@ export type AgentEvent = AgentEventBase & ({
     summary: string;
     truncated?: boolean;
     artifacts?: readonly AgentToolArtifact[];
-    data?: CodeCellEventData | import('../tools/contracts.js').ExecResult | Omit<import('../tools/contracts.js').ExecResult, 'stdout' | 'stderr'> | import('../tools/contracts.js').ApplyPatchResult | import('../tools/contracts.js').ReadEventData | import('../tools/contracts.js').ViewImageResult | import('../subagent/contracts.js').SubagentTaskSnapshot | import('../subagent/contracts.js').SubagentManyOutput | import('../tools/contracts.js').SleepResult | import('./public-tool-metadata.js').PublicToolMetadata;
+    data?: CodeCellEventData | import('../tools/contracts.js').ExecResult | Omit<import('../tools/contracts.js').ExecResult, 'stdout' | 'stderr'> | import('../tools/contracts.js').ApplyPatchResult | import('../tools/contracts.js').ReadEventData | import('../tools/contracts.js').ViewImageResult | import('../tools/contracts.js').SleepResult | Readonly<Record<string, unknown>> | import('./public-tool-metadata.js').PublicToolMetadata;
 } | {
     type: 'tool.failed';
     resultExtensions?: readonly import('../tools/result-extension-contract.js').ToolResultExtension[];
@@ -156,8 +156,9 @@ export type AgentEvent = AgentEventBase & ({
     modelId?: string;
     modelName?: string;
     reasoningEffort?: AgentReasoningEffort;
-    latestMessage?: import('../subagent/contracts.js').SubagentLatestMessage;
-    latestActivity?: import('../subagent/contracts.js').SubagentLatestActivity;
+    /** Historical event fields retained for reading existing session records. */
+    latestMessage?: unknown;
+    latestActivity?: unknown;
     errorCode?: string;
     errorMessage?: string;
 } | {

package/dist/runtime/execution-handle.d.ts

@@ -3,6 +3,8 @@ import type { AgentEvent } from './events.js';
 /** A live execution exposes streamed events separately from its terminal result. */
 export interface ExecutionHandle extends AsyncIterable<AgentEvent> {
     readonly executionId: string;
+    /** Identity of the admitted Turn when the operation creates one. */
+    readonly turnId?: string;
     result(): Promise<ExecutionResult>;
     /** Signals abort; await result() to observe the terminal status and cleanup. */
     cancel(): void;

package/dist/runtime/wait.js

@@ -49,8 +49,18 @@ export function waitForToolCondition(input) {
         };
         const abort = () => finish('interrupted', input.signal?.reason ??
             new AgentError('MAR_AGENT_EXECUTION_CANCELLED', 'Execution cancelled.'));
-        unsubscribe = input.subscribe(check);
-        unsubscribeInterrupt = input.interrupt?.subscribe(check) ?? (() => { });
+        const releaseSubscription = input.subscribe(check);
+        if (settled) {
+            releaseSubscription();
+            return;
+        }
+        unsubscribe = releaseSubscription;
+        const releaseInterrupt = input.interrupt?.subscribe(check) ?? (() => { });
+        if (settled) {
+            releaseInterrupt();
+            return;
+        }
+        unsubscribeInterrupt = releaseInterrupt;
         cancelTimer = waitDeadline(input.waitMs, () => {
             check();
             finish('timeout');

package/dist/sdk/agent.js

@@ -13,6 +13,7 @@ import { toolCallers } from '../tools/callers.js';
 import { AnthropicMessagesAdapter } from '../model/anthropic-messages.js';
 import { OpenAiResponsesAdapter } from '../model/openai-responses.js';
 import { JsonlSessionStore } from '../session/store/jsonl/jsonl-store.js';
+import { createSessionCatalog } from '../session/catalog.js';
 /** Validate models before Host negotiation and expose only built-in protocol adapters. */
 export async function createAgent(options) {
     if (Object.hasOwn(options, 'adapterFactory'))
@@ -33,6 +34,7 @@ export async function createAgentWithAdapter(options, adapterFactory) {
         throw new AgentError('MAR_AGENT_SESSION_STORE_INVALID', 'Session store must not be null.');
     const ownsStore = options.sessionStore === undefined;
     const store = options.sessionStore ?? (await JsonlSessionStore.open(description.homeDirectory));
+    const historyCatalog = createSessionCatalog(store, true);
     // The same adapter can be borrowed concurrently by Execution and Extension operations.
     const activeExecutionAdapters = new Map();
     const activeAdapterReferences = {
@@ -50,6 +52,23 @@ export async function createAgentWithAdapter(options, adapterFactory) {
         }
     };
     const sessionRuntimes = new SessionRegistry();
+    const executionListeners = new Set();
+    const liveSession = (runtime) => ({
+        id: runtime.storedSession.id,
+        workspace: runtime.storedSession.workspace,
+        source: structuredClone(runtime.storedSession.source),
+        subscribe: (listener) => runtime.subscribe(listener)
+    });
+    const onExecutionRegistered = (runtime) => {
+        for (const listener of [...executionListeners]) {
+            try {
+                listener(liveSession(runtime));
+            }
+            catch {
+                /* Observers cannot affect execution admission. */
+            }
+        }
+    };
     const sessionWriterOwner = {};
     let disposed = false;
     let disposal;
@@ -86,7 +105,6 @@ export async function createAgentWithAdapter(options, adapterFactory) {
             'data.checkpoint',
             'data.store',
             'session',
-            'agents',
             'settings',
             ...(options.host.extensionPorts?.environment ? ['environment'] : []),
             ...(options.host.extensionPorts?.files ? ['files'] : []),
@@ -109,7 +127,6 @@ export async function createAgentWithAdapter(options, adapterFactory) {
                 agentRole: sessionRuntimes.get(call.sessionId)?.sourceType === 'subagent' ? 'subagent' : 'root'
             })),
         sessionBackend: (id) => sessionRuntimes.get(id)?.sessionBackend,
-        agentsBackend: (id) => sessionRuntimes.get(id)?.agentsBackend,
         scheduleTool: (id) => (definition, run) => {
             const schedule = sessionRuntimes.get(id)?.scheduleTool;
             if (!schedule)
@@ -180,7 +197,8 @@ export async function createAgentWithAdapter(options, adapterFactory) {
         agentResources: {
             activeExecutionAdapters: activeAdapterReferences,
             sessionRuntimes,
-            sessionWriterOwner
+            sessionWriterOwner,
+            onExecutionRegistered
         },
         hasCustomAdapters: adapterFactory !== undefined,
         modelState: () => ({ models, defaultModelId, generation: modelGeneration }),
@@ -197,9 +215,39 @@ export async function createAgentWithAdapter(options, adapterFactory) {
     });
     return {
         extensionDiagnostics: () => extensions.diagnostics(),
+        observeSessionExecutions: (listener) => {
+            assertSessionAdmission();
+            executionListeners.add(listener);
+            const sessions = [...sessionRuntimes.values()]
+                .filter((runtime) => runtime.activeExecutionId !== undefined)
+                .map(liveSession);
+            return {
+                sessions,
+                unsubscribe: () => {
+                    executionListeners.delete(listener);
+                }
+            };
+        },
         createSession: async (input) => {
             assertSessionAdmission();
-            return sessionRuntimes.trackOpen(undefined, async () => openSession((await store.createSession(input)).id, input.workspace));
+            if (input.source !== undefined &&
+                input.parentSessionId !== undefined &&
+                input.source.parentSessionId !== input.parentSessionId)
+                throw new AgentError('MAR_AGENT_SESSION_SOURCE_INVALID', 'Session source conflicts with its parent.');
+            return sessionRuntimes.trackOpen(undefined, async () => {
+                const created = await store.createSession({
+                    workspace: input.workspace,
+                    ...(input.title === undefined ? {} : { title: input.title }),
+                    ...(input.source !== undefined
+                        ? { source: input.source }
+                        : input.parentSessionId === undefined
+                            ? {}
+                            : {
+                                source: { type: 'user', parentSessionId: input.parentSessionId }
+                            })
+                });
+                return openSession(created.id, input.workspace);
+            });
         },
         openSession: (id) => openSession(id),
         listSessions: async (input) => {
@@ -210,6 +258,46 @@ export async function createAgentWithAdapter(options, adapterFactory) {
             assertSessionAdmission();
             return store.getSession(id);
         },
+        sessionHistory: async (id, input) => {
+            assertSessionAdmission(id);
+            return historyCatalog.history(id, input);
+        },
+        sessionInputReceipt: async (id, input) => {
+            assertSessionAdmission(id);
+            return historyCatalog.inputReceipt(id, input);
+        },
+        sessionExecutionWasInterrupted: async (id, executionId, input) => {
+            assertSessionAdmission(id);
+            input?.signal?.throwIfAborted();
+            // Maintenance admission excludes every writer without adopting pending resources.
+            const maintenance = await store.acquireSessionMaintenance(id, 'clear', sessionWriterOwner);
+            try {
+                input?.signal?.throwIfAborted();
+                if (sessionRuntimes.get(id)?.activeExecutionId !== undefined)
+                    return false;
+                let cursor;
+                do {
+                    const page = await historyCatalog.history(id, {
+                        limit: 100,
+                        ...(cursor === undefined ? {} : { cursor })
+                    });
+                    input?.signal?.throwIfAborted();
+                    const latest = page.entries
+                        .flatMap((entry) => (entry.kind === 'event' ? [entry.event] : []))
+                        .findLast((event) => event.type === 'execution.started' ||
+                        event.type === 'execution.completed' ||
+                        event.type === 'execution.failed' ||
+                        event.type === 'execution.cancelled');
+                    if (latest)
+                        return latest.type === 'execution.started' && latest.executionId === executionId;
+                    cursor = page.nextCursor;
+                } while (cursor);
+                return false;
+            }
+            finally {
+                await maintenance.release();
+            }
+        },
         setSessionTitle: async (id, title, input) => {
             assertSessionAdmission();
             return store.updateTitle(id, title, { ...input, automatic: input?.automatic ?? false }, sessionWriterOwner);
@@ -293,10 +381,12 @@ export async function createAgentWithAdapter(options, adapterFactory) {
             }
         },
         deleteSession: (id) => maintenanceCoordinator.delete(id),
+        deleteSessions: (ids) => maintenanceCoordinator.deleteMembers(ids),
         dispose: () => {
             if (disposal)
                 return disposal;
             disposed = true;
+            executionListeners.clear();
             for (const runtime of sessionRuntimes.values())
                 runtime.cancelExecutions();
             // Explicit end observers finish in a separate lifecycle frame before Session retirement.
@@ -307,7 +397,6 @@ export async function createAgentWithAdapter(options, adapterFactory) {
                 () => maintenanceCoordinator.join(),
                 () => extensions.dispose(),
                 ...runtimes.map((runtime) => () => runtime.retireInputs()),
-                ...runtimes.map((runtime) => () => runtime.disposeSubagents()),
                 () => Promise.all(runtimes.map((runtime) => runtime.joinExecutions())),
                 () => pendingReconfiguration,
                 () => SessionRuntime.closeModelAdapters(runtimes),

package/dist/sdk/execution-context-coordinator.d.ts

@@ -25,7 +25,6 @@ export declare class ExecutionContextCoordinator {
         readonly window: number;
         readonly gc: Pick<ContextGcRuntime, 'run'>;
         readonly gcBase: Omit<ContextGcRuntimeInput, 'system' | 'tools' | 'usage' | 'inlineMedia' | 'mediaView' | 'getActiveProcessIds'>;
-        readonly child: boolean;
         start(input?: {
             focus?: string;
             async?: boolean;
@@ -41,9 +40,9 @@ export declare class ExecutionContextCoordinator {
     advanceBoundary(): void;
     drainRequests(): boolean;
     prepareInputs(ports: {
-        includeSubagentUpdates: boolean;
+        includeSessionContext: boolean;
         appendMailbox(): Promise<unknown>;
-        appendSubagentUpdates(): Promise<void>;
+        appendSessionContext(): Promise<void>;
         refreshTools(): void;
         updateEnvironment(): void;
     }): Promise<void>;

package/dist/sdk/execution-context-coordinator.js

@@ -26,8 +26,8 @@ export class ExecutionContextCoordinator {
     }
     async prepareInputs(ports) {
         await ports.appendMailbox();
-        if (ports.includeSubagentUpdates)
-            await ports.appendSubagentUpdates();
+        if (ports.includeSessionContext)
+            await ports.appendSessionContext();
         ports.refreshTools();
         await this.ports.context.syncMcpWorldState(this.ports.messages.length);
         this.advanceBoundary();
@@ -80,7 +80,7 @@ export class ExecutionContextCoordinator {
                 this.ports.signal.throwIfAborted();
                 this.ports.execution.assertContextValid();
             });
-        if (!this.ports.compact.pending && !this.ports.child)
+        if (!this.ports.compact.pending)
             await this.gc(round, usage, await this.ports.resources.gcCandidate(), true);
     }
     async gc(round, usage, media, includeProcesses = false) {

package/dist/sdk/execution-input.d.ts

@@ -4,6 +4,7 @@ import type { SessionModelMessage as ModelMessage } from '../session/model-reque
 import { SessionInputCoordinator, type SessionInputEntry, type ExtensionSessionRequest, type ExtensionSessionActionResult } from '../extensions/session-input.js';
 import type { ExtensionPromptInput, ExtensionPromptResult } from '../extensions/prompt-input.js';
 import type { ExtensionOperationContext } from '../extensions/operation.js';
+import type { ExtensionSessionContextProvider } from '../extensions/session-context.js';
 import type { ResolvedModelConfiguration } from './model-runtime.js';
 import type { SmartCompactionInput } from '../runtime/compaction/smart.js';
 import type { CompactFlight } from '../runtime/compaction/coordinator.js';
@@ -11,7 +12,6 @@ import { type ResourcePublisher } from '../runtime/resource-publication.js';
 import type { createExecutionModelContext } from './execution-model-context.js';
 import type { InternalExecutionOptions } from './session-execution.js';
 import type { RunInput } from './types.js';
-import type { SubagentSessionController } from '../subagent/session-controller.js';
 /** Owns committed input, mailbox admission and live projection for one Execution. */
 export declare function createExecutionInput(input: {
     host: ResourcePublisher;
@@ -20,7 +20,6 @@ export declare function createExecutionInput(input: {
     executionId: string;
     turnId: string;
     mode: 'run' | 'plan' | 'compact';
-    source: 'user' | 'subagent';
     controller: AbortController;
     inputs: Pick<SessionInputCoordinator, 'drain' | 'boundarySize'>;
     messages: ModelMessage[];
@@ -52,7 +51,7 @@ export declare function createExecutionInput(input: {
         enqueue(content: ExtensionPromptInput, call: ExtensionOperationContext): Promise<unknown>;
         project(actual: ExtensionPromptInput, metadata: NonNullable<ModelMessage["metadata"]>): void;
     }) => Promise<boolean>;
-    receiveSteer: (content: ExtensionPromptInput, clientMessageId: string, call: ExtensionOperationContext) => Promise<SessionRecord>;
-    appendSubagentUpdates: (subagents: Pick<SubagentSessionController, "collectModelUpdates"> | undefined) => Promise<void>;
+    receiveSteer: (content: ExtensionPromptInput, clientMessageId: string, call: ExtensionOperationContext, source?: import("../extensions/session-input.js").ExtensionInputSource) => Promise<SessionRecord>;
+    appendExtensionContext: (provider: ExtensionSessionContextProvider | undefined) => Promise<void>;
     appendMailboxMessages: (restoring?: boolean) => Promise<boolean>;
 };

package/dist/sdk/execution-input.js

@@ -4,11 +4,9 @@ import { inputMetadataFromRecord } from '../session/record-projection.js';
 import { AGENT_EXECUTION_POLICY } from '../runtime/execution-policy.js';
 import { publishModelResources } from '../runtime/resource-publication.js';
 import { extensionInputSource } from './extension-session-launch.js';
-import { renderSubagentUpdate } from '../subagent/model-update.js';
 /** Owns committed input, mailbox admission and live projection for one Execution. */
 export function createExecutionInput(input) {
     const { host, store, sessionId, executionId, turnId, mode, controller, inputs, messages, pendingInputs, messageSources, modelContext, model, tokens, setSmartInput, withRecordProjection, appendExtensionMessage, startCompact, compactContext } = input;
-    const sessionSource = { type: input.source };
     const writeInputRecord = async (content, type, metadata, call, commitEvidence, projectCommitted) => {
         call.signal.throwIfAborted();
         if (content.images?.length && !model().inputCapabilities.includes('IMAGE'))
@@ -17,7 +15,6 @@ export function createExecutionInput(input) {
             call.signal.throwIfAborted();
             const smartPercent = tokens() === undefined ? undefined : (tokens() * 100) / model().contextWindowTokens;
             const smartCompaction = mode !== 'compact' &&
-                sessionSource.type === 'user' &&
                 type === 'turn.user' &&
                 metadata.inputSource === undefined &&
                 smartPercent !== undefined &&
@@ -64,6 +61,13 @@ export function createExecutionInput(input) {
             projectCommitted(actualContent, record.recordId, inputMetadata);
             for (const text of content.modelContext ?? content.context ?? [])
                 messages.push({ role: 'user', content: text, contextKind: 'contextual' });
+            if (metadata.clientMessageId)
+                await store.append(sessionId, {
+                    type: 'input.applied',
+                    payload: { inputRef: record.recordId },
+                    executionId,
+                    turnId
+                });
         });
     };
     const appendMailboxMessages = async (restoring = false) => inputs.drain(async (entry, request, call) => {
@@ -91,8 +95,7 @@ export function createExecutionInput(input) {
                 if (images.length && !model().inputCapabilities.includes('IMAGE'))
                     throw new AgentError('MAR_AGENT_INPUT_CAPABILITY_UNSUPPORTED', 'Selected model does not support image input.');
                 const percent = tokens() === undefined ? undefined : (tokens() * 100) / model().contextWindowTokens;
-                const eligible = sessionSource.type === 'user' &&
-                    percent !== undefined &&
+                const eligible = percent !== undefined &&
                     percent >= AGENT_EXECUTION_POLICY.smartCompactionPercent &&
                     percent < AGENT_EXECUTION_POLICY.automaticCompactionPercent;
                 const actual = {
@@ -135,7 +138,6 @@ export function createExecutionInput(input) {
                 return outcome;
             });
         }
-        const parent = entry.parentMessage;
         let outcome;
         const content = {
             text: request.input.text,
@@ -146,15 +148,9 @@ export function createExecutionInput(input) {
                 : { modelContext: request.input.modelContext }),
             ...(request.input.images === undefined ? {} : { images: request.input.images })
         };
-        await writeInputRecord(content, parent && !parent.delivery?.origin ? 'turn.user' : 'extension.input', parent && !parent.delivery?.origin
-            ? {
-                inputSource: 'parent_agent',
-                ...(parent.delivery ? { messageId: parent.delivery.messageId } : {})
-            }
-            : {
-                source: extensionInputSource(call, request.input.provenance, request.input.modelAttribution),
-                ...(parent?.delivery ? { messageId: parent.delivery.messageId } : {})
-            }, call, (recordId) => {
+        await writeInputRecord(content, 'extension.input', {
+            source: extensionInputSource(call, request.input.provenance, request.input.modelAttribution)
+        }, call, (recordId) => {
             outcome = { changed: true, executionId, recordId };
             recordSessionInputCommit(entry, outcome);
         }, (actual, recordId, metadata) => {
@@ -168,7 +164,6 @@ export function createExecutionInput(input) {
                     }
                     : {})
             });
-            parent?.delivery?.applied();
         });
         return outcome;
     }, {
@@ -195,7 +190,6 @@ export function createExecutionInput(input) {
             const { internal, input: request } = ports;
             await writeInputRecord(content, internal.inputSource === 'extension' ? 'extension.input' : 'turn.user', {
                 ...(internal.extensionSource ? { source: internal.extensionSource } : {}),
-                ...(internal.delivery ? { messageId: internal.delivery.messageId } : {}),
                 ...(internal.inputSource === undefined ? {} : { inputSource: internal.inputSource }),
                 ...(request.clientMessageId ? { clientMessageId: request.clientMessageId } : {})
             }, call, (recordId) => {
@@ -203,7 +197,6 @@ export function createExecutionInput(input) {
                 internal.inputCommitted?.(recordId);
             }, (actual, _recordId, metadata) => {
                 ports.project(actual, metadata);
-                internal.delivery?.applied();
             });
             return {};
         };
@@ -218,7 +211,7 @@ export function createExecutionInput(input) {
         await ports.operation((call) => internal.promptAdmitted ? write(content, call) : ports.admit(content, call, write));
         return entered;
     };
-    const receiveSteer = (content, clientMessageId, call) => withRecordProjection(async () => {
+    const receiveSteer = (content, clientMessageId, call, source) => withRecordProjection(async () => {
         call.signal.throwIfAborted();
         if (content.images?.length && !model().inputCapabilities.includes('IMAGE'))
             throw new AgentError('MAR_AGENT_INPUT_CAPABILITY_UNSUPPORTED', 'Selected model does not support image input.');
@@ -234,6 +227,7 @@ export function createExecutionInput(input) {
                 ...(content.modelText === undefined ? {} : { modelText: content.modelText }),
                 ...(content.context === undefined ? {} : { context: content.context }),
                 ...(content.modelContext === undefined ? {} : { modelContext: content.modelContext }),
+                ...(source === undefined ? {} : { source }),
                 clientMessageId,
                 ...(images.length ? { images } : {})
             },
@@ -243,24 +237,36 @@ export function createExecutionInput(input) {
         pendingInputs.set(record.recordId, record);
         return record;
     });
-    const appendSubagentUpdates = async (subagents) => {
-        if (!subagents)
+    const appendExtensionContext = async (provider) => {
+        if (!provider)
             return;
         await withRecordProjection(async () => {
             controller.signal.throwIfAborted();
-            for (const update of subagents.collectModelUpdates()) {
+            const proposed = await provider.collect(controller.signal);
+            controller.signal.throwIfAborted();
+            if (!Array.isArray(proposed))
+                throw new AgentError('MAR_AGENT_EXTENSION_CONTEXT_INVALID', 'Invalid context batch.');
+            const batch = proposed.slice(0, 8);
+            for (const item of batch) {
+                if (typeof item?.content !== 'string' ||
+                    item.content.length === 0 ||
+                    Buffer.byteLength(item.content, 'utf8') > 32_768 ||
+                    typeof item.acknowledge !== 'function')
+                    throw new AgentError('MAR_AGENT_EXTENSION_CONTEXT_INVALID', 'Invalid context item.');
+            }
+            for (const item of batch) {
                 controller.signal.throwIfAborted();
                 const message = {
                     role: 'user',
-                    content: renderSubagentUpdate(update.snapshot, update.truncated),
+                    content: item.content,
                     contextKind: 'contextual'
                 };
                 const stored = await store.append(sessionId, { type: 'model.context', payload: message, executionId, turnId }, { signal: controller.signal });
                 messages.push(message);
                 messageSources.set(message, stored);
-                update.acknowledge();
+                item.acknowledge();
             }
         });
     };
-    return { startInitialInput, receiveSteer, appendSubagentUpdates, appendMailboxMessages };
+    return { startInitialInput, receiveSteer, appendExtensionContext, appendMailboxMessages };
 }

package/dist/sdk/execution-round-preparation.d.ts

@@ -1,6 +1,6 @@
 /** Owns round retries when late input or resource collection invalidates a candidate. */
 export declare function createExecutionRoundPreparer<Continuation, Candidate, Round>(ports: {
-    prepareInputs(includeSubagentUpdates: boolean): Promise<void>;
+    prepareInputs(includeSessionContext: boolean): Promise<void>;
     buildCandidate(continuation: Continuation | undefined): Promise<Candidate>;
     adoptLateInput(): Promise<boolean>;
     prepareResources(candidate: Candidate): Promise<{