@myagentroam/agent 0.11.39 → 0.11.40

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();

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

@@ -115,7 +115,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>;
+    acquireSessionMaintenance(sessionId: string, kind: 'clear' | 'delete', owner?: object, members?: readonly string[]): 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>>;

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

@@ -219,20 +219,21 @@ export class JsonlSessionStore {
     async createSession(input) {
         this.#assertOpen();
         const source = normalizeSessionSource(input.source);
-        if (source.type !== 'subagent')
+        if (source.parentSessionId === undefined)
             return this.#createSession(input, source);
+        const parentSessionId = source.parentSessionId;
         // Publish under the parent's existing serial domain so tree admission cannot miss a child.
-        return this.#serializeRecordOperation(source.parentSessionId, async () => {
+        return this.#serializeRecordOperation(parentSessionId, async () => {
             this.#assertOpen();
-            if (this.#shared.writerLeases.get(source.parentSessionId)?.maintenance)
+            if (this.#shared.writerLeases.get(parentSessionId)?.maintenance)
                 throw new AgentError('MAR_AGENT_SESSION_LOCKED', 'Session is under maintenance.');
-            const release = await this.#acquirePublicationGate(source.parentSessionId, 5000);
+            const release = await this.#acquirePublicationGate(parentSessionId, 5000);
             let failure;
             try {
-                await this.#recoverPendingTreeDelete(source.parentSessionId);
-                if (this.#shared.writerLeases.get(source.parentSessionId)?.maintenance)
+                await this.#recoverPendingTreeDelete(parentSessionId);
+                if (this.#shared.writerLeases.get(parentSessionId)?.maintenance)
                     throw new AgentError('MAR_AGENT_SESSION_LOCKED', 'Session is under maintenance.');
-                await this.getSession(source.parentSessionId);
+                await this.getSession(parentSessionId);
                 return await this.#createSession(input, source);
             }
             catch (error) {
@@ -1408,13 +1409,27 @@ export class JsonlSessionStore {
         const lease = this.#shared.writerLeases.get(sessionId);
         return lease?.owner === owner && lease.retained > 0;
     }
-    async acquireSessionMaintenance(sessionId, kind, owner) {
+    async acquireSessionMaintenance(sessionId, kind, owner, members) {
         this.#assertOpen();
+        const ids = members === undefined ? [sessionId] : [...members];
+        if (ids.length === 0 ||
+            !ids.includes(sessionId) ||
+            new Set(ids).size !== ids.length ||
+            (kind === 'clear' && (ids.length !== 1 || ids[0] !== sessionId)))
+            throw new AgentError('MAR_AGENT_SESSION_INVALID', 'Invalid Session maintenance members.');
+        ids.sort();
+        for (const id of ids)
+            this.#sessionRoot(id);
         await this.#recoverPendingTreeDelete(sessionId);
         return acquireTreeMaintenance({
             sessionId,
             kind,
-            tree: () => this.sessionTree(sessionId),
+            tree: async () => {
+                await this.#refreshIndex();
+                if (ids.some((id) => !this.#shared.index.sessions.some((session) => session.id === id)))
+                    throw new AgentError('MAR_AGENT_SESSION_NOT_FOUND', 'Session was not found.');
+                return ids;
+            },
             acquire: (id, holding, registerGate) => this.#serializeRecordOperation(id, async () => {
                 this.#assertOpen();
                 registerGate(await this.#acquirePublicationGate(id));

package/dist/session/types.d.ts

@@ -1,6 +1,7 @@
 /** Public session provenance; storage may persist additional private metadata. */
 export type SessionSource = {
     readonly type: 'user';
+    readonly parentSessionId?: string;
 } | {
     readonly type: 'subagent';
     readonly parentSessionId: string;

package/dist/tools/agent/sleep.js

@@ -36,7 +36,7 @@ export async function executeSleep(arguments_, context, callId) {
         durationMs,
         startedAt: new Date().toISOString()
     });
-    const messages = context.subagentMessages;
+    const messages = context.contextUpdates;
     const outcome = await waitForToolCondition({
         ready: () => messages?.pending() ?? false,
         subscribe: (notify) => messages?.subscribe(notify) ?? (() => { }),

package/dist/tools/callers.js

@@ -15,18 +15,7 @@ export function toolCallers(tool) {
 export function allowsToolCaller(tool, caller) {
     // Control tools cannot be widened by a Host override or historical definition.
     if (caller === 'programmatic' &&
-        [
-            'code_exec',
-            'code_exec_wait',
-            'tool_search',
-            'question',
-            'skill',
-            'sleep',
-            'agent_start',
-            'agent_wait',
-            'agent_message',
-            'agent_cancel'
-        ].includes(tool.name))
+        ['code_exec', 'code_exec_wait', 'tool_search', 'question', 'skill', 'sleep'].includes(tool.name))
         return false;
     return toolCallers(tool).includes(caller);
 }

package/dist/tools/code-mode/dispatch.js

@@ -32,7 +32,9 @@ export function createCodeToolDispatch(input) {
                     ...(expected ? { expectedMcpTool: expected } : {})
                 }, 'programmatic');
                 const bounded = boundedModelToolOutput(call.name, result.content, result.data);
-                const data = structuredToolEventData(call.name, result.data);
+                const data = structuredToolEventData(call.name, call.name === 'exec' || call.name === 'exec_wait'
+                    ? (result.eventData ?? result.data)
+                    : result.data);
                 const preview = toolEventSummary(result.content);
                 input.assertLive();
                 await input.emit({
@@ -44,8 +46,9 @@ export function createCodeToolDispatch(input) {
                     truncated: result.truncated === true || bounded.truncated || preview.truncated,
                     ...(result.artifacts ? { artifacts: result.artifacts } : {})
                 });
+                const { eventData: _eventData, ...guestResult } = result;
                 return {
-                    ...result,
+                    ...guestResult,
                     content: bounded.content,
                     truncated: result.truncated === true || bounded.truncated
                 };

package/dist/tools/code-mode/index.d.ts

@@ -22,7 +22,7 @@ export declare class CodeModeTool {
     wait(value: unknown, context: ToolExecutionContext): Promise<ToolExecutionResult>;
     listSessionResources(sessionId: string): {
         cellId: string;
-        status: "completed" | "failed" | "cancelled" | "running";
+        status: "running" | "failed" | "cancelled" | "completed";
         executionId: string;
     }[];
     constructor(paths: WorkspacePathResolver, environment: NodeJS.ProcessEnv | undefined, executor: LocalProcessExecutor, signalProcessTree: (child: import('node:child_process').ChildProcessWithoutNullStreams, signal: NodeJS.Signals) => Promise<void>, engineFactory?: CodeModeEngineFactory);

package/dist/tools/code-mode/index.js

@@ -399,6 +399,8 @@ export class CodeModeTool {
                     };
                     const indices = original.result.images?.map(addImage);
                     const data = [
+                        'exec',
+                        'exec_wait',
                         'apply_patch',
                         'todo_read',
                         'todo_write',