@myagentroam/agent 0.11.39 → 0.11.41

package/dist/sdk/session.js

@@ -2,21 +2,15 @@ import { createExtensionSessionLaunch, extensionInputSource } from './extension-
 import { createSessionExecutionFactory } from './session-execution-factory.js';
 import { createSessionExtensionMessages } from './session-extension-messages.js';
 import { createSessionExtensionPrompt } from './session-extension-prompt.js';
-import { createSubagentBackend } from './subagent-backend.js';
 import { AgentError } from '../error.js';
 import { SessionInputCoordinator, recordSessionInputCommit } from '../extensions/session-input.js';
 import { buildSystemPromptSections } from '../prompts/index.js';
 import { childSubagentInstruction } from '../prompts/subagent.js';
 import { DEFAULT_COMPACTION_FOCUS } from '../runtime/compaction/history.js';
 import { restoreEnvironmentState } from '../runtime/context/environment.js';
-import { SubagentSessionController } from '../subagent/session-controller.js';
 import { allowsDirectTool } from '../tools/callers.js';
-import { createExtensionAgentsBackend } from './extension-agents.js';
 import { createExtensionSessionBackend } from './extension-session.js';
 import { createSessionOpen } from './session-open.js';
-function restoreSubagentOrigin(origin) {
-    return { ...origin.correlation, signal: origin.signal };
-}
 /** SDK Session orchestration owns warm resources; Runtime owns only the model/tool loop. */
 export function createSessionOpener(services) {
     const { host, description, settings, store, createAdapter, activeAdaptersExcept } = services;
@@ -27,11 +21,7 @@ export function createSessionOpener(services) {
         generation: () => services.modelState().generation,
         createAdapter,
         hasCustomAdapters: services.hasCustomAdapters,
-        openSubagents: (id, workspace) => SubagentSessionController.open({
-            parentSessionId: id,
-            rootSessionId: id,
-            backend: createSubagentBackend(store, workspace)
-        }),
+        onExecutionRegistered: services.agentResources.onExecutionRegistered,
         assertAdmission: services.assertSessionAdmission,
         epoch: services.openEpoch,
         canPublish: services.canPublishSession,
@@ -149,8 +139,7 @@ export function createSessionOpener(services) {
             refreshSessionAdapters,
             sessionInputs,
             withRecordProjection,
-            appendExtensionMessage,
-            startSubagentTurn: async (id, input) => (await openSession(id)).startSubagentTurn(input)
+            appendExtensionMessage
         });
         sessionRuntime.ensureSessionBackend(() => createExtensionSessionBackend({
             describe: async (call) => {
@@ -200,70 +189,32 @@ export function createSessionOpener(services) {
             messages: createSessionExtensionMessages({
                 sessionId,
                 store,
-                agents: () => sessionRuntime.agentsBackend,
                 runtime: (id) => sessionRuntimes.get(id),
                 models: () => services.modelState()
             }),
-            launch: createExtensionSessionLaunch(sessionSource.type, execution),
+            launch: createExtensionSessionLaunch(execution),
             diagnose: (code, operationId) => services.extensions.session(sessionId)?.diagnose({ code, operationId, sessionId })
         }));
-        if (sessionSource.type === 'user')
-            sessionRuntime.ensureAgentsBackend(() => createExtensionAgentsBackend({
-                existingController: () => sessionRuntime.subagents,
-                controller: async () => {
-                    // Access to managed children is not a new Execution admission for their parent.
-                    services.assertCanStart();
-                    if (sessionRuntime.subagents === undefined)
-                        await openSession(sessionId);
-                    if (!sessionRuntime.subagents)
-                        throw new AgentError('MAR_AGENT_SUBAGENT_FAILED', 'Session task controller is unavailable.');
-                    return sessionRuntime.subagents;
-                },
-                parent: (controller, call) => {
-                    const current = call.executionId === undefined
-                        ? undefined
-                        : controller.parentExecution(call.executionId);
-                    if (call.executionId !== undefined && !current)
-                        throw new AgentError('MAR_AGENT_SUBAGENT_FAILED', 'Parent Execution source is unavailable.');
-                    const state = services.modelState();
-                    const selected = state.models.get(state.defaultModelId);
-                    return {
-                        ...(current ?? {
-                            modelId: selected.id,
-                            reasoningEffort: selected.defaultReasoningEffort,
-                            models: state.models,
-                            emitTerminal: async () => { },
-                            startTurn: async (turn) => {
-                                const child = await openSession(turn.sessionId);
-                                return child.startSubagentTurn({
-                                    prompt: turn.prompt,
-                                    modelId: turn.modelId,
-                                    reasoningEffort: turn.reasoningEffort,
-                                    role: turn.role,
-                                    initialMailbox: turn.initialMailbox,
-                                    turnId: turn.turnId,
-                                    ...(turn.origin === undefined
-                                        ? {}
-                                        : { origin: restoreSubagentOrigin(turn.origin) }),
-                                    ...(turn.delivery === undefined ? {} : { delivery: turn.delivery })
-                                });
-                            }
-                        }),
-                        operationId: call.operationId,
-                        origin: { signal: call.signal, correlation: call },
-                        signal: call.signal,
-                        ...(call.ownerInstanceId === undefined
-                            ? {}
-                            : { ownerInstanceId: call.ownerInstanceId }),
-                        ...(call.extensionId === undefined ? {} : { extensionId: call.extensionId })
-                    };
-                }
-            }));
+        const inputSource = () => {
+            const current = services.extensions.operations.current();
+            return current && current.sessionId !== sessionId && current.extensionId
+                ? extensionInputSource(current)
+                : undefined;
+        };
+        const inputOptions = () => {
+            const source = inputSource();
+            return source ? { extensionSource: source } : {};
+        };
         return {
             id: sessionId,
-            run: (input) => execution('run', input),
-            plan: (input) => execution('plan', input),
-            steer: (input) => sessionRuntime.execution?.steer?.(input) ?? Promise.resolve({ status: 'notAccepted' }),
+            subscribe: (listener) => {
+                services.assertSessionAdmission(sessionId);
+                return sessionRuntime.subscribe(listener);
+            },
+            run: (input) => execution('run', input, input.clientMessageId ? inputOptions() : undefined),
+            plan: (input) => execution('plan', input, input.clientMessageId ? inputOptions() : undefined),
+            steer: (input) => sessionRuntime.execution?.steer?.(input, inputSource()) ??
+                Promise.resolve({ status: 'notAccepted' }),
             compact: (input = {}) => {
                 const requests = sessionRuntime.execution?.compactRequests;
                 if (requests) {
@@ -276,25 +227,7 @@ export function createSessionOpener(services) {
                 });
             },
             cancel: async (executionId) => sessionRuntime.cancelExecution(executionId),
-            startSubagentTurn: (turn) => execution(turn.role === 'explore' ? 'plan' : 'run', {
-                prompt: turn.prompt,
-                modelId: turn.modelId,
-                reasoningEffort: turn.reasoningEffort,
-                ...(turn.permissionMode === undefined ? {} : { permissionMode: turn.permissionMode })
-            }, {
-                publishHostEvents: false,
-                ...(turn.origin === undefined ? {} : { signal: turn.origin.signal }),
-                inputSource: turn.origin === undefined ? 'parent_agent' : 'extension',
-                ...(turn.origin === undefined
-                    ? {}
-                    : { extensionSource: extensionInputSource(turn.origin) }),
-                initialMailbox: turn.initialMailbox,
-                turnId: turn.turnId,
-                ...(turn.mcpExecutionScopeId === undefined
-                    ? {}
-                    : { mcpExecutionScopeId: turn.mcpExecutionScopeId }),
-                ...(turn.delivery ? { delivery: turn.delivery } : {})
-            })
+            joinExecution: (executionId) => sessionRuntime.joinExecution(executionId)
         };
     };
     return openSession;

package/dist/sdk/types.d.ts

@@ -8,6 +8,10 @@ import type { SessionListInput, SessionSource, SessionTitleUpdateInput } from '.
 export interface CreateSessionInput {
     workspace: string;
     title?: string;
+    /** Optional creation relationship; authorization and depth are owned by the Host. */
+    parentSessionId?: string;
+    /** Optional provenance snapshot; it cannot contradict the creation relationship. */
+    source?: SessionSource;
 }
 export type { SessionTitleUpdateInput } from '../session/types.js';
 export type { HostExecutionExtensions, HostSessionResourceSnapshot, HostSkill, AgentHost } from '../host/contracts.js';
@@ -35,20 +39,50 @@ export type SteerResult = {
 /** A persisted Session permits one active main execution at a time. */
 export interface AgentSession {
     readonly id: string;
+    /** Subscribe to future events and atomically capture the currently active Execution, if any. */
+    subscribe(listener: (event: import('../runtime/events.js').AgentEvent) => void): {
+        readonly activeExecutionId?: string;
+        /** Terminal fact already published by the still-admitted Execution, if any. */
+        readonly terminalEvent?: Extract<import('../runtime/events.js').AgentEvent, {
+            type: 'execution.completed' | 'execution.failed' | 'execution.cancelled';
+        }>;
+        unsubscribe(): void;
+    };
     run(input: RunInput): ExecutionHandle;
     plan(input: RunInput): ExecutionHandle;
     steer(input: SteerInput): Promise<SteerResult>;
     compact(input?: CompactInput): ExecutionHandle;
     cancel(executionId: string): Promise<void>;
+    /** Join a currently owned Execution after its cleanup, without cancelling it. */
+    joinExecution(executionId: string): Promise<import('../runtime/contracts.js').ExecutionResult> | undefined;
+}
+/** A Session already owned by this Agent, with no history opening or replay. */
+export interface AgentLiveSession {
+    readonly id: string;
+    readonly workspace: string;
+    readonly source: SessionSource;
+    readonly subscribe: AgentSession['subscribe'];
 }
 export interface Agent {
     extensionDiagnostics(): readonly import('../extensions/contracts.js').ExtensionDiagnostic[];
+    /** Atomically subscribe to future admitted Executions and snapshot currently admitted Sessions. */
+    observeSessionExecutions(listener: (session: AgentLiveSession) => void): {
+        readonly sessions: readonly AgentLiveSession[];
+        unsubscribe(): void;
+    };
     createSession(input: CreateSessionInput): Promise<AgentSession>;
     openSession(sessionId: string): Promise<AgentSession>;
     listSessions(input?: SessionListInput): Promise<AgentSessionPage>;
     getSession(sessionId: string): Promise<AgentSessionSummary & {
         automaticTitlePending: boolean;
     }>;
+    /** Read persisted Session history without opening or starting an Execution. */
+    sessionHistory: import('../session/catalog.js').AgentSessionCatalog['history'];
+    sessionInputReceipt: import('../session/catalog.js').AgentSessionCatalog['inputReceipt'];
+    /** Check an unfinished persisted Execution under the Session's exclusive writer admission. */
+    sessionExecutionWasInterrupted(sessionId: string, executionId: string, input?: {
+        readonly signal?: AbortSignal;
+    }): Promise<boolean>;
     setSessionTitle(sessionId: string, title: string, input?: SessionTitleUpdateInput): Promise<boolean>;
     clearSession(sessionId: string): Promise<void>;
     /** Updates future execution snapshots only; undefined clears the Host instruction extension. */
@@ -59,6 +93,8 @@ export interface Agent {
         readonly defaultModelId?: string;
     }): Promise<void>;
     deleteSession(sessionId: string): Promise<void>;
+    /** Deletes the explicit members under one maintenance admission; never infers descendants. */
+    deleteSessions(sessionIds: readonly string[]): Promise<void>;
     /** Joins executions/reconfiguration, closes owned resources, and releases borrowed Store leases. */
     dispose(): Promise<void>;
 }

package/dist/session/catalog.d.ts

@@ -15,6 +15,14 @@ export interface AgentSessionHistoryPage {
     entries: AgentSessionHistoryEntry[];
     nextCursor?: string;
 }
+export interface AgentSessionInputReceipt {
+    readonly clientMessageId: string;
+    readonly executionId: string;
+    readonly turnId: string;
+    readonly status: 'accepted' | 'applied';
+    readonly appliedExecutionId?: string;
+    readonly appliedTurnId?: string;
+}
 export interface AgentSessionContextUsage {
     inputTokens: number;
 }
@@ -40,6 +48,17 @@ export interface AgentSessionCatalog {
         limit?: number;
         cursor?: string;
     }): Promise<AgentSessionHistoryPage>;
+    /** Read the specified receipt, or the latest receipt associated with the fixed Execution. */
+    inputReceipt(sessionId: string, input: {
+        clientMessageId?: string;
+        executionId: string;
+        signal?: AbortSignal;
+        source?: {
+            sessionId: string;
+            extensionId: string;
+            actors?: readonly string[];
+        };
+    }): Promise<AgentSessionInputReceipt | undefined>;
     readImage(sessionId: string, input: {
         readonly sequence: number;
         readonly imageIndex: number;
@@ -57,6 +76,8 @@ export interface AgentSessionCatalog {
     rollback(sessionId: string, input: AgentSessionRollbackInput): Promise<AgentSessionSummary>;
     clear(sessionId: string): Promise<AgentSessionSummary>;
     delete(sessionId: string): Promise<AgentSessionDeleteResult>;
+    /** Delete exactly these members after their owners have released their resources. */
+    deleteMembers(sessionIds: readonly string[]): Promise<AgentSessionDeleteResult>;
     close(): Promise<void>;
 }
 export type OpenAgentSessionCatalogInput = {
@@ -66,5 +87,5 @@ export type OpenAgentSessionCatalogInput = {
     sessionStore: SessionStore;
     homeDirectory?: never;
 };
-export declare function createSessionCatalog(store: Pick<SessionStore, 'list' | 'firstUserMessagePreview' | 'executionConfiguration' | 'readPage' | 'readInputImage' | 'readResource' | 'readToolResultResource' | 'forkSession' | 'rollbackSession' | 'clearSession' | 'delete' | 'close'>, borrowed: boolean): AgentSessionCatalog;
+export declare function createSessionCatalog(store: Pick<SessionStore, 'list' | 'firstUserMessagePreview' | 'executionConfiguration' | 'readPage' | 'readInputImage' | 'readResource' | 'readToolResultResource' | 'forkSession' | 'rollbackSession' | 'clearSession' | 'delete' | 'acquireSessionMaintenance' | 'close'>, borrowed: boolean): AgentSessionCatalog;
 export declare function imageMetadata(value: unknown): AgentSessionHistoryImageMetadata[];

package/dist/session/catalog.js

@@ -1,5 +1,6 @@
 import { AgentError } from '../error.js';
 import { publicHostedToolEvents } from '../runtime/event-projection.js';
+import { appliedInputRecord } from './deferred-input.js';
 const MAX_INPUT_IMAGE_BYTES = 5 * 1024 * 1024;
 const INPUT_IMAGE_MIME_TYPES = new Set(['image/png', 'image/jpeg', 'image/gif', 'image/webp']);
 export function createSessionCatalog(store, borrowed) {
@@ -21,6 +22,80 @@ export function createSessionCatalog(store, borrowed) {
             assertOpen();
             return store.executionConfiguration(sessionId);
         },
+        inputReceipt: async (sessionId, input) => {
+            assertOpen();
+            if ((input.clientMessageId !== undefined && !input.clientMessageId.trim()) ||
+                !input.executionId.trim())
+                throw new AgentError('MAR_AGENT_SESSION_INPUT_INVALID', 'Input receipt identity is invalid.');
+            const applied = new Map();
+            let beforeSequence;
+            do {
+                input.signal?.throwIfAborted();
+                const page = await store.readPage(sessionId, {
+                    limit: 1000,
+                    ...(beforeSequence === undefined ? {} : { beforeSequence })
+                });
+                input.signal?.throwIfAborted();
+                for (const record of [...page.records].reverse()) {
+                    if (!isRecord(record.payload))
+                        continue;
+                    if (record.type === 'input.applied' &&
+                        typeof record.payload.inputRef === 'string' &&
+                        !applied.has(record.payload.inputRef))
+                        applied.set(record.payload.inputRef, {
+                            ...(record.executionId === undefined ? {} : { executionId: record.executionId }),
+                            ...(record.turnId === undefined ? {} : { turnId: record.turnId })
+                        });
+                    if (record.type === 'model.context' &&
+                        isRecord(record.payload.input) &&
+                        (input.clientMessageId === undefined ||
+                            record.payload.input.clientMessageId === input.clientMessageId)) {
+                        const projected = appliedInputRecord(record);
+                        if (projected && !applied.has(projected.recordId))
+                            applied.set(projected.recordId, {
+                                ...(record.executionId === undefined ? {} : { executionId: record.executionId }),
+                                ...(record.turnId === undefined ? {} : { turnId: record.turnId })
+                            });
+                    }
+                    if (record.type !== 'turn.user' ||
+                        !record.executionId ||
+                        !record.turnId ||
+                        typeof record.payload.clientMessageId !== 'string' ||
+                        !record.payload.clientMessageId ||
+                        (input.clientMessageId !== undefined &&
+                            record.payload.clientMessageId !== input.clientMessageId))
+                        continue;
+                    if (input.source) {
+                        const source = record.payload.source;
+                        if (!isRecord(source) ||
+                            source.sessionId !== input.source.sessionId ||
+                            source.extensionId !== input.source.extensionId ||
+                            (input.source.actors && !input.source.actors.includes(String(source.actor))))
+                            continue;
+                    }
+                    const application = applied.get(record.recordId);
+                    if (input.clientMessageId === undefined
+                        ? record.executionId !== input.executionId &&
+                            application?.executionId !== input.executionId
+                        : record.executionId !== input.executionId)
+                        continue;
+                    return {
+                        clientMessageId: record.payload.clientMessageId,
+                        executionId: record.executionId,
+                        turnId: record.turnId,
+                        status: application ? 'applied' : 'accepted',
+                        ...{
+                            ...(application?.executionId === undefined
+                                ? {}
+                                : { appliedExecutionId: application.executionId }),
+                            ...(application?.turnId === undefined ? {} : { appliedTurnId: application.turnId })
+                        }
+                    };
+                }
+                beforeSequence = page.previousBeforeSequence;
+            } while (beforeSequence !== undefined);
+            return undefined;
+        },
         history: async (sessionId, options = {}) => {
             assertOpen();
             const beforeSequence = parseCursor(options.cursor);
@@ -139,6 +214,33 @@ export function createSessionCatalog(store, borrowed) {
             assertOpen();
             return store.delete(sessionId);
         },
+        deleteMembers: async (sessionIds) => {
+            assertOpen();
+            const ids = [...sessionIds];
+            if (ids.length === 0 ||
+                ids.some((id) => typeof id !== 'string' || id.length === 0) ||
+                new Set(ids).size !== ids.length)
+                throw new AgentError('MAR_AGENT_SESSION_INVALID', 'Invalid Session maintenance members.');
+            ids.sort();
+            const maintenance = await store.acquireSessionMaintenance(ids[0], 'delete', undefined, ids);
+            let failed = false;
+            try {
+                return await store.delete(ids[0], maintenance);
+            }
+            catch (error) {
+                failed = true;
+                throw error;
+            }
+            finally {
+                try {
+                    await maintenance.release();
+                }
+                catch (error) {
+                    if (!failed)
+                        throw error;
+                }
+            }
+        },
         close: () => {
             closure ??= Promise.resolve().then(() => (borrowed ? undefined : store.close()));
             return closure;

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

@@ -3,7 +3,7 @@ import { isDeepStrictEqual } from 'node:util';
 import { inlineMediaGcAnchored, parseInlineMediaGc } from './inline-media.js';
 import { codeCallEvidence, codePartialPatchCallEvidence, callsFromRecord, codeObservationEvidence, observationsFromRecord, retainedCodeInputs } from './context-gc-observations.js';
 import { parseReadContextOutput } from '../prompts/read-context.js';
-import { codeCellCompletionSequence, contextGcApplyPatchInputReplacement, contextGcCodeModeInputReplacement, contextGcCodeModeOutputReplacement, contextGcExecInputReplacement, contextGcExecOutputReplacement, contextGcPatchResultFromCompletedPayload, contextGcPatchResultFromFailedPayload, contextGcStaleReadReplacement, contextGcWebOutputReplacement, normalizeContextGcCodeModeInput, normalizeContextGcExecResult } from './context-gc-replacements.js';
+import { codeCellCompletionSequence, contextGcApplyPatchInputReplacement, contextGcCodeModeInputReplacement, contextGcCodeModeOutputReplacement, contextGcExecInputReplacement, contextGcExecOutputReplacement, contextGcPatchResultFromCompletedPayload, contextGcPatchResultFromFailedPayload, contextGcStaleReadReplacement, contextGcToolOutputReplacement, contextGcWebOutputReplacement, isGenericContextGcTool, normalizeContextGcCodeModeInput, normalizeContextGcExecResult } from './context-gc-replacements.js';
 import { contextGcSubagentNeedsRetainedPriorFinal, contextGcSubagentOutputReplacement, contextGcSubagentSnapshotIsPreciselyCovered, contextGcSubagentSnapshotIsSuperseded, normalizeContextGcSubagentSnapshot } from './context-gc-subagent.js';
 export const CONTEXT_GC_CHECKPOINT_VERSION = 1;
 export const CONTEXT_GC_MAX_TARGETS = 4_096;
@@ -350,6 +350,20 @@ function replacementMatchesRecords(replacement, records, recordsBySequence, work
                         value.truncated === true) === true
                     : evidence.completed.payload.truncated));
     }
+    if (replacement.kind === 'TOOL_OUTPUT') {
+        const evidence = successfulToolEvidence(records, recordsBySequence, replacement.evidenceSequence, replacement.toolName, replacement.callId);
+        return (isGenericContextGcTool(replacement.toolName) &&
+            evidence !== undefined &&
+            evidence.result.sequence === replacement.target.sequence &&
+            !hasFailedToolEvidence(records, evidence.call, evidence.result, replacement.toolName) &&
+            isRecord(evidence.completed.payload) &&
+            typeof evidence.completed.payload.truncated === 'boolean' &&
+            typeof source.payload.content === 'string' &&
+            isRecord(evidence.result.payload) &&
+            evidence.result.payload.content === source.payload.content &&
+            replacement.replacementContent ===
+                contextGcToolOutputReplacement(replacement.toolName, source.payload.content, evidence.completed.payload.truncated));
+    }
     if (replacement.kind === 'SUBAGENT_OUTPUT') {
         const retainedPriorFinal = replacement.retainedPriorFinal;
         const sourceEvidence = successfulToolEvidence(records, recordsBySequence, source.sequence, replacement.toolName);
@@ -808,6 +822,21 @@ function isContextGcReplacement(value) {
             (value.target.toolName === undefined || value.target.toolName === value.toolName) &&
             isNonemptyString(value.replacementContent) &&
             isPositiveInteger(value.evidenceSequence));
+    if (value.kind === 'TOOL_OUTPUT')
+        return (hasOnlyKeys(value, [
+            'kind',
+            'toolName',
+            'callId',
+            'target',
+            'replacementContent',
+            'evidenceSequence'
+        ]) &&
+            value.target.role === 'tool' &&
+            isNonemptyString(value.toolName) &&
+            isGenericContextGcTool(value.toolName) &&
+            (value.target.toolName === undefined || value.target.toolName === value.toolName) &&
+            isNonemptyString(value.replacementContent) &&
+            isPositiveInteger(value.evidenceSequence));
     if (value.kind === 'CODE_MODE_OUTPUT')
         return (hasOnlyKeys(value, ['kind', 'callId', 'target', 'replacementContent', 'evidenceSequence']) &&
             value.target.role === 'tool' &&

package/dist/session/context-gc-contract.d.ts

@@ -68,6 +68,13 @@ export type ContextGcReplacement = {
     readonly target: ContextGcTarget;
     readonly replacementContent: string;
     readonly evidenceSequence: number;
+} | {
+    readonly kind: 'TOOL_OUTPUT';
+    readonly toolName: string;
+    readonly callId: string;
+    readonly target: ContextGcTarget;
+    readonly replacementContent: string;
+    readonly evidenceSequence: number;
 } | {
     readonly kind: 'SUBAGENT_OUTPUT';
     readonly toolName: 'agent_wait' | 'agent_message' | 'agent_cancel';

package/dist/session/context-gc-replacements.d.ts

@@ -55,6 +55,9 @@ export declare function contextGcStaleReadReplacement(input: {
     readonly operation: Exclude<ContextGcPatchFile['operation'], 'added'>;
 }): string;
 export declare function contextGcWebOutputReplacement(toolName: ContextGcWebToolName, originalContent: string, truncated: boolean): string;
+/** Tools with their own evidence and lifecycle policies are never handled as generic output. */
+export declare function isGenericContextGcTool(toolName: string): boolean;
+export declare function contextGcToolOutputReplacement(toolName: string, originalContent: string, truncated: boolean): string;
 export declare function contextGcExecInputReplacement(arguments_: unknown, toolName?: string): unknown;
 export declare function contextGcExecOutputReplacement(result: ContextGcExecResult): string;
 export declare function normalizeContextGcExecResult(modelContent: unknown, completedPayload: unknown): ContextGcExecResult | undefined;

package/dist/session/context-gc-replacements.js

@@ -82,6 +82,32 @@ export function contextGcWebOutputReplacement(toolName, originalContent, truncat
         contextGc: 'Detailed web tool output was reclaimed after six successful rollouts. An incomplete preview is not the complete search result or page, and GC did not access the network.'
     });
 }
+/** Tools with their own evidence and lifecycle policies are never handled as generic output. */
+export function isGenericContextGcTool(toolName) {
+    return (toolName.length > 0 &&
+        ![
+            'read',
+            'apply_patch',
+            'exec',
+            'exec_wait',
+            'code_exec',
+            'code_exec_wait',
+            'web_search',
+            'web_fetch'
+        ].includes(toolName));
+}
+export function contextGcToolOutputReplacement(toolName, originalContent, truncated) {
+    const preview = unicodeHeadTail(originalContent, EXEC_OUTPUT_PREVIEW_CHARACTERS);
+    return JSON.stringify({
+        toolName,
+        originalBytes: Buffer.byteLength(originalContent),
+        lines: lineCount(originalContent),
+        truncated,
+        preview,
+        previewComplete: !truncated && preview === originalContent,
+        contextGc: 'Detailed tool output was reclaimed after six successful rollouts. An incomplete preview is not the complete result; the tool was not replayed.'
+    });
+}
 export function contextGcExecInputReplacement(arguments_, toolName = 'exec') {
     if (!isRecord(arguments_))
         return contextGcMarkup('terminal_exec_input', {

package/dist/session/store/contracts.d.ts

@@ -144,8 +144,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>;
+    /** Conflicts fail before cleanup; delete admits only the explicit members, or the given Session. */
+    acquireSessionMaintenance(sessionId: string, kind: 'clear' | 'delete', owner?: object, members?: readonly string[]): Promise<SessionStoreMaintenance>;
     forkSession(sessionId: string, input: {
         readonly boundaryTurnId: string | null;
         readonly title: string;

package/dist/session/store/jsonl/directory-index.d.ts

@@ -14,7 +14,7 @@ export declare function persistSessionIndex(path: string, index: SessionIndex):
 export declare function persistFormatSelection(path: string, index: SessionIndex): Promise<void>;
 export declare function normalizeSessionSource(value: SessionSource | undefined): SessionSource;
 interface SessionListFilter {
-    readonly source: SessionSource['type'];
+    readonly source?: SessionSource['type'];
     readonly parentSessionId?: string;
     readonly rootSessionId?: string;
 }

package/dist/session/store/jsonl/directory-index.js

@@ -184,8 +184,17 @@ export async function persistFormatSelection(path, index) {
     }
 }
 export function normalizeSessionSource(value) {
-    if (value === undefined || value.type === 'user')
+    if (value === undefined)
         return { type: 'user' };
+    if (value.type === 'user') {
+        if (value.parentSessionId !== undefined &&
+            (typeof value.parentSessionId !== 'string' || !value.parentSessionId.trim()))
+            throw new AgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Session source is invalid.');
+        return {
+            type: 'user',
+            ...(value.parentSessionId === undefined ? {} : { parentSessionId: value.parentSessionId })
+        };
+    }
     if (value.type !== 'subagent' ||
         typeof value.parentSessionId !== 'string' ||
         !value.parentSessionId.trim() ||
@@ -221,27 +230,21 @@ export function normalizeSessionSource(value) {
     };
 }
 export function sessionListFilter(input) {
-    const source = input.source ??
-        (input.parentSessionId !== undefined || input.rootSessionId !== undefined
-            ? 'subagent'
-            : 'user');
-    if ((source !== 'user' && source !== 'subagent') ||
-        (input.parentSessionId !== undefined &&
-            (source !== 'subagent' || input.parentSessionId.length === 0)) ||
-        (input.rootSessionId !== undefined &&
-            (source !== 'subagent' || input.rootSessionId.length === 0)))
+    const source = input.source;
+    if ((source !== undefined && source !== 'user' && source !== 'subagent') ||
+        (input.parentSessionId !== undefined && input.parentSessionId.length === 0) ||
+        (input.rootSessionId !== undefined && (source === 'user' || input.rootSessionId.length === 0)))
         throw new AgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Session list filter is invalid.');
     return {
-        source,
+        ...(source === undefined ? {} : { source }),
         ...(input.parentSessionId === undefined ? {} : { parentSessionId: input.parentSessionId }),
         ...(input.rootSessionId === undefined ? {} : { rootSessionId: input.rootSessionId })
     };
 }
 export function sessionMatchesFilter(meta, filter) {
     const source = normalizeSessionSource(meta.source);
-    return (source.type === filter.source &&
-        (filter.parentSessionId === undefined ||
-            (source.type === 'subagent' && source.parentSessionId === filter.parentSessionId)) &&
+    return ((filter.source === undefined || source.type === filter.source) &&
+        (filter.parentSessionId === undefined || source.parentSessionId === filter.parentSessionId) &&
         (filter.rootSessionId === undefined ||
             (source.type === 'subagent' && source.rootSessionId === filter.rootSessionId)));
 }
@@ -273,9 +276,7 @@ export function sessionTreeIds(sessions, sessionId) {
         const parentId = ids[index];
         for (const session of sessions) {
             const source = normalizeSessionSource(session.source);
-            if (source.type === 'subagent' &&
-                source.parentSessionId === parentId &&
-                !ids.includes(session.id))
+            if (source.parentSessionId === parentId && !ids.includes(session.id))
                 ids.push(session.id);
         }
     }

package/dist/session/store/jsonl/history.js

@@ -155,7 +155,7 @@ export function forkedPayload(type, value, sourceSessionId, targetSessionId, tit
                 : {})
         };
     };
-    if (type === 'model.context')
+    if (type === 'model.context' || type === 'input.applied')
         return application(payload);
     if (type === 'compact.completed') {
         if (payload.inlineMediaState)

package/dist/session/store/jsonl/index-transaction.js

@@ -21,7 +21,7 @@ export async function commitSessionIndex(root, snapshot, committed, deletedIds,
             if (!created)
                 throw new AgentError('MAR_AGENT_SESSION_CORRUPT', 'Session publication is missing.');
             const source = normalizeSessionSource(created.source);
-            if (source.type !== 'subagent')
+            if (source.parentSessionId === undefined)
                 continue;
             if (!disk.sessions.some((entry) => entry.id === source.parentSessionId))
                 throw new ParentPublicationRejected('MAR_AGENT_SESSION_NOT_FOUND', 'Parent Session was not found.');
@@ -35,7 +35,6 @@ export async function commitSessionIndex(root, snapshot, committed, deletedIds,
             }
         }
         if (deleteExpected) {
-            const ids = new Set(deleteExpected.map((entry) => entry.id));
             for (const expected of deleteExpected) {
                 const current = disk.sessions.find((entry) => entry.id === expected.id);
                 if (!current ||
@@ -45,12 +44,7 @@ export async function commitSessionIndex(root, snapshot, committed, deletedIds,
                     !isDeepStrictEqual(current.storage, expected.storage) ||
                     current.storageTransactionId !== expected.storageTransactionId ||
                     current.nextSequence !== expected.nextSequence)
-                    throw new AgentError('MAR_AGENT_SESSION_CORRUPT', 'Session tree changed during deletion.');
-            }
-            for (const entry of disk.sessions) {
-                const source = normalizeSessionSource(entry.source);
-                if (source.type === 'subagent' && ids.has(source.parentSessionId) && !ids.has(entry.id))
-                    throw new AgentError('MAR_AGENT_SESSION_CORRUPT', 'Session tree changed during deletion.');
+                    throw new AgentError('MAR_AGENT_SESSION_CORRUPT', 'Session changed during deletion.');
             }
         }
         const local = snapshot();