@myagentroam/agent 0.9.64 → 0.9.66

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

@@ -1,5 +1,8 @@
 import { createHash } from 'node:crypto';
 const RAW_MODEL_CONTEXT_PREVIEW_CHARACTERS = 256;
+const EXEC_INPUT_COMPLETE_CHARACTERS = 512;
+const EXEC_INPUT_PREVIEW_CHARACTERS = 256;
+const EXEC_OUTPUT_PREVIEW_CHARACTERS = 512;
 export function contextGcPatchResultFromCompletedPayload(payload) {
     if (!isRecord(payload) || payload.type !== 'tool.completed')
         return undefined;
@@ -43,39 +46,55 @@ export function contextGcPatchResultFromCompletedPayload(payload) {
         }
     };
 }
-export function contextGcApplyPatchInputReplacement(arguments_, result, evidenceSequence) {
+export function contextGcApplyPatchInputReplacement(arguments_, result, evidenceSequence, formatVersion = 2) {
     const original = typeof arguments_ === 'string' ? arguments_ : stableJson(arguments_);
     const summary = result.files
         .map((file) => `${file.operation} ${file.path}${file.targetPath ? ` -> ${file.targetPath}` : ''} (+${file.addedLines}/-${file.deletedLines})`)
         .join('; ');
-    return `<context_gc kind="successful_apply_patch_input" originalBytes="${Buffer.byteLength(original)}" originalSha256="${sha256(original)}" evidenceSequence="${evidenceSequence}">Applied successfully: ${escapeXml(summary)}. Totals: ${result.totals.files} files, +${result.totals.addedLines}/-${result.totals.deletedLines}. The original patch body was reclaimed.</context_gc>`;
+    return `<context_gc kind="successful_apply_patch_input"${formatVersion === 2 ? ' formatVersion="2"' : ''} originalBytes="${Buffer.byteLength(original)}"${formatVersion === 1 ? ` originalSha256="${sha256(original)}"` : ''}${formatVersion === 1 ? ` evidenceSequence="${evidenceSequence}"` : ''}>Applied successfully: ${escapeXml(summary)}. Totals: ${result.totals.files} files, +${result.totals.addedLines}/-${result.totals.deletedLines}. The original patch body was reclaimed.</context_gc>`;
 }
 export function contextGcStaleReadReplacement(input) {
-    return `<context_gc kind="stale_read" path="${escapeXml(input.path)}" originalBytes="${Buffer.byteLength(input.content)}" originalSha256="${sha256(input.content)}" supersededByCallId="${escapeXml(input.supersededByCallId)}" operation="${input.operation}" evidenceSequence="${input.evidenceSequence}">This read predates a successful apply_patch. Re-read the path before relying on its contents.</context_gc>`;
+    const formatVersion = input.formatVersion ?? 2;
+    return `<context_gc kind="stale_read" path="${escapeXml(input.path)}"${formatVersion === 2 ? ' formatVersion="2"' : ''} originalBytes="${Buffer.byteLength(input.content)}"${formatVersion === 1 ? ` originalSha256="${sha256(input.content)}"` : ''}${formatVersion === 1
+        ? ` supersededByCallId="${escapeXml(input.supersededByCallId)}" evidenceSequence="${input.evidenceSequence}"`
+        : ''} operation="${input.operation}">This read predates a successful apply_patch. Re-read the path before relying on its contents.</context_gc>`;
 }
-export function contextGcExecInputReplacement(arguments_) {
+export function contextGcWebOutputReplacement(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: preview === originalContent,
+        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.'
+    });
+}
+export function contextGcExecInputReplacement(arguments_, formatVersion = 3) {
     if (!isRecord(arguments_))
-        return `<context_gc kind="terminal_exec_input" originalSha256="${sha256(stableJson(arguments_))}" />`;
+        return `<context_gc kind="terminal_exec_input"${formatVersion === 3 ? ' formatVersion="3"' : ''} originalBytes="${Buffer.byteLength(stableJson(arguments_))}"${formatVersion === 3 ? '' : ` originalSha256="${sha256(stableJson(arguments_))}"`} />`;
     const action = typeof arguments_.action === 'string' ? arguments_.action : 'unknown';
     const original = stableJson(arguments_);
     const retained = {
         action,
         contextGc: {
             kind: 'terminal_exec_input',
+            ...(formatVersion >= 2 ? { formatVersion } : {}),
             originalBytes: Buffer.byteLength(original),
-            originalSha256: sha256(original)
+            ...(formatVersion <= 2 ? { originalSha256: sha256(original) } : {})
         }
     };
     for (const key of ['cwd', 'processId', 'timeoutMs', 'yieldMs'])
         if (arguments_[key] !== undefined)
             retained[key] = arguments_[key];
     if (typeof arguments_.command === 'string')
-        retained.commandPrefix = [...arguments_.command].slice(0, 256).join('');
+        retainExecText(retained, 'command', arguments_.command, formatVersion);
     if (typeof arguments_.data === 'string')
-        retained.dataPrefix = [...arguments_.data].slice(0, 256).join('');
+        retainExecText(retained, 'data', arguments_.data, formatVersion);
     return retained;
 }
-export function contextGcExecOutputReplacement(result) {
+export function contextGcExecOutputReplacement(result, formatVersion = 3) {
     if (result.source === 'MODEL_CONTEXT_TRUNCATED')
         return JSON.stringify({
             status: result.status,
@@ -88,12 +107,15 @@ export function contextGcExecOutputReplacement(result) {
             stderrDroppedBytes: result.stderrDroppedBytes,
             modelContextTruncated: true,
             modelContextBytes: Buffer.byteLength(result.modelContextContent),
-            modelContextSha256: sha256(result.modelContextContent),
             modelContextPreview: unicodeHeadTail(result.modelContextContent, RAW_MODEL_CONTEXT_PREVIEW_CHARACTERS),
+            ...(formatVersion >= 2 ? { contextGcFormatVersion: formatVersion } : {}),
+            ...(formatVersion <= 2 ? { modelContextSha256: sha256(result.modelContextContent) } : {}),
             contextGc: 'The model-visible terminal result was truncated after execution and is no longer valid JSON. Detailed terminal input/output was reclaimed after the process reached a stable terminal state. Re-run the command if full output is required.'
         });
     const stdout = result.stdout;
     const stderr = result.stderr;
+    const stdoutPreview = unicodeHeadTail(stdout, EXEC_OUTPUT_PREVIEW_CHARACTERS);
+    const stderrPreview = unicodeHeadTail(stderr, EXEC_OUTPUT_PREVIEW_CHARACTERS);
     return JSON.stringify({
         status: result.status,
         ...(result.processId === undefined ? {} : { processId: result.processId }),
@@ -103,11 +125,32 @@ export function contextGcExecOutputReplacement(result) {
         stderrBytes: nonnegativeNumber(result.stderrBytes) ?? Buffer.byteLength(stderr),
         stdoutDroppedBytes: nonnegativeNumber(result.stdoutDroppedBytes) ?? 0,
         stderrDroppedBytes: nonnegativeNumber(result.stderrDroppedBytes) ?? 0,
-        stdoutSha256: sha256(stdout),
-        stderrSha256: sha256(stderr),
-        stdoutPreview: unicodeHeadTail(stdout, 512),
-        stderrPreview: unicodeHeadTail(stderr, 512),
-        contextGc: 'Detailed terminal input/output was reclaimed after the process reached a stable terminal state. Re-run the command if full output is required.'
+        ...(formatVersion <= 2
+            ? {
+                stdoutSha256: sha256(stdout),
+                stderrSha256: sha256(stderr)
+            }
+            : {}),
+        stdoutPreview,
+        stderrPreview,
+        ...(formatVersion >= 2
+            ? {
+                stdoutLines: lineCount(stdout),
+                stderrLines: lineCount(stderr),
+                stdoutPreviewComplete: result.truncated === false &&
+                    result.stdoutDroppedBytes === 0 &&
+                    result.stdoutBytes === Buffer.byteLength(stdout) &&
+                    stdoutPreview === stdout,
+                stderrPreviewComplete: result.truncated === false &&
+                    result.stderrDroppedBytes === 0 &&
+                    result.stderrBytes === Buffer.byteLength(stderr) &&
+                    stderrPreview === stderr,
+                contextGcFormatVersion: formatVersion
+            }
+            : {}),
+        contextGc: formatVersion >= 2
+            ? 'Detailed terminal input/output was reclaimed after the process reached a stable terminal state. An incomplete preview is not the complete result. Re-run the command if full output is required.'
+            : 'Detailed terminal input/output was reclaimed after the process reached a stable terminal state. Re-run the command if full output is required.'
     });
 }
 export function normalizeContextGcExecResult(modelContent, completedPayload) {
@@ -192,6 +235,23 @@ function unicodeHeadTail(value, count) {
         .slice(-count)
         .join('')}`;
 }
+function retainExecText(retained, key, value, formatVersion) {
+    if (formatVersion === 1) {
+        retained[`${key}Prefix`] = [...value].slice(0, EXEC_INPUT_PREVIEW_CHARACTERS).join('');
+        return;
+    }
+    if ([...value].length <= EXEC_INPUT_COMPLETE_CHARACTERS) {
+        retained[key] = value;
+        return;
+    }
+    retained[`${key}Preview`] = unicodeHeadTail(value, EXEC_INPUT_PREVIEW_CHARACTERS);
+    retained[`${key}Bytes`] = Buffer.byteLength(value);
+    if (formatVersion === 2)
+        retained[`${key}Sha256`] = sha256(value);
+}
+function lineCount(value) {
+    return value.length === 0 ? 0 : value.split('\n').length;
+}
 function nonnegativeNumber(value) {
     return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined;
 }

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

@@ -14,6 +14,16 @@ export interface ContextGcSubagentSnapshot {
         readonly timestamp: string;
         readonly truncated?: boolean;
     };
+    readonly latestActivity?: {
+        readonly kind: 'message';
+        readonly timestamp: string;
+        readonly phase: 'commentary' | 'final_answer';
+    } | {
+        readonly kind: 'tool';
+        readonly timestamp: string;
+        readonly toolName: string;
+        readonly status: 'started' | 'completed' | 'failed';
+    };
     readonly summary?: string;
     readonly changedFiles?: readonly string[];
     readonly verification?: readonly string[];
@@ -34,10 +44,12 @@ export declare function contextGcSubagentSnapshotTurnId(snapshot: ContextGcSubag
 export declare function contextGcSubagentNeedsRetainedPriorFinal(snapshot: ContextGcSubagentSnapshot): boolean;
 export declare function contextGcSubagentPriorFinalIsRetained(source: ContextGcSubagentSnapshot, retained: ContextGcSubagentSnapshot | undefined): boolean;
 export declare function contextGcSubagentSnapshotIsSuperseded(source: ContextGcSubagentSnapshot, terminal: ContextGcSubagentSnapshot, retainedPriorFinal?: ContextGcSubagentSnapshot): boolean;
+export declare function contextGcSubagentSnapshotIsPreciselyCovered(source: ContextGcSubagentSnapshot, retained: ContextGcSubagentSnapshot): boolean;
 export declare function contextGcSubagentOutputReplacement(input: {
     readonly sourceContent: string;
     readonly source: ContextGcSubagentSnapshot;
     readonly terminal: ContextGcSubagentSnapshot;
     readonly terminalCallId: string;
     readonly evidenceSequence: number;
+    readonly formatVersion?: 1 | 2;
 }): string;

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

@@ -67,8 +67,32 @@ export function contextGcSubagentSnapshotIsSuperseded(source, terminal, retained
         stringArrayIsCovered(source.verification, terminal.verification) &&
         evidenceIsCovered(source.evidence, terminal.evidence));
 }
+export function contextGcSubagentSnapshotIsPreciselyCovered(source, retained) {
+    if (retained.status !== 'cancelled' &&
+        retained.status !== 'failed' &&
+        retained.status !== 'interrupted')
+        return false;
+    if (source.agentId !== retained.agentId ||
+        source.description !== retained.description ||
+        contextGcSubagentSnapshotTurnId(source) !== contextGcSubagentSnapshotTurnId(retained) ||
+        !optionalStringMatches(source.modelId, retained.modelId) ||
+        !optionalStringMatches(source.modelName, retained.modelName) ||
+        !optionalStringMatches(source.reasoningEffort, retained.reasoningEffort) ||
+        !optionalStringMatches(source.summary, retained.summary) ||
+        !optionalStringMatches(source.errorCode, retained.errorCode) ||
+        !optionalStringMatches(source.errorMessage, retained.errorMessage) ||
+        !latestMessageIsCovered(source.latestMessage, retained.latestMessage) ||
+        !latestActivityIsCovered(source.latestActivity, retained.latestActivity) ||
+        !receiptIsCovered(source, retained) ||
+        !stringArrayIsCovered(source.changedFiles, retained.changedFiles) ||
+        !stringArrayIsCovered(source.verification, retained.verification) ||
+        !evidenceIsCovered(source.evidence, retained.evidence))
+        return false;
+    return (source.status === retained.status || source.status === 'queued' || source.status === 'running');
+}
 export function contextGcSubagentOutputReplacement(input) {
     const latestMessage = input.source.latestMessage;
+    const formatVersion = input.formatVersion ?? 2;
     return JSON.stringify({
         agentId: input.source.agentId,
         description: input.source.description,
@@ -87,26 +111,37 @@ export function contextGcSubagentOutputReplacement(input) {
             ? {}
             : {
                 latestMessage: {
-                    itemId: latestMessage.itemId,
                     turnId: latestMessage.turnId,
                     phase: latestMessage.phase,
                     timestamp: latestMessage.timestamp,
+                    ...(formatVersion === 1 ? { itemId: latestMessage.itemId } : {}),
                     ...(latestMessage.truncated === undefined
                         ? {}
                         : { truncated: latestMessage.truncated }),
                     textBytes: Buffer.byteLength(latestMessage.text),
-                    textSha256: sha256(latestMessage.text)
+                    ...(formatVersion === 1 ? { textSha256: sha256(latestMessage.text) } : {})
                 }
             }),
+        ...(input.source.latestActivity === undefined
+            ? {}
+            : { latestActivity: input.source.latestActivity }),
         contextGc: {
             kind: 'superseded_subagent_snapshot',
+            ...(formatVersion === 2 ? { formatVersion } : {}),
             originalBytes: Buffer.byteLength(input.sourceContent),
-            originalSha256: sha256(input.sourceContent),
+            ...(formatVersion === 1 ? { originalSha256: sha256(input.sourceContent) } : {}),
             terminalStatus: input.terminal.status,
-            terminalTurnId: contextGcCompletedSubagentTurnId(input.terminal),
-            terminalCallId: input.terminalCallId,
-            evidenceSequence: input.evidenceSequence,
-            note: 'This intermediate child-agent snapshot was superseded by retained completed evidence; complete Turn results remain in retained completed snapshots.'
+            terminalTurnId: contextGcCompletedSubagentTurnId(input.terminal) ??
+                contextGcSubagentSnapshotTurnId(input.terminal),
+            ...(formatVersion === 1
+                ? {
+                    terminalCallId: input.terminalCallId,
+                    evidenceSequence: input.evidenceSequence
+                }
+                : {}),
+            note: input.terminal.status === 'completed'
+                ? 'This intermediate child-agent snapshot was superseded by retained completed evidence; complete Turn results remain in retained completed snapshots.'
+                : 'This duplicate child-agent snapshot was superseded by a retained non-completed terminal snapshot. Only fields exactly covered by the retained snapshot were reclaimed.'
         }
     });
 }
@@ -128,6 +163,7 @@ function parseContextGcSubagentSnapshot(value) {
             'modelName',
             'reasoningEffort',
             'latestMessage',
+            'latestActivity',
             'summary',
             'changedFiles',
             'verification',
@@ -169,6 +205,9 @@ function parseContextGcSubagentSnapshot(value) {
     const latestMessage = parseContextGcSubagentLatestMessage(parsed.latestMessage);
     if (parsed.latestMessage !== undefined && !latestMessage)
         return undefined;
+    const latestActivity = parseContextGcSubagentLatestActivity(parsed.latestActivity);
+    if (parsed.latestActivity !== undefined && !latestActivity)
+        return undefined;
     return {
         agentId: parsed.agentId,
         description: parsed.description,
@@ -179,6 +218,7 @@ function parseContextGcSubagentSnapshot(value) {
             ? { reasoningEffort: parsed.reasoningEffort }
             : {}),
         ...(latestMessage ? { latestMessage } : {}),
+        ...(latestActivity ? { latestActivity } : {}),
         ...(typeof parsed.summary === 'string' ? { summary: parsed.summary } : {}),
         ...(Array.isArray(parsed.changedFiles) ? { changedFiles: [...parsed.changedFiles] } : {}),
         ...(Array.isArray(parsed.verification) ? { verification: [...parsed.verification] } : {}),
@@ -215,6 +255,25 @@ function parseContextGcSubagentLatestMessage(value) {
         ...(typeof value.truncated === 'boolean' ? { truncated: value.truncated } : {})
     };
 }
+function parseContextGcSubagentLatestActivity(value) {
+    if (!isRecord(value) || !isNonemptyString(value.timestamp))
+        return undefined;
+    if (value.kind === 'message' &&
+        Object.keys(value).every((key) => ['kind', 'timestamp', 'phase'].includes(key)) &&
+        (value.phase === 'commentary' || value.phase === 'final_answer'))
+        return { kind: 'message', timestamp: value.timestamp, phase: value.phase };
+    if (value.kind === 'tool' &&
+        Object.keys(value).every((key) => ['kind', 'timestamp', 'toolName', 'status'].includes(key)) &&
+        isNonemptyString(value.toolName) &&
+        (value.status === 'started' || value.status === 'completed' || value.status === 'failed'))
+        return {
+            kind: 'tool',
+            timestamp: value.timestamp,
+            toolName: value.toolName,
+            status: value.status
+        };
+    return undefined;
+}
 function isOptionalSubagentEvidence(value) {
     return (value === undefined ||
         (Array.isArray(value) &&
@@ -236,6 +295,19 @@ function isOptionalNonemptyString(value) {
 function optionalStringMatches(source, terminal) {
     return source === undefined || source === terminal;
 }
+function latestMessageIsCovered(source, retained) {
+    return (source === undefined || (retained !== undefined && stableJson(source) === stableJson(retained)));
+}
+function latestActivityIsCovered(source, retained) {
+    return (source === undefined || (retained !== undefined && stableJson(source) === stableJson(retained)));
+}
+function receiptIsCovered(source, retained) {
+    if (source.messageId === undefined)
+        return true;
+    return (source.messageId === retained.messageId &&
+        source.turnId === retained.turnId &&
+        source.deliveryStatus === retained.deliveryStatus);
+}
 function stringArrayIsCovered(source, terminal) {
     return source === undefined || source.every((item) => terminal?.includes(item) === true);
 }

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

@@ -184,6 +184,21 @@ export declare class JsonlSessionStore {
             source: SessionSource;
         }[];
     }>;
+    listSubagentChildren(parentSessionId: string): Promise<{
+        id: string;
+        title: string;
+        workspace: string;
+        createdAt: string;
+        lastActivityAt: string;
+        source: {
+            readonly type: "subagent";
+            readonly parentSessionId: string;
+            readonly rootSessionId: string;
+            readonly parentExecutionId: string;
+            readonly role: "general-purpose" | "explore";
+            readonly description: string;
+        };
+    }[]>;
     sessionTree(sessionId: string): Promise<readonly string[]>;
     delete(sessionId: string): Promise<{
         readonly deleted: boolean;

package/dist/session/jsonl-store.js

@@ -841,6 +841,21 @@ export class JsonlSessionStore {
             : undefined;
         return { sessions, ...(next ? { nextCursor: next } : {}) };
     }
+    async listSubagentChildren(parentSessionId) {
+        this.#assertOpen();
+        await this.#refreshIndex();
+        return this.#shared.index.sessions
+            .map((session) => ({ session, source: normalizeSessionSource(session.source) }))
+            .filter((item) => item.source.type === 'subagent' && item.source.parentSessionId === parentSessionId)
+            .map(({ session, source }) => ({
+            id: session.id,
+            title: session.title,
+            workspace: session.workspace,
+            createdAt: session.createdAt,
+            lastActivityAt: session.lastActivityAt,
+            source
+        }));
+    }
     async sessionTree(sessionId) {
         this.#assertOpen();
         await this.#refreshIndex();

package/dist/subagent/scheduler.d.ts

@@ -26,6 +26,16 @@ export interface SubagentLatestMessage {
     timestamp: string;
     truncated: boolean;
 }
+export type SubagentLatestActivity = {
+    kind: 'message';
+    timestamp: string;
+    phase: 'commentary' | 'final_answer';
+} | {
+    kind: 'tool';
+    timestamp: string;
+    toolName: string;
+    status: 'started' | 'completed' | 'failed';
+};
 export interface SubagentTaskSnapshot extends Record<string, unknown> {
     agentId: string;
     description: string;
@@ -34,6 +44,7 @@ export interface SubagentTaskSnapshot extends Record<string, unknown> {
     modelName?: string;
     reasoningEffort?: MarAgentReasoningEffort;
     latestMessage?: SubagentLatestMessage;
+    latestActivity?: SubagentLatestActivity;
     summary?: string;
     changedFiles?: string[];
     verification?: string[];
@@ -64,6 +75,7 @@ export interface SubagentController {
     beginExecution?(runner: (task: SubagentTaskInput, signal: AbortSignal) => Promise<SubagentTaskResult>): void;
     run(input: SubagentTaskInput, options?: SubagentRunOptions): Promise<SubagentTaskSnapshot>;
     output(agentId: string, options?: SubagentOutputOptions): Promise<SubagentTaskSnapshot>;
+    outputAny(options?: SubagentOutputOptions): Promise<SubagentTaskSnapshot>;
     message(agentId: string, message: string, options?: SubagentMessageOptions): Promise<SubagentTaskSnapshot>;
     cancel(agentId: string): Promise<SubagentTaskSnapshot>;
     listSessionResources(): readonly {
@@ -86,11 +98,12 @@ export declare class SubagentScheduler implements SubagentController {
     beginExecution(runner: (task: SubagentTaskInput, signal: AbortSignal) => Promise<SubagentTaskResult>): void;
     run(input: SubagentTaskInput, options?: SubagentRunOptions): Promise<SubagentTaskSnapshot>;
     output(agentId: string, options?: SubagentOutputOptions): Promise<SubagentTaskSnapshot>;
+    outputAny(options?: SubagentOutputOptions): Promise<SubagentTaskSnapshot>;
     cancel(agentId: string): Promise<SubagentTaskSnapshot>;
     message(_agentId: string, _message: string): Promise<SubagentTaskSnapshot>;
     listSessionResources(): {
         agentId: string;
-        status: "completed" | "cancelled" | "running" | "queued" | "failed";
+        status: "completed" | "cancelled" | "running" | "failed" | "queued";
         description: string;
     }[];
     dispose(): Promise<void>;

package/dist/subagent/scheduler.js

@@ -6,6 +6,7 @@ export class SubagentScheduler {
     limits;
     #tasks = new Map();
     #queue = [];
+    #completionWaiters = new Set();
     #running = 0;
     #disposed = false;
     #createdInExecution = 0;
@@ -92,9 +93,26 @@ export class SubagentScheduler {
             ? undefined
             : Math.max(options.waitMs, TOOL_EXECUTION_LIMITS.agentWaitWaitFloorMs);
         if (waitMs !== undefined && !['completed', 'failed', 'cancelled'].includes(task.status))
-            await waitForCompletion(task.completion, waitMs, options.signal);
+            await this.#waitForCompletion(task, waitMs, options.signal);
         return this.#public(task);
     }
+    async outputAny(options = {}) {
+        options.signal?.throwIfAborted();
+        validateOutputOptions(options);
+        const tasks = [...this.#tasks.values()];
+        if (tasks.length === 0)
+            throw new MarAgentError('MAR_AGENT_SUBAGENT_NOT_FOUND', 'Subagent task was not found.');
+        const live = tasks.filter((task) => task.status === 'queued' || task.status === 'running');
+        if (live.length === 0 || options.waitMs === 0)
+            return this.#public(live.at(-1) ?? tasks.at(-1));
+        const waitMs = options.waitMs === undefined
+            ? undefined
+            : Math.max(options.waitMs, TOOL_EXECUTION_LIMITS.agentWaitWaitFloorMs);
+        if (waitMs !== undefined)
+            await this.#waitForAnyCompletion(live, waitMs, options.signal);
+        const completed = live.find((task) => task.status !== 'queued' && task.status !== 'running');
+        return this.#public(completed ?? live.at(-1));
+    }
     async cancel(agentId) {
         const task = this.#tasks.get(agentId);
         if (!task)
@@ -115,6 +133,7 @@ export class SubagentScheduler {
                 this.#queue.splice(index, 1);
             task.controller.abort(reason);
             task.resolve();
+            this.#notifyCompletion(task);
             this.#drain();
         }
         else if (task.status === 'running')
@@ -145,6 +164,7 @@ export class SubagentScheduler {
                 .finally(() => {
                 this.#running--;
                 task.resolve();
+                this.#notifyCompletion(task);
                 this.#drain();
             });
         }
@@ -175,6 +195,7 @@ export class SubagentScheduler {
                 task.status = 'cancelled';
                 task.controller.abort();
                 task.resolve();
+                this.#notifyCompletion(task);
             }
             else if (task.status === 'running')
                 task.controller.abort();
@@ -183,6 +204,16 @@ export class SubagentScheduler {
         this.#queue.length = 0;
         this.#tasks.clear();
     }
+    #waitForAnyCompletion(candidates, waitMs, signal) {
+        return waitForCompletionNotification(this.#completionWaiters, (task) => candidates.includes(task), waitMs, signal);
+    }
+    #waitForCompletion(task, waitMs, signal) {
+        return waitForCompletionNotification(this.#completionWaiters, (completed) => completed === task, waitMs, signal);
+    }
+    #notifyCompletion(task) {
+        for (const waiter of this.#completionWaiters)
+            waiter(task);
+    }
 }
 function normalizeResult(result) {
     return {
@@ -217,7 +248,7 @@ function truncateUtf8(value, maximumBytes) {
         end--;
     return bytes.subarray(0, end).toString('utf8');
 }
-function waitForCompletion(completion, waitMs, signal) {
+function waitForCompletionNotification(waiters, accepts, waitMs, signal) {
     return new Promise((resolve, reject) => {
         let settled = false;
         const finish = (error) => {
@@ -226,20 +257,32 @@ function waitForCompletion(completion, waitMs, signal) {
             settled = true;
             clearTimeout(timer);
             signal?.removeEventListener('abort', abort);
+            waiters.delete(notify);
             if (error === undefined)
                 resolve();
             else
                 reject(error);
         };
+        const notify = (value) => {
+            if (accepts(value))
+                finish();
+        };
         const abort = () => finish(signal?.reason ?? new MarAgentError('MAR_AGENT_EXECUTION_CANCELLED', 'Execution cancelled.'));
         const timer = setTimeout(finish, waitMs);
         timer.unref();
+        waiters.add(notify);
         signal?.addEventListener('abort', abort, { once: true });
-        void completion.then(() => finish());
         if (signal?.aborted)
             abort();
     });
 }
+function validateOutputOptions(options) {
+    if (options.waitMs !== undefined &&
+        (!Number.isInteger(options.waitMs) ||
+            options.waitMs < TOOL_EXECUTION_LIMITS.agentWaitMinWaitMs ||
+            options.waitMs > TOOL_EXECUTION_LIMITS.agentWaitMaxWaitMs))
+        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Task wait is invalid.');
+}
 function linkAbort(signal, abort) {
     const listener = () => abort(signal.reason);
     signal.addEventListener('abort', listener, { once: true });

package/dist/subagent/session-controller.d.ts

@@ -42,6 +42,7 @@ export interface SubagentParentExecution {
 }
 export interface PersistedSubagentSession {
     readonly id: string;
+    readonly createdAt: string;
     readonly source: Extract<SessionSource, {
         type: 'subagent';
     }>;
@@ -57,6 +58,7 @@ export interface SubagentSessionControllerBackend {
         readonly id: string;
     }>;
     deleteSession(sessionId: string): Promise<void>;
+    /** Returns children in durable creation order. */
     listChildren(parentSessionId: string): Promise<readonly PersistedSubagentSession[]>;
     loadChild(parentSessionId: string, sessionId: string): Promise<PersistedSubagentSession | undefined>;
 }
@@ -83,11 +85,12 @@ export declare class SubagentSessionController implements SubagentController {
     endParentExecution(executionId: string): void;
     run(input: SubagentTaskInput, options?: SubagentRunOptions): Promise<SubagentTaskSnapshot>;
     output(agentId: string, options?: SubagentOutputOptions): Promise<SubagentTaskSnapshot>;
+    outputAny(options?: SubagentOutputOptions): Promise<SubagentTaskSnapshot>;
     message(agentId: string, message: string, options?: SubagentMessageOptions): Promise<SubagentTaskSnapshot>;
     cancel(agentId: string): Promise<SubagentTaskSnapshot>;
     listSessionResources(): {
         agentId: string;
-        status: "completed" | "cancelled" | "running" | "queued" | "failed" | "interrupted";
+        status: "completed" | "cancelled" | "running" | "failed" | "queued" | "interrupted";
         description: string;
     }[];
     dispose(): Promise<void>;