@myagentroam/agent 0.11.13 → 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/compaction/retained-context.js

@@ -1,4 +1,4 @@
-import { parseModelInputMetadata } from '../../session/store/index.js';
+import { parseModelInputMetadata } from '../../session/store/execution-state.js';
 import { restoreModelContext } from '../context/projection.js';
 /** Use a public native identity, never private context text, as the visible boundary. */
 export function compactSnapshotAnchor(messages, sources) {

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

@@ -1,5 +1,5 @@
 import type { ModelMessage } from '../../model/contracts.js';
-import { type SessionRecord } from '../../session/store/index.js';
+import type { SessionRecord } from '../../session/store/contracts.js';
 export declare const SMART_COMPACTION_MARKER = "<mar_runtime>\n  <smart_compaction>For this message only, smart_compact may be considered at a clear transition into sustained new work, when the previous phase is largely complete and its details have low continuation value.</smart_compaction>\n</mar_runtime>";
 export interface SmartCompactionInput {
     readonly recordId: string;

package/dist/agent-core/runtime/compaction/smart.js

@@ -1,5 +1,5 @@
 import { MarAgentError } from '../../error.js';
-import { compactSummaryFromCheckpoint } from '../../session/store/index.js';
+import { compactSummaryFromCheckpoint } from '../../session/store/execution-state.js';
 export const SMART_COMPACTION_MARKER = '<mar_runtime>\n  <smart_compaction>For this message only, smart_compact may be considered at a clear transition into sustained new work, when the previous phase is largely complete and its details have low continuation value.</smart_compaction>\n</mar_runtime>';
 /** A measured watermark, not the stricter native-request budget calibration. */
 export function latestSmartContextTokens(records, modelId, contextWindowTokens) {

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

@@ -1,9 +1,9 @@
 import type { ClientToolDefinition, ModelUsage } from '../../model/contracts.js';
 import { type ContextGcPlatform } from '../../session/context-gc-checkpoint.js';
-import { JsonlSessionStore, type SessionRecord } from '../../session/store/index.js';
+import type { SessionStore, SessionRecord } from '../../session/store/contracts.js';
 import { type ContextProjection } from './projection.js';
 export interface ContextGcRuntimeInput {
-    readonly store: JsonlSessionStore;
+    readonly store: SessionStore;
     readonly sessionId: string;
     readonly records?: readonly SessionRecord[];
     readonly system: string;

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

@@ -1,12 +1,12 @@
 import { restoreNativeModelContext } from '../../model/native-context.js';
 import { appliedInputRecord } from '../../session/deferred-input.js';
-import { inputMetadataFromRecord } from '../../session/store/index.js';
+import { inputMetadataFromRecord } from '../../session/store/execution-state.js';
 import { contextGcTargetKey, latestValidContextGcCheckpoint } from '../../session/context-gc-checkpoint.js';
 import { TOOL_EXECUTION_LIMITS } from '../../tools/execution-limits.js';
 import { replaceReadContextItems } from '../../tools/local/read-context.js';
 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.d.ts

@@ -1,8 +1,9 @@
+import type { SessionStore } from '../../session/store/contracts.js';
 import type { ModelMessage } from '../../model/contracts.js';
-import { type CompactUserInput, type JsonlSessionStore } from '../../session/store/index.js';
+import type { CompactUserInput } from '../../session/store/contracts.js';
 import type { EnvironmentContextState } from './contracts.js';
 import { type ContextProjection } from './projection.js';
-export declare function restoreMessages(store: JsonlSessionStore, sessionId: string, records: readonly import('../../session/store/index.js').SessionRecord[], options: {
+export declare function restoreMessages(store: SessionStore, sessionId: string, records: readonly import('../../session/store/index.js').SessionRecord[], options: {
     includeImages: boolean;
     strictImages?: boolean;
     currentTurnId?: string;

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

@@ -1,6 +1,6 @@
 import { MarAgentError } from '../../error.js';
 import { appliedInputRecord, pendingDeferredInputs } from '../../session/deferred-input.js';
-import { compactSummaryFromCheckpoint, replacementHistoryFromCheckpoint, inputMetadataFromRecord } from '../../session/store/index.js';
+import { compactSummaryFromCheckpoint, replacementHistoryFromCheckpoint, inputMetadataFromRecord } from '../../session/store/execution-state.js';
 import { compactedHistoryMessages, continuationMessage } from '../compaction/history.js';
 import { restoreCompactTail } from '../compaction/retained-context.js';
 import { environmentContextUpdate, restoreEnvironmentState } from './environment.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/context/usage.js

@@ -1,6 +1,6 @@
 import { isDeepStrictEqual } from 'node:util';
 import { marAgentReasoningEffortSchema } from '../../model/configuration.js';
-import { compactSummaryFromCheckpoint } from '../../session/store/index.js';
+import { compactSummaryFromCheckpoint } from '../../session/store/execution-state.js';
 import { estimatedRequestTokens } from './request-budget.js';
 export function latestModelUsage(records, selectedModelId) {
     let usage;

package/dist/agent-core/runtime/context/world-state.d.ts

@@ -19,7 +19,7 @@ export declare function insertContextualWorldState(messages: readonly ModelMessa
 export declare function latestContextualWorldStateGeneration(records: readonly import('../../session/store/index.js').SessionRecord[]): string | undefined;
 export declare function updatePromptWorldState(state: ContextualWorldState, index: number, parts: readonly ContextualPart[]): ContextualWorldState;
 export declare function parsePersistedContextualWorldState(payload: unknown): ContextualWorldState | undefined;
-export declare function persistContextualWorldState(store: import('../../session/store/index.js').JsonlSessionStore, sessionId: string, state: ContextualWorldState): Promise<void>;
+export declare function persistContextualWorldState(store: import('../../session/store/contracts.js').SessionStore, sessionId: string, state: ContextualWorldState): Promise<void>;
 export declare function updateContextualWorldState(state: ContextualWorldState, index: number, current: {
     instructionSnapshot: string | undefined;
     instructionContent: string | undefined;

package/dist/agent-core/runtime/context/world-state.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { MarAgentError } from '../../error.js';
 import { contextualBlock, contextualChanges } from './contextual-blocks.js';
-import { compactSummaryFromCheckpoint } from '../../session/store/index.js';
+import { compactSummaryFromCheckpoint } from '../../session/store/execution-state.js';
 export function insertContextualWorldState(messages, entries) {
     const result = [...messages];
     // Entries can be restored before the latest user after Compact. Sort anchors,

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 {};