@myagentroam/agent 0.11.14 → 0.11.15

package/dist/agent-core/host/contracts.d.ts

@@ -7,7 +7,7 @@ import type { CoreEnvironmentBackend } from '../extensions/environment.js';
 import type { CoreOperationContext } from '../extensions/operation.js';
 import type { CoreToolRef } from '../extensions/tools.js';
 export declare const MAR_AGENT_HOST_API_VERSION = "1.0";
-export type MarAgentHostCapability = 'workspace.read' | 'workspace.patch' | 'process.manage' | 'code.execute' | 'user-input.request' | 'event.publish' | 'session.store' | 'mcp.tools' | 'image.read';
+export type MarAgentHostCapability = 'workspace.read' | 'workspace.patch' | 'process.manage' | 'code.execute' | 'user-input.request' | 'event.publish';
 export interface HostDescription {
     apiVersion: string;
     mode: 'normal' | 'node';
@@ -51,7 +51,7 @@ export interface HostSessionResourceSnapshot {
         cwd: string;
     }[];
 }
-/** The Host owns workspace/tool effects; the SDK owns JSONL storage beneath its supplied HOME. */
+/** The Host owns workspace/tool effects; SessionStore is injected or defaults to SDK-owned JSONL. */
 export interface MarAgentHost {
     /** Independent model consumption facts, including child and auxiliary calls. */
     modelUsage?: import('../model/usage-observer.js').ModelUsageObserver | undefined;

package/dist/agent-core/host/contracts.js

@@ -5,8 +5,7 @@ const requiredCapabilities = [
     'workspace.patch',
     'process.manage',
     'user-input.request',
-    'event.publish',
-    'session.store'
+    'event.publish'
 ];
 export function negotiateHost(description) {
     const match = /^(\d+)\.(\d+)$/.exec(description.apiVersion);

package/dist/agent-core/host/local-agent-host.js

@@ -103,8 +103,7 @@ export class LocalAgentHost {
                 'process.manage',
                 'code.execute',
                 'user-input.request',
-                'event.publish',
-                'session.store'
+                'event.publish'
             ],
             limits: {
                 maxProcesses: TOOL_EXECUTION_LIMITS.maxProcesses,

package/dist/agent-core/runtime/compaction/requests.d.ts

@@ -1,4 +1,4 @@
-import type { CompactInput, ExecutionHandle } from '../../sdk/types.js';
+import type { CompactInput, ExecutionHandle } from '../execution-handle.js';
 import type { MarAgentEvent } from '../events.js';
 import type { CompactFlight } from './coordinator.js';
 /** External handles represent an operation inside its owning main Execution, not another loop. */

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

@@ -100,13 +100,16 @@ async function attemptContextGc(input) {
         records =
             input.records ?? (await input.store.readExecutionState(input.sessionId)).contextRecords;
         const checkpointCache = new ContextGcCheckpointCache();
-        const previous = checkpointCache.read(records, undefined, input.workspace);
+        const previous = checkpointCache.read(records);
         if (previous) {
             deferred = {
                 ...deferred,
                 checkpointTrigger: previous.payload.trigger,
                 protectedCandidatesPending: previous.payload.metrics.protectedCandidateTokens > 0
             };
+        }
+        if (previous?.payload.trigger.modelId === input.modelId &&
+            previous.payload.trigger.contextWindowTokens === input.contextWindowTokens) {
             const rolloutGrowth = records.filter((record) => record.sequence > previous.record.sequence &&
                 record.type === 'model.attempt' &&
                 isRecord(record.payload) &&
@@ -120,7 +123,7 @@ async function attemptContextGc(input) {
                     contextGcMinimumUsageGrowth(input.contextWindowTokens))
                 return deferred;
         }
-        const projection = buildContextProjection(records, input.workspace, checkpointCache);
+        const projection = buildContextProjection(records, checkpointCache);
         const inspection = inspectContextGc({
             records,
             checkpointCache,
@@ -159,14 +162,14 @@ async function attemptContextGc(input) {
         const committed = await input.store.commitContextGc(input.sessionId, draft, records);
         return {
             ...deferred,
-            result: await matchingCheckpointWasPersisted(input.store, input.sessionId, draft, input.workspace, records, committed)
+            result: await matchingCheckpointWasPersisted(input.store, input.sessionId, draft, records, committed)
         };
     }
     catch (commitError) {
         try {
             return {
                 ...deferred,
-                result: await matchingCheckpointWasPersisted(input.store, input.sessionId, draft, input.workspace, records)
+                result: await matchingCheckpointWasPersisted(input.store, input.sessionId, draft, records)
             };
         }
         catch {
@@ -176,7 +179,7 @@ async function attemptContextGc(input) {
         return deferred;
     }
 }
-async function matchingCheckpointWasPersisted(store, sessionId, draft, workspace, records, committed) {
+async function matchingCheckpointWasPersisted(store, sessionId, draft, records, committed) {
     const record = committed ??
         (await store.readPage(sessionId, {
             limit: 1,
@@ -185,7 +188,7 @@ async function matchingCheckpointWasPersisted(store, sessionId, draft, workspace
     if (record?.sequence !== draft.boundarySequence + 1 || record.type !== 'context.gc.completed')
         return false;
     const updatedRecords = [...records, record];
-    const projection = buildContextProjection(updatedRecords, workspace);
+    const projection = buildContextProjection(updatedRecords);
     if (committed)
         return { records: updatedRecords, projection };
     const payload = projection.checkpoint;

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

@@ -1,5 +1,5 @@
 import { codeCallEvidence, codePartialPatchCallEvidence, codeObservationEvidence, retainedCodeInputs } from '../../session/context-gc-observations.js';
-import { ContextGcCheckpointCache, contextGcBaseFromRecords, contextGcLogicalPathKey, contextGcMinimumUsageGrowth, contextGcTargetKey, normalizeContextGcReplacements } from '../../session/context-gc-checkpoint.js';
+import { ContextGcCheckpointCache, contextGcBaseFromRecords, contextGcCheckpointIntervalEligible, contextGcLogicalPathKey, contextGcMinimumUsageGrowth, contextGcTargetKey, normalizeContextGcReplacements } from '../../session/context-gc-checkpoint.js';
 import { codeCellCompletionSequence, contextGcApplyPatchInputReplacement, contextGcCodeModeInputReplacement, contextGcCodeModeOutputReplacement, contextGcExecInputReplacement, contextGcExecOutputReplacement, contextGcPatchResultFromCompletedPayload, contextGcPatchResultFromFailedPayload, contextGcStaleReadReplacement, contextGcWebOutputReplacement, normalizeContextGcCodeModeInput, normalizeContextGcExecResult } from '../../session/context-gc-replacements.js';
 import { contextGcSubagentNeedsRetainedPriorFinal, contextGcSubagentOutputReplacement, contextGcSubagentPriorFinalIsRetained, contextGcSubagentSnapshotIsPreciselyCovered, contextGcSubagentSnapshotIsSuperseded, contextGcSubagentSnapshotTurnId, normalizeContextGcSubagentSnapshot } from '../../session/context-gc-subagent.js';
 import { parseReadContextOutput } from '../../tools/local/read-context.js';
@@ -131,15 +131,25 @@ export function inspectContextGc(input) {
     if (!usageRecord)
         return {};
     const normalRolloutOrdinal = countSuccessfulNormalRollouts(input.records, input.modelId, input.contextWindowTokens);
-    const previous = input.checkpointCache.read(input.records, undefined, input.workspace);
-    if (previous) {
-        const minimumUsageGrowth = contextGcMinimumUsageGrowth(input.contextWindowTokens);
-        const protectedCandidatesPending = previous.payload.metrics.protectedCandidateTokens > 0;
+    const previous = input.checkpointCache.read(input.records);
+    const checkpointEligible = contextGcCheckpointIntervalEligible({
+        usageSequence: usageRecord.sequence,
+        contextInputTokens: contextUsageTokens,
+        contextWindowTokens: input.contextWindowTokens,
+        normalRolloutOrdinal,
+        modelId: input.modelId,
+        platform: input.platform
+    }, previous?.payload.trigger);
+    // Discovery and economic evaluation have their own low-growth opportunities;
+    // neither a protected candidate nor periodic discovery makes a draft eligible.
+    if (previous?.payload.trigger.modelId === input.modelId &&
+        previous.payload.trigger.contextWindowTokens === input.contextWindowTokens) {
         const rolloutGrowth = normalRolloutOrdinal - previous.payload.trigger.normalRolloutOrdinal;
         if (rolloutGrowth < 2 ||
-            (!protectedCandidatesPending &&
+            (previous.payload.metrics.protectedCandidateTokens === 0 &&
                 rolloutGrowth < CONTEXT_GC_POLICY.largeExecProtectionRollouts &&
-                contextUsageTokens - previous.payload.trigger.contextInputTokens < minimumUsageGrowth))
+                contextUsageTokens - previous.payload.trigger.contextInputTokens <
+                    contextGcMinimumUsageGrowth(input.contextWindowTokens)))
             return {};
     }
     if (input.messages.length !== input.messageSources.length)
@@ -188,41 +198,45 @@ export function inspectContextGc(input) {
             normalRolloutOrdinal,
             protectedCandidateTokens
         });
-        const plan = finalizePlan(input, marginal ?? stageAPlanWithProtectedCandidates);
+        const plan = checkpointEligible
+            ? finalizePlan(input, marginal ?? stageAPlanWithProtectedCandidates)
+            : undefined;
         const retryAfterRollouts = Math.min(exec.retryAfterRollouts, codeMode.retryAfterRollouts, web.retryAfterRollouts);
-        return plan
-            ? {
-                plan,
-                ...(protectedCandidateTokens > 0 && Number.isFinite(retryAfterRollouts)
-                    ? { retryAfterRollouts }
-                    : {})
-            }
-            : {};
+        if (!plan && checkpointEligible)
+            return {};
+        return {
+            ...(plan ? { plan } : {}),
+            ...(protectedCandidateTokens > 0 && Number.isFinite(retryAfterRollouts)
+                ? { retryAfterRollouts }
+                : {})
+        };
     }
     const exec = collectExecCandidates(input, groups, existingTargets, candidateSavings);
     const codeMode = collectCodeModeCandidates(input, groups, existingTargets, candidateSavings);
     const web = collectWebCandidates(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], {
         stage: 'STAGE_A_AND_EXEC',
         contextUsageTokens,
         usageRatio,
         usageRecord,
         normalRolloutOrdinal,
-        protectedCandidateTokens: deterministicProtectedTokens +
-            exec.protectedTokens +
-            codeMode.protectedTokens +
-            web.protectedTokens
+        protectedCandidateTokens
     });
-    if (combined?.economics.passes) {
+    if (combined?.economics.passes && checkpointEligible) {
         const plan = finalizePlan(input, combined);
         return plan ? { plan } : {};
     }
     const retryAfterRollouts = Math.min(stageA.retryAfterRollouts, subagent.retryAfterRollouts, exec.retryAfterRollouts, codeMode.retryAfterRollouts, web.retryAfterRollouts);
-    return deterministicProtectedTokens +
-        exec.protectedTokens +
-        codeMode.protectedTokens +
-        web.protectedTokens >=
-        contextGcMinimumReclaimedTokens(contextUsageTokens, input.contextWindowTokens) &&
+    // A worthwhile mixed set retains every positive protected candidate's retry
+    // hint even when the checkpoint interval prevents a durable draft.
+    return protectedCandidateTokens > 0 &&
+        (combined?.economics.passes ||
+            protectedCandidateTokens >=
+                contextGcMinimumReclaimedTokens(contextUsageTokens, input.contextWindowTokens)) &&
         Number.isFinite(retryAfterRollouts)
         ? { retryAfterRollouts }
         : {};
@@ -459,7 +473,7 @@ function evaluateCandidateSet(input, existing, candidates, state) {
     if (reclaimedTokens === 0)
         return undefined;
     const cache = contextGcCacheImpact(input, input.messages, projected.messages, input.usage.cacheReadTokens ?? 0, reclaimedTokens);
-    const growthSamples = collectContextGrowthSamples(input.records, input.modelId, input.contextWindowTokens, input.workspace, input.checkpointCache);
+    const growthSamples = collectContextGrowthSamples(input.records, input.modelId, input.contextWindowTokens, input.checkpointCache);
     const contextGrowthP75Tokens = percentile75(growthSamples);
     const compactThresholdTokens = Math.floor(input.contextWindowTokens * COMPACT_THRESHOLD_RATIO);
     // Usage describes the request before its generated output and tool results.
@@ -1098,8 +1112,8 @@ function latestUsageRecord(records, selectedModelId) {
     }
     return latest;
 }
-function collectContextGrowthSamples(records, modelId, contextWindowTokens, workspace, checkpointCache) {
-    const previous = checkpointCache.read(records, undefined, workspace);
+function collectContextGrowthSamples(records, modelId, contextWindowTokens, checkpointCache) {
+    const previous = checkpointCache.read(records);
     const base = contextGcBaseFromRecords(records);
     const startSequence = previous?.record.sequence ?? (base?.type === 'COMPACT' ? base.sequence : base?.firstSequence);
     let activeModelId = modelId;

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

@@ -9,7 +9,7 @@ export interface ContextProjection {
     readonly entries: readonly ContextProjectionEntry[];
     readonly checkpoint?: ContextGcCheckpointPayload;
 }
-export declare function buildContextProjection(records: readonly SessionRecord[], workspace?: string, checkpointCache?: ContextGcCheckpointCache): ContextProjection;
+export declare function buildContextProjection(records: readonly SessionRecord[], checkpointCache?: ContextGcCheckpointCache): ContextProjection;
 export declare function applyContextGcReplacementsToMessages(messages: readonly ModelMessage[], messageSources: readonly SessionRecord[], replacements: readonly ContextGcReplacement[]): {
     readonly messages: ModelMessage[];
     readonly messageSources: SessionRecord[];

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

@@ -6,7 +6,7 @@ import { TOOL_EXECUTION_LIMITS } from '../../tools/execution-limits.js';
 import { replaceReadContextItems } from '../../tools/local/read-context.js';
 import { parseCodeCalls, parseObservations, renderObservationResult } from '../../tools/code-mode/observations.js';
 const MAX_MODEL_CONTEXT_BYTES = 1024 * 1024;
-export function buildContextProjection(records, workspace, checkpointCache) {
+export function buildContextProjection(records, checkpointCache) {
     let activeModelId;
     const rawEntries = [];
     for (const record of records) {
@@ -33,8 +33,8 @@ export function buildContextProjection(records, workspace, checkpointCache) {
             rawEntries.push({ record, message });
     }
     const valid = checkpointCache
-        ? checkpointCache.read(records, undefined, workspace)
-        : latestValidContextGcCheckpoint(records, undefined, workspace);
+        ? checkpointCache.read(records)
+        : latestValidContextGcCheckpoint(records);
     const messages = rawEntries.flatMap((entry) => (entry.message ? [entry.message] : []));
     const sources = rawEntries.flatMap((entry) => (entry.message ? [entry.record] : []));
     const applied = applyContextGcReplacementsToMessages(messages, sources, valid?.payload.replacements ?? []);

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

@@ -9,8 +9,7 @@ export async function restoreMessages(store, sessionId, records, options) {
     const messages = [];
     const outcomes = new Map();
     const toolOutcomes = new WeakMap();
-    const modelProjection = new Map((options.projection ??
-        buildContextProjection(records, (await store.getSession(sessionId)).workspace)).entries.map((entry) => [entry.record.recordId, entry.message]));
+    const modelProjection = new Map((options.projection ?? buildContextProjection(records)).entries.map((entry) => [entry.record.recordId, entry.message]));
     let userMessages = [];
     let ignoredImages = 0;
     let currentTurnUserIndex;

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

@@ -0,0 +1,12 @@
+import type { ExecutionResult, RunInput } from './contracts.js';
+import type { MarAgentEvent } from './events.js';
+/** A live execution exposes streamed events separately from its terminal result. */
+export interface ExecutionHandle extends AsyncIterable<MarAgentEvent> {
+    readonly executionId: string;
+    result(): Promise<ExecutionResult>;
+    /** Signals abort; await result() to observe the terminal status and cleanup. */
+    cancel(): void;
+}
+export type CompactInput = Partial<RunInput> & {
+    readonly async?: boolean;
+};

package/dist/agent-core/runtime/execution-handle.js

@@ -0,0 +1 @@
+export {};

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

@@ -223,29 +223,46 @@ export async function createMarAgentWithAdapter(options) {
             const runtime = sessionRuntimes.get(id);
             if ([...active.keys()].some((key) => key.startsWith(`${id}:`)))
                 throw new MarAgentError('MAR_AGENT_EXECUTION_ACTIVE', 'A session cannot be cleared while an execution is active.');
-            await extensions.endSession(id, 'clear');
-            extensions.retireSession(id);
-            await completeAgentCleanup([
-                () => extensions.clearSession(id),
-                () => runtime?.inputs?.retire(),
-                () => runtime?.subagents?.dispose(),
-                () => closeModelAdapters(runtime === undefined ? [] : [...runtime.adapters.values()]),
-                () => {
-                    // Existing SDK Session handles share this runtime and remain usable after clear.
-                    if (runtime) {
-                        runtime.adapters.clear();
-                        runtime.adapterGeneration = modelGeneration;
-                        delete runtime.todo;
-                        delete runtime.subagents;
-                        delete runtime.subagentsOpening;
-                        delete runtime.contextualWorldState;
-                        delete runtime.inputs;
-                        delete runtime.requestSnapshots;
-                    }
-                },
-                () => options.host.disposeSessionResources?.(id),
-                () => store.clearSession(id)
-            ]);
+            const maintenance = await store.acquireSessionMaintenance(id, 'clear', sessionWriterOwner);
+            let failed = false;
+            try {
+                await completeAgentCleanup([
+                    () => extensions.endSession(id, 'clear'),
+                    () => extensions.retireSession(id),
+                    () => extensions.clearSession(id),
+                    () => runtime?.inputs?.retire(),
+                    () => runtime?.subagents?.dispose(),
+                    () => closeModelAdapters(runtime === undefined ? [] : [...runtime.adapters.values()]),
+                    () => {
+                        // Existing SDK Session handles share this runtime and remain usable after clear.
+                        if (runtime) {
+                            runtime.adapters.clear();
+                            runtime.adapterGeneration = modelGeneration;
+                            delete runtime.todo;
+                            delete runtime.subagents;
+                            delete runtime.subagentsOpening;
+                            delete runtime.contextualWorldState;
+                            delete runtime.inputs;
+                            delete runtime.requestSnapshots;
+                        }
+                    },
+                    () => options.host.disposeSessionResources?.(id),
+                    () => store.clearSession(id, maintenance)
+                ]);
+            }
+            catch (error) {
+                failed = true;
+                throw error;
+            }
+            finally {
+                try {
+                    await maintenance.release();
+                }
+                catch (error) {
+                    if (!failed)
+                        throw error;
+                }
+            }
         }),
         setSystemInstruction: (systemInstruction) => {
             if (disposed)
@@ -333,31 +350,62 @@ export async function createMarAgentWithAdapter(options) {
             }
         },
         deleteSession: (id) => trackSessionLifecycle(id, 'delete', async () => {
-            const sessionIds = await store.sessionTree(id);
-            const sessionIdSet = new Set(sessionIds);
-            const executionKeys = [...active.keys()].filter((key) => sessionIdSet.has(key.slice(0, key.indexOf(':'))));
-            for (const key of executionKeys)
-                active.get(key)?.abort();
-            await Promise.all(sessionIds.map((sessionId) => extensions.endSession(sessionId, 'other', false)));
-            for (const sessionId of sessionIds)
-                extensions.retireSession(sessionId);
-            const runtimes = sessionIds.flatMap((sessionId) => {
-                const runtime = sessionRuntimes.get(sessionId);
-                sessionRuntimes.delete(sessionId);
-                return runtime === undefined ? [] : [runtime];
-            });
-            await completeAgentCleanup([
-                ...sessionIds.map((sessionId) => () => extensions.clearSession(sessionId)),
-                ...runtimes.map((runtime) => () => runtime.inputs?.retire()),
-                ...runtimes.map((runtime) => () => runtime.subagents?.dispose()),
-                () => Promise.allSettled(executionKeys.flatMap((key) => {
-                    const result = executionResults.get(key);
-                    return result === undefined ? [] : [result];
-                })),
-                () => closeModelAdapters(runtimes.flatMap((runtime) => [...runtime.adapters.values()])),
-                ...sessionIds.map((sessionId) => () => options.host.disposeSessionResources?.(sessionId)),
-                () => store.delete(id)
-            ]);
+            const maintenance = await store.acquireSessionMaintenance(id, 'delete', sessionWriterOwner);
+            let failed = false;
+            try {
+                const sessionIds = maintenance.sessionIds;
+                const sessionIdSet = new Set(sessionIds);
+                const executionKeys = [...active.keys()].filter((key) => sessionIdSet.has(key.slice(0, key.indexOf(':'))));
+                for (const key of executionKeys)
+                    active.get(key)?.abort();
+                const runtimes = sessionIds.flatMap((sessionId) => {
+                    const runtime = sessionRuntimes.get(sessionId);
+                    return runtime === undefined ? [] : [runtime];
+                });
+                await completeAgentCleanup([
+                    async () => {
+                        let failure;
+                        await Promise.all(sessionIds.map(async (sessionId) => {
+                            try {
+                                await extensions.endSession(sessionId, 'other', false);
+                            }
+                            catch (error) {
+                                failure ??= { error };
+                            }
+                        }));
+                        if (failure)
+                            throw failure.error;
+                    },
+                    ...sessionIds.map((sessionId) => () => extensions.retireSession(sessionId)),
+                    () => {
+                        for (const sessionId of sessionIds)
+                            sessionRuntimes.delete(sessionId);
+                    },
+                    ...sessionIds.map((sessionId) => () => extensions.clearSession(sessionId)),
+                    ...runtimes.map((runtime) => () => runtime.inputs?.retire()),
+                    ...runtimes.map((runtime) => () => runtime.subagents?.dispose()),
+                    () => Promise.allSettled(executionKeys.flatMap((key) => {
+                        const result = executionResults.get(key);
+                        return result === undefined ? [] : [result];
+                    })),
+                    () => closeModelAdapters(runtimes.flatMap((runtime) => [...runtime.adapters.values()])),
+                    ...sessionIds.map((sessionId) => () => options.host.disposeSessionResources?.(sessionId)),
+                    () => store.delete(id, maintenance)
+                ]);
+            }
+            catch (error) {
+                failed = true;
+                throw error;
+            }
+            finally {
+                try {
+                    await maintenance.release();
+                }
+                catch (error) {
+                    if (!failed)
+                        throw error;
+                }
+            }
         }),
         dispose: () => {
             if (disposal)

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

@@ -1,8 +1,8 @@
 import type { MarAgentHost } from '../host/contracts.js';
 import type { CoreExtensionSource, CoreRuntimeExtension } from '../extensions/contracts.js';
 import type { MarAgentModelConfiguration } from '../model/configuration.js';
-import type { ExecutionResult, RolloutBudgetOptions, RunInput } from '../runtime/contracts.js';
-import type { MarAgentEvent } from '../runtime/events.js';
+import type { RolloutBudgetOptions, RunInput } from '../runtime/contracts.js';
+import type { CompactInput, ExecutionHandle } from '../runtime/execution-handle.js';
 import type { MarAgentSessionPage, MarAgentSessionSummary } from '../session/catalog.js';
 import type { SessionListInput, SessionSource, SessionTitleUpdateInput } from '../session/types.js';
 export interface CreateSessionInput {
@@ -13,17 +13,8 @@ export type { SessionTitleUpdateInput } from '../session/types.js';
 export type { HostExecutionExtensions, HostSessionResourceSnapshot, HostSkill, MarAgentHost } from '../host/contracts.js';
 export type { AccessMode, ExecutionMode, ExecutionResult, MarAgentImageMetadata, RolloutBudgetOptions, RunInput, RunInputImage } from '../runtime/contracts.js';
 export type { MarAgentEvent, MarAgentEventBase } from '../runtime/events.js';
+export type { CompactInput, ExecutionHandle } from '../runtime/execution-handle.js';
 export type { CodeCellEventData, MarAgentToolArtifact, MarAgentToolImageArtifact, McpCatalogTool, McpToolCallContext, McpToolCatalog, McpToolCatalogContext, ToolCall, ToolExecutionContext, ToolExecutionResult } from '../tools/contracts.js';
-/** A live execution exposes streamed events separately from its terminal result. */
-export interface ExecutionHandle extends AsyncIterable<MarAgentEvent> {
-    readonly executionId: string;
-    result(): Promise<ExecutionResult>;
-    /** Signals abort; await result() to observe the terminal status and cleanup. */
-    cancel(): void;
-}
-export type CompactInput = Partial<RunInput> & {
-    readonly async?: boolean;
-};
 export interface SteerInput {
     readonly expectedExecutionId: string;
     readonly prompt: string;

package/dist/agent-core/session/context-gc-checkpoint.d.ts

@@ -143,9 +143,11 @@ export interface ContextGcCheckpointPayload extends ContextGcCheckpointDraft {
 /** Disposable memoization for one evaluation's immutable record snapshot. */
 export declare class ContextGcCheckpointCache {
     #private;
-    read(records: readonly SessionRecord[], boundarySequence?: number, workspace?: string): ReturnType<typeof latestValidContextGcCheckpoint>;
+    read(records: readonly SessionRecord[], boundarySequence?: number): ReturnType<typeof latestValidContextGcCheckpoint>;
 }
 export declare function contextGcMinimumUsageGrowth(contextWindowTokens: number): number;
+/** Compare adjacent checkpoint triggers only within the same model/window scope. */
+export declare function contextGcCheckpointIntervalEligible(trigger: ContextGcCheckpointDraft['trigger'], previous?: ContextGcCheckpointDraft['trigger']): boolean;
 export declare function contextGcLogicalPathKey(path: string, workspace: string, platform?: ContextGcPlatform): string | undefined;
 export declare function contextGcTargetKey(target: ContextGcTarget): string;
 export declare function contextGcReplacementKey(replacement: ContextGcReplacement): string;
@@ -154,7 +156,7 @@ export declare function contextGcBaseSequence(base: ContextGcBase): number;
 export declare function normalizeContextGcReplacements(replacements: readonly ContextGcReplacement[]): ContextGcReplacement[] | undefined;
 export declare function parseContextGcCheckpoint(record: SessionRecord | undefined): ContextGcCheckpointPayload | undefined;
 export declare function validateContextGcCheckpoint(records: readonly SessionRecord[], record: SessionRecord, workspace?: string | undefined, committedReplacements?: readonly ContextGcReplacement[]): ContextGcCheckpointPayload | undefined;
-export declare function latestValidContextGcCheckpoint(records: readonly SessionRecord[], boundarySequence?: number, _workspace?: string): {
+export declare function latestValidContextGcCheckpoint(records: readonly SessionRecord[], boundarySequence?: number): {
     readonly record: SessionRecord;
     readonly payload: ContextGcCheckpointPayload;
 } | undefined;

package/dist/agent-core/session/context-gc-checkpoint.js

@@ -9,20 +9,28 @@ export const CONTEXT_GC_MAX_TARGETS = 4_096;
 /** Disposable memoization for one evaluation's immutable record snapshot. */
 export class ContextGcCheckpointCache {
     #snapshot;
-    read(records, boundarySequence = records.at(-1)?.sequence ?? 0, workspace) {
+    read(records, boundarySequence = records.at(-1)?.sequence ?? 0) {
         const cached = this.#snapshot;
-        if (cached?.records === records &&
-            cached.boundarySequence === boundarySequence &&
-            cached.workspace === workspace)
+        if (cached?.records === records && cached.boundarySequence === boundarySequence)
             return cached.value;
-        const value = latestValidContextGcCheckpoint(records, boundarySequence, workspace);
-        this.#snapshot = { records, boundarySequence, workspace, value };
+        const value = latestValidContextGcCheckpoint(records, boundarySequence);
+        this.#snapshot = { records, boundarySequence, value };
         return value;
     }
 }
 export function contextGcMinimumUsageGrowth(contextWindowTokens) {
     return Math.max(2_000, Math.floor(contextWindowTokens * 0.05));
 }
+/** Compare adjacent checkpoint triggers only within the same model/window scope. */
+export function contextGcCheckpointIntervalEligible(trigger, previous) {
+    if (!previous ||
+        trigger.modelId !== previous.modelId ||
+        trigger.contextWindowTokens !== previous.contextWindowTokens)
+        return true;
+    return (trigger.normalRolloutOrdinal - previous.normalRolloutOrdinal >= 2 &&
+        trigger.contextInputTokens - previous.contextInputTokens >=
+            contextGcMinimumUsageGrowth(trigger.contextWindowTokens));
+}
 export function contextGcLogicalPathKey(path, workspace, platform) {
     if (!path || !workspace || path.includes('\0') || workspace.includes('\0'))
         return undefined;
@@ -198,7 +206,7 @@ export function validateContextGcCheckpoint(records, record, workspace = session
     }
     return payload;
 }
-export function latestValidContextGcCheckpoint(records, boundarySequence = records.at(-1)?.sequence ?? 0, _workspace) {
+export function latestValidContextGcCheckpoint(records, boundarySequence = records.at(-1)?.sequence ?? 0) {
     const base = contextGcBaseFromRecords(records, boundarySequence);
     if (!base)
         return undefined;

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

@@ -49,6 +49,12 @@ export interface SessionStoreCompactInput {
     executionId?: string;
     turnId?: string;
 }
+/** Store-issued ownership spanning SDK cleanup and the final durable mutation. */
+export interface SessionStoreMaintenance {
+    readonly sessionIds: readonly string[];
+    /** Idempotent; releases maintenance only, never another owner's Execution/retained references. */
+    release(): Promise<void>;
+}
 /**
  * Session persistence port. Implementations preserve record order, committed-resource
  * visibility and the existing per-Session writer/checkpoint atomic boundaries.
@@ -124,6 +130,8 @@ export interface SessionStore {
     /** Retention requires the originating owner to hold an active Execution lease. */
     retainSessionLease(sessionId: string, owner: object): Promise<() => Promise<void>>;
     hasRetainedSessionLease(sessionId: string, owner: object): boolean;
+    /** Conflicts fail before cleanup; delete includes the Store's current Session tree. */
+    acquireSessionMaintenance(sessionId: string, kind: 'clear' | 'delete', owner?: object): Promise<SessionStoreMaintenance>;
     forkSession(sessionId: string, input: {
         readonly boundaryTurnId: string | null;
         readonly title: string;
@@ -131,8 +139,8 @@ export interface SessionStore {
     rollbackSession(sessionId: string, input: {
         readonly boundaryTurnId: string | null;
     }): Promise<MarAgentSessionSummary>;
-    clearSession(sessionId: string): Promise<MarAgentSessionSummary>;
-    delete(sessionId: string): Promise<{
+    clearSession(sessionId: string, maintenance?: SessionStoreMaintenance): Promise<MarAgentSessionSummary>;
+    delete(sessionId: string, maintenance?: SessionStoreMaintenance): Promise<{
         readonly deleted: boolean;
     }>;
     /** Stop using the handle and release its leases before closing it. Never preempts other owners. */

package/dist/agent-core/session/store/execution-state.js

@@ -1,5 +1,4 @@
 import { todoItemsFromSnapshot } from '../../tools/agent/todo.js';
-import { contextGcBaseSequence, latestValidContextGcCheckpoint } from '../context-gc-checkpoint.js';
 export function deriveExecutionState(records) {
     let automaticTitle = false;
     let sawUserTurn = false;
@@ -36,7 +35,6 @@ export function deriveExecutionState(records) {
             executionModel = candidate;
     }
     const boundary = records.findLastIndex(isCompactCheckpoint);
-    const checkpoint = latestValidContextGcCheckpoint(records);
     return {
         automaticTitlePending: automaticTitle && !sawUserTurn,
         todo: { revision: todoRevision, items: todoItems },
@@ -45,13 +43,6 @@ export function deriveExecutionState(records) {
             version: 1,
             userTurns,
             ...(compactSequence === undefined ? {} : { compactSequence }),
-            ...(checkpoint === undefined
-                ? {}
-                : {
-                    gcSequence: checkpoint.record.sequence,
-                    gcGeneration: checkpoint.payload.generation,
-                    gcBaseSequence: contextGcBaseSequence(checkpoint.payload.base)
-                }),
             ...(todoSequence === undefined ? {} : { todoSequence }),
             todoRevision,
             executionModelIndexed: true,
@@ -170,9 +161,6 @@ export function sameResumeIndex(left, right) {
     return (left?.version === right.version &&
         left.userTurns === right.userTurns &&
         left.compactSequence === right.compactSequence &&
-        left.gcSequence === right.gcSequence &&
-        left.gcGeneration === right.gcGeneration &&
-        left.gcBaseSequence === right.gcBaseSequence &&
         left.todoSequence === right.todoSequence &&
         left.todoRevision === right.todoRevision &&
         left.executionModelIndexed === right.executionModelIndexed &&

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

@@ -1,4 +1,4 @@
-import type { SessionStore, SessionRecordInput, SessionStoreCompactInput } from './contracts.js';
+import type { SessionStore, SessionStoreMaintenance, SessionRecordInput, SessionStoreCompactInput } from './contracts.js';
 import { type CoreCheckpoint, type CoreJsonValue } from '../../extensions/data.js';
 import { type CodeModeStateEntry } from '../../tools/code-mode/state.js';
 import { type ContextGcCheckpointDraft } from '../context-gc-checkpoint.js';
@@ -10,7 +10,6 @@ export declare class JsonlSessionStore implements SessionStore {
     #private;
     private constructor();
     static open(home: string): Promise<JsonlSessionStore>;
-    /** Append the durable creation record before making this Session visible in the index. */
     createSession(input: {
         title?: string;
         workspace: string;
@@ -57,7 +56,7 @@ export declare class JsonlSessionStore implements SessionStore {
     }>;
     updateTitle(sessionId: string, title: string, input?: SessionTitleUpdateInput, owner?: object): Promise<boolean>;
     /** Reset history with the same recovery journal while preserving the Session identity. */
-    clearSession(sessionId: string): Promise<{
+    clearSession(sessionId: string, maintenance?: SessionStoreMaintenance): Promise<{
         id: string;
         title: string;
         workspace: string;
@@ -108,6 +107,7 @@ export declare class JsonlSessionStore implements SessionStore {
     /** A warm cell retains physical writer ownership between Executions of the same Agent. */
     acquireSessionLease(sessionId: string, owner?: object): Promise<() => Promise<void>>;
     hasRetainedSessionLease(sessionId: string, owner: object): boolean;
+    acquireSessionMaintenance(sessionId: string, kind: 'clear' | 'delete', owner?: object): Promise<SessionStoreMaintenance>;
     /** Native writes join their Agent's sole writer, without admitting another Execution. */
     acquireSessionWriteLease(sessionId: string, owner: object): Promise<() => Promise<void>>;
     retainSessionLease(sessionId: string, owner: object): Promise<() => Promise<void>>;
@@ -156,7 +156,7 @@ export declare class JsonlSessionStore implements SessionStore {
     /** Counts native input records, not the post-Compact model context. */
     userTurnCount(sessionId: string): Promise<number>;
     firstUserMessagePreview(sessionId: string): Promise<string | undefined>;
-    delete(sessionId: string): Promise<{
+    delete(sessionId: string, maintenance?: SessionStoreMaintenance): Promise<{
         readonly deleted: boolean;
     }>;
     close(): Promise<void>;

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

@@ -7,7 +7,7 @@ import { cloneCoreJson } from '../../extensions/data.js';
 import { acquireFileLock } from '../../storage/file-lock.js';
 import { todoItemsFromSnapshot } from '../../tools/agent/todo.js';
 import { applyCodeModeStateMutations, parseCodeModeStateMutations, restoreCodeModeState } from '../../tools/code-mode/state.js';
-import { contextGcBaseFromRecords, contextGcBaseSequence, contextGcMinimumUsageGrowth, latestValidContextGcCheckpoint, normalizeContextGcReplacements, parseContextGcCheckpoint, sameContextGcBase, validateContextGcCheckpoint } from '../context-gc-checkpoint.js';
+import { contextGcBaseFromRecords, contextGcCheckpointIntervalEligible, latestValidContextGcCheckpoint, normalizeContextGcReplacements, sameContextGcBase, validateContextGcCheckpoint } from '../context-gc-checkpoint.js';
 import { bindToolResultResources, cleanupUnreferencedToolResources, completeToolResultResources, copyToolResultResources, readToolResultResource, toolResultResourceFiles, writeToolResultResource } from '../tool-result-resources.js';
 import { beginSessionStorageTransaction, isUnjournaledTransactionFile, recoverSessionStorageTransaction } from '../transaction-recovery.js';
 import { extensionCheckpointFromPayload, indexExtensionCheckpoint, restoreExtensionCheckpoint, updateSessionCurrentState } from './current-state.js';
@@ -23,6 +23,7 @@ export class JsonlSessionStore {
     static #instances = new Map();
     static #opening = new Map();
     #shared;
+    #maintenance = new WeakMap();
     #leaseClosed = false;
     constructor(shared) {
         this.#shared = shared;
@@ -283,9 +284,22 @@ export class JsonlSessionStore {
         }
         return { directory, release };
     }
-    /** Append the durable creation record before making this Session visible in the index. */
     async createSession(input) {
         this.#assertOpen();
+        const source = normalizeSessionSource(input.source);
+        if (source.type !== 'subagent')
+            return this.#createSession(input, source);
+        // Publish under the parent's existing serial domain so tree admission cannot miss a child.
+        return this.#serializeRecordOperation(source.parentSessionId, async () => {
+            this.#assertOpen();
+            if (this.#shared.writerLeases.get(source.parentSessionId)?.maintenance)
+                throw new MarAgentError('MAR_AGENT_SESSION_LOCKED', 'Session is under maintenance.');
+            await this.getSession(source.parentSessionId);
+            return this.#createSession(input, source);
+        });
+    }
+    /** Append the durable creation record before making this Session visible in the index. */
+    async #createSession(input, source) {
         const id = randomUUID();
         const now = new Date().toISOString();
         const meta = {
@@ -294,7 +308,7 @@ export class JsonlSessionStore {
             workspace: input.workspace,
             createdAt: now,
             lastActivityAt: now,
-            source: normalizeSessionSource(input.source),
+            source,
             nextSequence: 1,
             automaticTitlePending: input.title === undefined,
             resume: {
@@ -697,9 +711,11 @@ export class JsonlSessionStore {
         }
     }
     /** Reset history with the same recovery journal while preserving the Session identity. */
-    async clearSession(sessionId) {
+    async clearSession(sessionId, maintenance) {
         this.#assertOpen();
-        const release = await this.acquireSessionLease(sessionId);
+        const holding = maintenance ?? (await this.acquireSessionMaintenance(sessionId, 'clear'));
+        this.#assertMaintenance(sessionId, 'clear', holding);
+        let failed = false;
         try {
             const meta = this.#shared.index.sessions.find((item) => item.id === sessionId);
             if (!meta)
@@ -726,8 +742,18 @@ export class JsonlSessionStore {
             ];
             return await this.#replaceHistory(meta, retained, { kind: 'clear', clearedAt });
         }
+        catch (error) {
+            failed = true;
+            throw error;
+        }
         finally {
-            await release();
+            if (!maintenance) {
+                const releasing = holding.release();
+                if (failed)
+                    await releasing.catch(() => undefined);
+                else
+                    await releasing;
+            }
         }
     }
     /** Called only while rollback or clear holds the maintenance lease. */
@@ -1123,14 +1149,9 @@ export class JsonlSessionStore {
                 records.at(-1)?.sessionId !== sessionId ||
                 !sameContextGcBase(contextGcBaseFromRecords(records, boundarySequence), draft.base))
                 throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Context GC planning boundary is invalid.');
-            const previous = latestValidContextGcCheckpoint(records, boundarySequence, meta.workspace);
-            if (previous) {
-                const minimumUsageGrowth = contextGcMinimumUsageGrowth(draft.trigger.contextWindowTokens);
-                if (draft.trigger.normalRolloutOrdinal - previous.payload.trigger.normalRolloutOrdinal < 2 ||
-                    draft.trigger.contextInputTokens - previous.payload.trigger.contextInputTokens <
-                        minimumUsageGrowth)
-                    throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Context GC checkpoint interval validation failed.');
-            }
+            const previous = latestValidContextGcCheckpoint(records, boundarySequence);
+            if (!contextGcCheckpointIntervalEligible(draft.trigger, previous?.payload.trigger))
+                throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Context GC checkpoint interval validation failed.');
             const plannedReplacements = normalizeContextGcReplacements(draft.replacements);
             if (!plannedReplacements || plannedReplacements.length === 0)
                 throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Context GC checkpoint must contain a replacement.');
@@ -1236,7 +1257,7 @@ export class JsonlSessionStore {
             this.#assertOpen();
             let lease = this.#shared.writerLeases.get(sessionId);
             if (lease) {
-                if (lease.executing || owner === undefined || lease.owner !== owner)
+                if (lease.maintenance || lease.executing || owner === undefined || lease.owner !== owner)
                     throw new MarAgentError('MAR_AGENT_SESSION_LOCKED', 'Session already has a writer.');
                 if (lease.appendFailure)
                     throw lease.appendFailure.error;
@@ -1262,12 +1283,89 @@ export class JsonlSessionStore {
         const lease = this.#shared.writerLeases.get(sessionId);
         return lease?.owner === owner && lease.retained > 0;
     }
+    async acquireSessionMaintenance(sessionId, kind, owner) {
+        this.#assertOpen();
+        const acquired = new Map();
+        let sessionIds = [];
+        let released = false;
+        const holding = Object.freeze({
+            get sessionIds() {
+                return sessionIds;
+            },
+            release: async () => {
+                if (released)
+                    return;
+                released = true;
+                this.#maintenance.delete(holding);
+                let failure;
+                for (const [id, writer] of [...acquired].reverse()) {
+                    try {
+                        await this.#serializeRecordOperation(id, async () => {
+                            delete writer.maintenance;
+                            await this.#releaseUnusedWriter(id, writer);
+                        });
+                    }
+                    catch (error) {
+                        failure ??= { error };
+                    }
+                }
+                if (failure)
+                    throw failure.error;
+            }
+        });
+        try {
+            // Re-read membership after acquiring writers; never hand the SDK a pre-lock tree snapshot.
+            for (;;) {
+                const tree = kind === 'delete' ? await this.sessionTree(sessionId) : [sessionId];
+                for (const id of tree.toReversed()) {
+                    if (acquired.has(id))
+                        continue;
+                    await this.#serializeRecordOperation(id, async () => {
+                        this.#assertOpen();
+                        let writer = this.#shared.writerLeases.get(id);
+                        if (writer &&
+                            (writer.maintenance ||
+                                owner === undefined ||
+                                writer.owner !== owner ||
+                                (kind === 'clear' && writer.executing)))
+                            throw new MarAgentError('MAR_AGENT_SESSION_LOCKED', 'Session already has a writer.');
+                        if (!writer) {
+                            // Deleting a stale index entry must not recreate its missing directory.
+                            const release = kind === 'delete' && !(await sessionDirectoryExists(this.#sessionDirectory(id)))
+                                ? async () => { }
+                                : await this.#acquireSessionLease(id);
+                            writer = { owner, executing: false, retained: 0, release };
+                            this.#shared.writerLeases.set(id, writer);
+                        }
+                        writer.maintenance = holding;
+                        acquired.set(id, writer);
+                    });
+                }
+                const current = kind === 'clear' ? tree : await this.sessionTree(sessionId);
+                if (current.every((id) => acquired.has(id))) {
+                    sessionIds = Object.freeze(current);
+                    break;
+                }
+            }
+            this.#maintenance.set(holding, { sessionId, kind });
+            return holding;
+        }
+        catch (error) {
+            await holding.release().catch(() => undefined);
+            throw error;
+        }
+    }
+    #assertMaintenance(sessionId, kind, holding) {
+        const current = this.#maintenance.get(holding);
+        if (current?.sessionId !== sessionId || current.kind !== kind)
+            throw new MarAgentError('MAR_AGENT_SESSION_LOCKED', 'Session maintenance ownership is invalid.');
+    }
     /** Native writes join their Agent's sole writer, without admitting another Execution. */
     async acquireSessionWriteLease(sessionId, owner) {
         return this.#serializeRecordOperation(sessionId, async () => {
             this.#assertOpen();
             let lease = this.#shared.writerLeases.get(sessionId);
-            if (lease && lease.owner !== owner)
+            if (lease && (lease.maintenance || lease.owner !== owner))
                 throw new MarAgentError('MAR_AGENT_SESSION_LOCKED', 'Session already has a writer.');
             if (lease?.appendFailure)
                 throw lease.appendFailure.error;
@@ -1291,7 +1389,7 @@ export class JsonlSessionStore {
     async retainSessionLease(sessionId, owner) {
         return this.#serializeRecordOperation(sessionId, async () => {
             const lease = this.#shared.writerLeases.get(sessionId);
-            if (!lease || !lease.executing || lease.owner !== owner)
+            if (!lease || lease.maintenance || !lease.executing || lease.owner !== owner)
                 throw new MarAgentError('MAR_AGENT_SESSION_LOCKED', 'Retained work requires its originating Session writer.');
             lease.retained++;
             let released = false;
@@ -1305,7 +1403,7 @@ export class JsonlSessionStore {
         });
     }
     async #releaseUnusedWriter(sessionId, lease) {
-        if (lease.executing || lease.retained)
+        if (lease.maintenance || lease.executing || lease.retained)
             return;
         try {
             await lease.release();
@@ -1472,20 +1570,8 @@ export class JsonlSessionStore {
             else
                 resume.reasoningEffort = executionModel.reasoningEffort;
         }
-        if (isCompactCheckpoint(record)) {
+        if (isCompactCheckpoint(record))
             resume.compactSequence = record.sequence;
-            delete resume.gcSequence;
-            delete resume.gcGeneration;
-            delete resume.gcBaseSequence;
-        }
-        else {
-            const checkpoint = parseContextGcCheckpoint(record);
-            if (checkpoint) {
-                resume.gcSequence = record.sequence;
-                resume.gcGeneration = checkpoint.generation;
-                resume.gcBaseSequence = contextGcBaseSequence(checkpoint.base);
-            }
-        }
         if (record.type !== 'todo.updated' || !todoItemsFromSnapshot(record.payload))
             return;
         resume.todoSequence = record.sequence;
@@ -1723,22 +1809,12 @@ export class JsonlSessionStore {
             throw error;
         }
     }
-    async delete(sessionId) {
+    async delete(sessionId, maintenance) {
         this.#assertOpen();
-        await this.#refreshIndex();
-        const tree = sessionTreeIds(this.#shared.index.sessions, sessionId);
-        if (tree.length === 0)
-            throw new MarAgentError('MAR_AGENT_SESSION_NOT_FOUND', 'Session was not found.');
-        const releases = [];
-        try {
-            for (const id of tree.toReversed())
-                if (await sessionDirectoryExists(join(this.#shared.root, 'sessions', id)))
-                    releases.push(await this.acquireSessionLease(id));
-        }
-        catch (error) {
-            await Promise.allSettled(releases.toReversed().map((release) => release()));
-            throw error;
-        }
+        const holding = maintenance ?? (await this.acquireSessionMaintenance(sessionId, 'delete'));
+        this.#assertMaintenance(sessionId, 'delete', holding);
+        const tree = holding.sessionIds;
+        let failed = false;
         try {
             const deleted = await sessionDirectoryExists(join(this.#shared.root, 'sessions', sessionId));
             for (const id of tree.toReversed()) {
@@ -1751,8 +1827,18 @@ export class JsonlSessionStore {
             await this.#saveIndex(tree);
             return { deleted };
         }
+        catch (error) {
+            failed = true;
+            throw error;
+        }
         finally {
-            await Promise.allSettled(releases.toReversed().map((release) => release()));
+            if (!maintenance) {
+                const releasing = holding.release();
+                if (failed)
+                    await releasing.catch(() => undefined);
+                else
+                    await releasing;
+            }
         }
     }
     #assertOpen() {

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

@@ -58,9 +58,6 @@ export interface SessionMeta {
         version: 1;
         userTurns?: number;
         compactSequence?: number;
-        gcSequence?: number;
-        gcGeneration?: number;
-        gcBaseSequence?: number;
         todoSequence?: number;
         todoRevision: number;
         executionModelIndexed?: true;

package/dist/index.d.ts

@@ -41,7 +41,7 @@ export type { CoreProcessesApi, CoreProcessesBackend, CoreProcessInput, CoreProc
 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 { SessionStore, SessionStoreSession, SessionRecordInput, SessionStoreCompactInput, SessionRecord, SessionExecutionState, CompactHistoryMessage, CompactUserInput, SessionInputImage, SessionInputImageMetadata, SessionInputImageData, RestoredSessionInputImage, CodeModeStateEntry, TodoSnapshot, TodoItem, CodeToolCallRecord, CodeObservation, ModelMessage, ModelUsage, ModelInputMetadata, ModelTextBlock, ModelContextualBlock, EnvironmentContextState, ContextGcCheckpointDraft, ContextGcBase, ContextGcPlatform, ContextGcEconomicsPolicy, ContextGcMetrics, ContextGcReplacement, ContextGcTarget, ContextGcReadItemReplacement, ContextGcWebToolName, ContextGcSubagentToolName, AvailableToolResultResource } from './agent-core/session/store/contracts.js';
+export type { SessionStore, SessionStoreMaintenance, SessionStoreSession, SessionRecordInput, SessionStoreCompactInput, SessionRecord, SessionExecutionState, CompactHistoryMessage, CompactUserInput, SessionInputImage, SessionInputImageMetadata, SessionInputImageData, RestoredSessionInputImage, CodeModeStateEntry, TodoSnapshot, TodoItem, CodeToolCallRecord, CodeObservation, ModelMessage, ModelUsage, ModelInputMetadata, ModelTextBlock, ModelContextualBlock, EnvironmentContextState, ContextGcCheckpointDraft, ContextGcBase, ContextGcPlatform, ContextGcEconomicsPolicy, ContextGcMetrics, ContextGcReplacement, ContextGcTarget, ContextGcReadItemReplacement, ContextGcWebToolName, ContextGcSubagentToolName, AvailableToolResultResource } from './agent-core/session/store/contracts.js';
 export type { OpenMarAgentSessionCatalogInput } from './agent-core/session/catalog.js';
 export type { ApplyPatchFileResult, ApplyPatchResult, ApplyPatchPartialResult, ClientToolDefinition, MarAgentToolArtifact, MarAgentToolImageArtifact, McpCatalogTool, McpToolCallContext, McpToolCatalog, McpToolCatalogContext, ToolCall, ToolCaller, ToolExecutionContext, ToolExecutionResult } from './agent-core/tools/contracts.js';
 export { MCP_DEFINITION_LIMITS, assertMcpToolCatalog, assertMcpToolDefinition } from './agent-core/tools/mcp/catalog.js';

package/package.json

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