@myagentroam/agent 0.9.158 → 0.9.160

package/dist/agent-core/subagent/session-controller.js

@@ -11,6 +11,7 @@ export class SubagentSessionController {
     #queue = [];
     #completionWaiters = new Set();
     #activityWaiters = new Set();
+    #nativeObservations = new Map();
     #activityRevision = 0;
     #resourceRevision = 0;
     #running = 0;
@@ -18,6 +19,7 @@ export class SubagentSessionController {
     #creationBudget = { count: 0 };
     #retainedExecution = new AsyncLocalStorage();
     #execution;
+    #pendingDeliveries = new Set();
     constructor(parentSessionId, rootSessionId, backend, limits = { maxTasks: 8, maxConcurrent: 4 }) {
         this.parentSessionId = parentSessionId;
         this.rootSessionId = rootSessionId;
@@ -43,11 +45,11 @@ export class SubagentSessionController {
             await this.#publishTerminal(state);
     }
     /** A retained cell must not borrow a later model Execution's identity or task budget. */
-    captureExecution() {
-        const context = { execution: this.#requireExecution(), budget: this.#creationBudget };
+    captureExecution(executionId) {
+        const enter = this.captureParentFrame(executionId);
         return {
-            run: (input, options) => this.#retainedExecution.run(context, () => this.run(input, options)),
-            message: (id, message, options) => this.#retainedExecution.run(context, () => this.message(id, message, options)),
+            run: (input, options) => enter(() => this.run(input, options)),
+            message: (id, message, options) => enter(() => this.message(id, message, options)),
             output: (id, options) => this.output(id, options),
             outputAny: (options) => this.outputAny(options),
             cancel: (id) => this.cancel(id),
@@ -55,22 +57,84 @@ export class SubagentSessionController {
             dispose: () => this.dispose()
         };
     }
+    /** SDK physical tool ingress shares the same captured parent as its model controls. */
+    captureParentFrame(executionId) {
+        const execution = executionId === undefined ? this.#requireExecution() : this.#execution;
+        if (!execution || (executionId !== undefined && execution.executionId !== executionId))
+            throw new MarAgentError('MAR_AGENT_SUBAGENT_FAILED', 'Parent Execution source is unavailable.');
+        const context = (executionId === undefined
+            ? this.#retainedExecution.getStore()
+            : undefined) ?? {
+            execution,
+            budget: this.#creationBudget
+        };
+        return (run) => this.#retainedExecution.run(context, run);
+    }
+    withOperation(operation, run) {
+        operation.signal.throwIfAborted();
+        if (!operation.operationId.trim())
+            throw new MarAgentError('MAR_AGENT_SUBAGENT_FAILED', 'Parent operation identity is invalid.');
+        return this.#retainedExecution.run({ execution: operation, budget: { count: 0 }, native: true }, run);
+    }
+    async inspect(agentId) {
+        return this.#snapshot(await this.#find(agentId), { full: true });
+    }
+    inspectAll() {
+        if (this.#disposed)
+            throw new MarAgentError('MAR_AGENT_DISPOSED', 'Subagent controller is disposed.');
+        return [...this.#agents.values()].map((state) => this.#snapshot(state, { full: true }));
+    }
+    async cancelOwned(ownerInstanceId) {
+        for (const pending of this.#pendingDeliveries)
+            if (pending.ownerInstanceId === ownerInstanceId)
+                pending.delivery.settled?.('cancelled');
+        const results = await Promise.allSettled([...this.#agents.values()]
+            .filter((state) => state.turn?.ownerInstanceId === ownerInstanceId)
+            .map((state) => this.#control(state, async () => {
+            if (state.turn?.ownerInstanceId === ownerInstanceId)
+                await this.#cancelState(state);
+        })));
+        const failure = results.find((result) => result.status === 'rejected');
+        this.#nativeObservations.delete(ownerInstanceId);
+        if (failure?.status === 'rejected')
+            throw failure.reason;
+    }
     endParentExecution(executionId) {
         if (this.#execution?.executionId === executionId)
             this.#execution = undefined;
     }
+    parentExecution(executionId) {
+        const execution = this.#retainedExecution.getStore()?.execution ?? this.#execution;
+        return execution?.executionId === executionId ? { ...execution, executionId } : undefined;
+    }
     async run(input, options = {}) {
         options.signal?.throwIfAborted();
+        options.turnSignal?.throwIfAborted();
+        if (options.waitFor !== undefined &&
+            options.waitFor !== 'start' &&
+            options.waitFor !== 'completion')
+            throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Task start wait is invalid.');
         const execution = this.#requireExecution();
-        validateTaskInput(input);
-        if ((this.#retainedExecution.getStore()?.budget ?? this.#creationBudget).count >=
-            this.limits.maxTasks)
+        const native = this.#retainedExecution.getStore()?.native === true;
+        validateTaskInput(input, native);
+        if (!native &&
+            (this.#retainedExecution.getStore()?.budget ?? this.#creationBudget).count >=
+                this.limits.maxTasks)
             throw new MarAgentError('MAR_AGENT_SUBAGENT_LIMIT', 'Subagent task limit was reached.');
         const source = {
             type: 'subagent',
             parentSessionId: this.parentSessionId,
             rootSessionId: this.rootSessionId,
-            parentExecutionId: execution.executionId,
+            ...(execution.executionId === undefined ? {} : { parentExecutionId: execution.executionId }),
+            ...(native && 'operationId' in execution
+                ? {
+                    parentOperationId: execution.operationId,
+                    ...(execution.ownerInstanceId === undefined
+                        ? {}
+                        : { ownerInstanceId: execution.ownerInstanceId }),
+                    ...(execution.extensionId === undefined ? {} : { extensionId: execution.extensionId })
+                }
+                : {}),
             role: input.role,
             description: input.description.trim()
         };
@@ -81,7 +145,9 @@ export class SubagentSessionController {
         try {
             if (this.#disposed)
                 throw new MarAgentError('MAR_AGENT_DISPOSED', 'Subagent controller is disposed.');
+            this.#requireExecution();
             options.signal?.throwIfAborted();
+            options.turnSignal?.throwIfAborted();
         }
         catch (error) {
             await this.#deleteUnstartedSession(created.id, error);
@@ -90,6 +156,8 @@ export class SubagentSessionController {
             agentId: created.id,
             description: source.description,
             role: input.role,
+            ...(source.ownerInstanceId === undefined ? {} : { ownerInstanceId: source.ownerInstanceId }),
+            ...(source.extensionId === undefined ? {} : { extensionId: source.extensionId }),
             status: 'queued',
             messageRevision: 0,
             observedMessageRevision: 0,
@@ -101,7 +169,8 @@ export class SubagentSessionController {
             terminalObserved: false,
             resourceRevision: ++this.#resourceRevision
         };
-        (this.#retainedExecution.getStore()?.budget ?? this.#creationBudget).count++;
+        if (!native)
+            (this.#retainedExecution.getStore()?.budget ?? this.#creationBudget).count++;
         this.#agents.set(state.agentId, state);
         const knownModel = execution.models.get(input.modelId ?? execution.modelId);
         if (knownModel) {
@@ -121,6 +190,7 @@ export class SubagentSessionController {
             await options.onCreated?.(this.#receiptSnapshot(state));
             if (this.#disposed)
                 throw new MarAgentError('MAR_AGENT_DISPOSED', 'Subagent controller is disposed.');
+            this.#requireExecution();
             options.signal?.throwIfAborted();
         }
         catch (error) {
@@ -128,11 +198,11 @@ export class SubagentSessionController {
         }
         if (state.status === 'failed') {
             await this.#publishTerminal(state);
-            state.terminalObserved = true;
+            this.#observeTerminal(state);
             return this.#snapshot(state);
         }
-        this.#queueTurn(state, input.prompt, execution.startTurn, []);
-        if (input.background)
+        this.#queueTurn(state, input.prompt, execution, [], undefined, undefined, options.signal, options.turnSignal);
+        if (options.waitFor === 'start' || (options.waitFor === undefined && input.background))
             return this.#receiptSnapshot(state);
         await waitForPromise(state.turn.completion, options.signal);
         const includeLatestMessage = this.#hasUnreadMessage(state);
@@ -144,7 +214,19 @@ export class SubagentSessionController {
         options.signal?.throwIfAborted();
         const state = await this.#find(agentId);
         options.signal?.throwIfAborted();
-        validateOutputOptions(options);
+        validateOutputOptions(options, this.#retainedExecution.getStore()?.native === true);
+        if (options.untilSettled) {
+            if (state.turn)
+                await waitForPromise(state.turn.completion, options.signal);
+            options.signal?.throwIfAborted();
+            const includeLatestMessage = this.#hasUnreadMessage(state);
+            const includeTerminalDetails = this.#observeTerminal(state);
+            this.#observeLatestMessage(state);
+            return {
+                ...this.#snapshot(state, { includeLatestMessage, includeTerminalDetails }),
+                waitOutcome: 'completion'
+            };
+        }
         if (options.waitMs === undefined || options.waitMs === 0)
             return {
                 ...this.#snapshot(state, {
@@ -167,7 +249,9 @@ export class SubagentSessionController {
             this.#observeLatestMessage(state);
             return { ...this.#snapshot(state), waitOutcome: 'message' };
         }
-        const waitMs = Math.max(options.waitMs, TOOL_EXECUTION_LIMITS.agentWaitWaitFloorMs);
+        const waitMs = this.#retainedExecution.getStore()?.native
+            ? options.waitMs
+            : Math.max(options.waitMs, TOOL_EXECUTION_LIMITS.agentWaitWaitFloorMs);
         if (waitFor === 'completion') {
             const completed = await this.#waitForCompletion(state, waitMs, options.signal);
             options.signal?.throwIfAborted();
@@ -201,7 +285,9 @@ export class SubagentSessionController {
     }
     async outputAny(options = {}) {
         options.signal?.throwIfAborted();
-        validateOutputOptions(options);
+        if (options.untilSettled)
+            throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'An unbounded wait requires an agent id.');
+        validateOutputOptions(options, this.#retainedExecution.getStore()?.native === true);
         const states = [...this.#agents.values()];
         if (states.length === 0)
             throw new MarAgentError('MAR_AGENT_SUBAGENT_NOT_FOUND', 'Subagent was not found.');
@@ -232,7 +318,9 @@ export class SubagentSessionController {
                 return { ...this.#snapshot(pending), waitOutcome: 'message' };
             }
         }
-        const waitMs = Math.max(options.waitMs, TOOL_EXECUTION_LIMITS.agentWaitWaitFloorMs);
+        const waitMs = this.#retainedExecution.getStore()?.native
+            ? options.waitMs
+            : Math.max(options.waitMs, TOOL_EXECUTION_LIMITS.agentWaitWaitFloorMs);
         if (waitFor === 'message') {
             const activity = await this.#waitForMessageOrCompletion(live, waitMs, options.signal);
             options.signal?.throwIfAborted();
@@ -272,7 +360,8 @@ export class SubagentSessionController {
         const execution = this.#requireExecution();
         if (typeof message !== 'string' ||
             message.trim().length === 0 ||
-            Buffer.byteLength(message) > TOOL_EXECUTION_LIMITS.subagentMessageMaxBytes ||
+            (this.#retainedExecution.getStore()?.native !== true &&
+                Buffer.byteLength(message) > TOOL_EXECUTION_LIMITS.subagentMessageMaxBytes) ||
             (options.delivery !== undefined &&
                 options.delivery !== 'append' &&
                 options.delivery !== 'replace'))
@@ -290,41 +379,49 @@ export class SubagentSessionController {
             const turnId = state.turn?.turnId ?? randomUUID();
             const receipt = { messageId: randomUUID(), turnId, deliveryStatus: 'accepted' };
             const mutableReceipt = receipt;
-            const delivery = {
-                messageId: receipt.messageId,
-                applied: () => {
-                    mutableReceipt.deliveryStatus = 'applied';
+            const delivery = this.#createDelivery(state, execution, mutableReceipt, options.signal);
+            try {
+                if (state.status === 'running' && state.turn) {
+                    const turn = state.turn;
+                    if (!turn.handle)
+                        await turn.handleReady;
+                    this.#requireExecution();
+                    options.signal?.throwIfAborted();
+                    delivery.signal?.throwIfAborted();
+                    if (state.status === 'running' &&
+                        state.turn === turn &&
+                        turn.handle?.enqueueMessage(message, delivery)) {
+                        delivery.accepted();
+                        state.receipt = mutableReceipt;
+                        return this.#messageReceiptSnapshot(state);
+                    }
+                    await turn.completion;
                 }
-            };
-            if (state.status === 'running' && state.turn) {
-                const turn = state.turn;
-                if (!turn.handle)
-                    await turn.handleReady;
-                this.#requireExecution();
-                options.signal?.throwIfAborted();
-                if (state.status === 'running' &&
-                    state.turn === turn &&
-                    turn.handle?.enqueueMessage(message, delivery)) {
+                else if (state.status === 'queued' && state.turn) {
+                    delivery.accepted();
+                    state.turn.pendingMessages.push({ text: message, delivery });
                     state.receipt = mutableReceipt;
                     return this.#messageReceiptSnapshot(state);
                 }
-                await turn.completion;
-            }
-            else if (state.status === 'queued' && state.turn) {
-                state.turn.pendingMessages.push({ text: message, delivery });
+                this.#requireExecution();
+                options.signal?.throwIfAborted();
+                delivery.signal?.throwIfAborted();
+                state.modelId = selected.id;
+                state.modelName = selected.name;
+                state.reasoningEffort = selected.reasoningEffort;
+                // A closing turn may have rejected append; reserve a fresh identity for its successor.
+                mutableReceipt.turnId = randomUUID();
+                delivery.accepted();
                 state.receipt = mutableReceipt;
+                this.#queueTurn(state, message, execution, [], mutableReceipt.turnId, delivery, options.signal);
                 return this.#messageReceiptSnapshot(state);
             }
-            this.#requireExecution();
-            options.signal?.throwIfAborted();
-            state.modelId = selected.id;
-            state.modelName = selected.name;
-            state.reasoningEffort = selected.reasoningEffort;
-            // A closing turn may have rejected append; reserve a fresh identity for its successor.
-            mutableReceipt.turnId = randomUUID();
-            state.receipt = mutableReceipt;
-            this.#queueTurn(state, message, execution.startTurn, [], mutableReceipt.turnId, delivery);
-            return this.#messageReceiptSnapshot(state);
+            catch (error) {
+                delivery.settled?.(options.signal?.aborted || ('signal' in execution && execution.signal.aborted)
+                    ? 'cancelled'
+                    : 'failed');
+                throw error;
+            }
         });
     }
     async cancel(agentId) {
@@ -350,6 +447,7 @@ export class SubagentSessionController {
             this.#closeReceipt(state);
             state.terminalPending = true;
             await this.#publishTerminal(state);
+            state.turn.resolveHandleReady();
             state.turn.resolve();
             this.#notifyCompletion(state);
             delete state.turn;
@@ -385,9 +483,12 @@ export class SubagentSessionController {
         if (this.#disposed)
             return;
         this.#disposed = true;
+        for (const pending of this.#pendingDeliveries)
+            pending.delivery.settled?.('cancelled');
         for (const state of this.#queue.splice(0)) {
             state.status = 'cancelled';
             this.#closeReceipt(state);
+            state.turn?.resolveHandleReady();
             state.turn?.resolve();
             this.#notifyCompletion(state);
             delete state.turn;
@@ -402,12 +503,22 @@ export class SubagentSessionController {
         }
         await Promise.allSettled([...this.#agents.values()].flatMap((state) => state.turn === undefined ? [] : [state.turn.completion]));
         this.#execution = undefined;
+        this.#nativeObservations.clear();
     }
-    #queueTurn(state, prompt, start, pendingMessages, turnId = randomUUID(), delivery) {
+    #queueTurn(state, prompt, execution, pendingMessages, turnId = randomUUID(), delivery, signal, turnSignal) {
         let resolve;
         let resolveHandleReady;
         const completion = new Promise((done) => (resolve = done));
         const handleReady = new Promise((done) => (resolveHandleReady = done));
+        const native = this.#retainedExecution.getStore()?.native === true && 'operationId' in execution
+            ? execution
+            : undefined;
+        const sourceSignal = turnSignal ??
+            (native === undefined
+                ? undefined
+                : signal === undefined
+                    ? native.signal
+                    : AbortSignal.any([native.signal, signal]));
         state.status = 'queued';
         this.#touchResource(state);
         delete state.summary;
@@ -417,19 +528,37 @@ export class SubagentSessionController {
         state.verification = [];
         state.evidence = [];
         state.terminalPending = false;
+        state.terminalObserved = false;
         state.turn = {
             turnId,
+            ...(native?.ownerInstanceId === undefined ? {} : { ownerInstanceId: native.ownerInstanceId }),
+            ...(native?.origin === undefined
+                ? {}
+                : { origin: Object.freeze({ ...native.origin, signal: sourceSignal }) }),
             ...(delivery === undefined ? {} : { delivery }),
             prompt,
-            start,
+            start: execution.startTurn,
             pendingMessages,
             handleReady,
             completion,
-            resolve,
+            resolve: () => {
+                sourceSignal?.removeEventListener('abort', abort);
+                resolve();
+            },
             resolveHandleReady
         };
+        const turn = state.turn;
+        const abort = () => {
+            void this.#control(state, async () => {
+                if (state.turn === turn)
+                    await this.#cancelState(state);
+            }).catch(() => undefined);
+        };
+        sourceSignal?.addEventListener('abort', abort, { once: true });
         this.#queue.push(state);
         this.#drain();
+        if (sourceSignal?.aborted)
+            abort();
     }
     #drain() {
         while (!this.#disposed && this.#running < this.limits.maxConcurrent && this.#queue.length > 0) {
@@ -448,6 +577,7 @@ export class SubagentSessionController {
             turn.handle = await turn.start({
                 turnId: turn.turnId,
                 ...(turn.delivery === undefined ? {} : { delivery: turn.delivery }),
+                ...(turn.origin === undefined ? {} : { origin: turn.origin }),
                 sessionId: state.agentId,
                 prompt: turn.prompt,
                 modelId: state.modelId,
@@ -482,7 +612,7 @@ export class SubagentSessionController {
             await consume;
             if (result.status === 'completed') {
                 state.status = 'completed';
-                state.summary = truncateUtf8(result.finalAnswer, TOOL_EXECUTION_LIMITS.subagentSummaryMaxBytes);
+                state.summary = result.finalAnswer;
             }
             else if (result.status === 'cancelled')
                 state.status = 'cancelled';
@@ -558,7 +688,21 @@ export class SubagentSessionController {
             waiter(activity);
     }
     #hasUnreadMessage(state) {
-        return state.messageRevision > state.observedMessageRevision;
+        return (state.messageRevision >
+            (this.#nativeObservation(state)?.messageRevision ?? state.observedMessageRevision));
+    }
+    #nativeObservation(state) {
+        const context = this.#retainedExecution.getStore();
+        if (!context?.native || !('operationId' in context.execution))
+            return undefined;
+        const owner = context.execution.ownerInstanceId ?? context.execution.operationId;
+        let observations = this.#nativeObservations.get(owner);
+        if (!observations)
+            this.#nativeObservations.set(owner, (observations = new Map()));
+        let observation = observations.get(state.agentId);
+        if (!observation)
+            observations.set(state.agentId, (observation = { messageRevision: 0, terminalRevision: 0 }));
+        return observation;
     }
     #oldestUnreadMessage(states) {
         return states
@@ -567,17 +711,79 @@ export class SubagentSessionController {
             .at(0);
     }
     #observeLatestMessage(state) {
-        state.observedMessageRevision = state.messageRevision;
+        const native = this.#nativeObservation(state);
+        if (native)
+            native.messageRevision = state.messageRevision;
+        else
+            state.observedMessageRevision = state.messageRevision;
     }
     #observeTerminal(state) {
+        const native = this.#nativeObservation(state);
+        if (native) {
+            if (!isTerminalState(state) || native.terminalRevision === state.resourceRevision)
+                return false;
+            native.terminalRevision = state.resourceRevision;
+            return true;
+        }
         if (!isTerminalState(state) || state.terminalObserved)
             return false;
         state.terminalObserved = true;
         return true;
     }
+    #createDelivery(state, execution, receipt, signal) {
+        const native = this.#retainedExecution.getStore()?.native === true && 'operationId' in execution
+            ? execution
+            : undefined;
+        const sourceSignal = native === undefined
+            ? undefined
+            : signal === undefined
+                ? native.signal
+                : AbortSignal.any([native.signal, signal]);
+        const controller = new AbortController();
+        const release = () => {
+            sourceSignal?.removeEventListener('abort', abort);
+            this.#pendingDeliveries.delete(pending);
+        };
+        const delivery = {
+            accepted: () => {
+                pending.admitted = true;
+            },
+            messageId: receipt.messageId,
+            ...(native?.origin === undefined ? {} : { origin: native.origin }),
+            ...(native === undefined ? {} : { signal: controller.signal }),
+            applied: () => {
+                // A durable commit remains applied even if cancellation races its completion callback.
+                receipt.deliveryStatus = 'applied';
+                release();
+            },
+            settled: (status) => {
+                if (receipt.deliveryStatus !== 'accepted')
+                    return;
+                receipt.deliveryStatus = status;
+                controller.abort(new MarAgentError('MAR_AGENT_CANCELLED', 'Agent message was cancelled.'));
+                release();
+            }
+        };
+        const pending = {
+            state,
+            receipt,
+            delivery,
+            admitted: false,
+            ...(native?.ownerInstanceId === undefined ? {} : { ownerInstanceId: native.ownerInstanceId })
+        };
+        const abort = () => delivery.settled?.('cancelled');
+        this.#pendingDeliveries.add(pending);
+        sourceSignal?.addEventListener('abort', abort, { once: true });
+        if (sourceSignal?.aborted)
+            abort();
+        return delivery;
+    }
     #closeReceipt(state) {
-        if (state.receipt?.deliveryStatus === 'accepted' && state.receipt.turnId === state.turn?.turnId)
-            state.receipt.deliveryStatus = state.status === 'cancelled' ? 'cancelled' : 'failed';
+        for (const pending of this.#pendingDeliveries)
+            if (pending.admitted &&
+                pending.state === state &&
+                pending.receipt.turnId === state.turn?.turnId)
+                pending.delivery.settled?.(state.status === 'cancelled' ? 'cancelled' : 'failed');
     }
     async #deleteUnstartedSession(agentId, error) {
         this.#agents.delete(agentId);
@@ -608,6 +814,8 @@ export class SubagentSessionController {
         const execution = this.#retainedExecution.getStore()?.execution ?? this.#execution;
         if (!execution)
             throw new MarAgentError('MAR_AGENT_SUBAGENT_FAILED', 'Subagent control requires an active parent execution.');
+        if ('signal' in execution)
+            execution.signal.throwIfAborted();
         return execution;
     }
     #receiptSnapshot(state) {
@@ -631,15 +839,22 @@ export class SubagentSessionController {
         const includeLatestMessage = options.includeLatestMessage ?? true;
         const includeLatestActivity = options.includeLatestActivity ?? true;
         const includeTerminalDetails = options.includeTerminalDetails ?? true;
+        const full = options.full ?? this.#retainedExecution.getStore()?.native === true;
         const latestMessage = !includeLatestMessage || state.latestMessage === undefined
             ? undefined
-            : terminal
+            : full
                 ? { ...state.latestMessage }
-                : compactRunningLatestMessage(state.latestMessage);
+                : projectLatestMessage(state.latestMessage, terminal);
         return {
             agentId: state.agentId,
             description: state.description,
             status: state.status,
+            ...(full && this.#retainedExecution.getStore()?.native === true
+                ? {
+                    role: state.role,
+                    ...(state.extensionId === undefined ? {} : { extensionId: state.extensionId })
+                }
+                : {}),
             ...state.receipt,
             ...(state.modelId === undefined ? {} : { modelId: state.modelId }),
             ...(state.modelName === undefined ? {} : { modelName: state.modelName }),
@@ -648,16 +863,36 @@ export class SubagentSessionController {
             ...(!includeLatestActivity || state.latestActivity === undefined
                 ? {}
                 : { latestActivity: { ...state.latestActivity } }),
-            ...(!includeTerminalDetails || state.summary === undefined ? {} : { summary: state.summary }),
+            ...(!includeTerminalDetails || state.summary === undefined
+                ? {}
+                : {
+                    summary: full
+                        ? state.summary
+                        : truncateUtf8(state.summary, TOOL_EXECUTION_LIMITS.subagentSummaryMaxBytes)
+                }),
             ...(!includeTerminalDetails || !terminal || state.changedFiles.length === 0
                 ? {}
-                : { changedFiles: [...state.changedFiles] }),
+                : {
+                    changedFiles: full
+                        ? [...state.changedFiles]
+                        : state.changedFiles.slice(0, TOOL_EXECUTION_LIMITS.subagentChangedFilesMaxItems)
+                }),
             ...(!includeTerminalDetails || !terminal || state.verification.length === 0
                 ? {}
-                : { verification: [...state.verification] }),
+                : {
+                    verification: full
+                        ? [...state.verification]
+                        : state.verification
+                            .slice(0, TOOL_EXECUTION_LIMITS.subagentVerificationMaxItems)
+                            .map((text) => truncateUtf8(text, 2_000))
+                }),
             ...(!includeTerminalDetails || !terminal || state.evidence.length === 0
                 ? {}
-                : { evidence: state.evidence.map((item) => ({ ...item })) }),
+                : {
+                    evidence: (full
+                        ? state.evidence
+                        : state.evidence.slice(0, TOOL_EXECUTION_LIMITS.subagentEvidenceMaxItems)).map((item) => ({ ...item }))
+                }),
             ...(state.errorCode === undefined ? {} : { errorCode: state.errorCode }),
             ...(state.errorMessage === undefined ? {} : { errorMessage: state.errorMessage })
         };
@@ -666,7 +901,7 @@ export class SubagentSessionController {
         if (!state.terminalPending || !this.#execution)
             return;
         try {
-            await this.#execution.emitTerminal(this.#snapshot(state));
+            await this.#execution.emitTerminal(this.#snapshot(state, { full: false }));
             state.terminalPending = false;
         }
         catch {
@@ -674,25 +909,31 @@ export class SubagentSessionController {
         }
     }
 }
-function compactRunningLatestMessage(message) {
-    if (message.phase !== 'commentary')
-        return { ...message };
-    const text = truncateCharacters(message.text, TOOL_EXECUTION_LIMITS.subagentRunningLatestMessageMaxCharacters);
+function projectLatestMessage(message, terminal) {
+    const text = truncateCharacters(message.text, !terminal && message.phase === 'commentary'
+        ? TOOL_EXECUTION_LIMITS.subagentRunningLatestMessageMaxCharacters
+        : 10_000);
     return {
         ...message,
         text,
         truncated: message.truncated === true || text !== message.text
     };
 }
-function validateTaskInput(input) {
-    if (input.parentSubagentId ||
+function validateTaskInput(input, native = false) {
+    if (!input ||
+        typeof input !== 'object' ||
+        typeof input.description !== 'string' ||
+        typeof input.prompt !== 'string' ||
+        (input.role !== 'general-purpose' && input.role !== 'explore') ||
+        input.parentSubagentId ||
         !input.description.trim() ||
-        input.description.length > TOOL_EXECUTION_LIMITS.subagentDescriptionMaxCharacters ||
+        (!native &&
+            input.description.length > TOOL_EXECUTION_LIMITS.subagentDescriptionMaxCharacters) ||
         !input.prompt.trim() ||
-        Buffer.byteLength(input.prompt) > TOOL_EXECUTION_LIMITS.subagentPromptMaxBytes)
-        throw new MarAgentError(input.parentSubagentId
+        (!native && Buffer.byteLength(input.prompt) > TOOL_EXECUTION_LIMITS.subagentPromptMaxBytes))
+        throw new MarAgentError(input?.parentSubagentId
             ? 'MAR_AGENT_SUBAGENT_RECURSION_DISABLED'
-            : 'MAR_AGENT_TOOL_INPUT_INVALID', input.parentSubagentId ? 'Subagents cannot create subagents.' : 'Subagent task is invalid.');
+            : 'MAR_AGENT_TOOL_INPUT_INVALID', input?.parentSubagentId ? 'Subagents cannot create subagents.' : 'Subagent task is invalid.');
 }
 function resolveModel(execution, input) {
     const modelId = input.modelId ?? execution.modelId;
@@ -726,7 +967,7 @@ function resolveExistingModel(execution, state) {
     };
 }
 function restoreAgentState(session) {
-    const delivered = session.records.findLast((record) => record.type === 'turn.user' &&
+    const delivered = session.records.findLast((record) => (record.type === 'turn.user' || record.type === 'extension.input') &&
         isRecord(record.payload) &&
         typeof record.payload.messageId === 'string' &&
         typeof record.turnId === 'string');
@@ -739,6 +980,12 @@ function restoreAgentState(session) {
         agentId: session.id,
         description: session.source.description,
         role: session.source.role,
+        ...(session.source.ownerInstanceId === undefined
+            ? {}
+            : { ownerInstanceId: session.source.ownerInstanceId }),
+        ...(session.source.extensionId === undefined
+            ? {}
+            : { extensionId: session.source.extensionId }),
         status: terminalType === 'execution.completed'
             ? 'completed'
             : terminalType === 'execution.failed'
@@ -780,7 +1027,7 @@ function restoreAgentState(session) {
     }
     state.observedMessageRevision = state.messageRevision;
     if (state.status === 'completed' && state.latestMessage?.phase === 'final_answer')
-        state.summary = truncateUtf8(state.latestMessage.text, TOOL_EXECUTION_LIMITS.subagentSummaryMaxBytes);
+        state.summary = state.latestMessage.text;
     if (state.status === 'failed' && terminal && isRecord(terminal.payload)) {
         if (typeof terminal.payload.code === 'string')
             state.errorCode = terminal.payload.code;
@@ -832,10 +1079,7 @@ function observeAgentEvent(state, event) {
             if (!isRecord(file))
                 continue;
             for (const path of [file.path, file.targetPath])
-                if (typeof path === 'string' &&
-                    path.length > 0 &&
-                    !state.changedFiles.includes(path) &&
-                    state.changedFiles.length < TOOL_EXECUTION_LIMITS.subagentChangedFilesMaxItems)
+                if (typeof path === 'string' && path.length > 0 && !state.changedFiles.includes(path))
                     state.changedFiles.push(path);
         }
     }
@@ -843,10 +1087,7 @@ function observeAgentEvent(state, event) {
         const data = event.data;
         const results = Array.isArray(data.results) ? data.results : [];
         for (const result of results) {
-            if (!isRecord(result) ||
-                typeof result.path !== 'string' ||
-                result.error !== undefined ||
-                state.evidence.length >= TOOL_EXECUTION_LIMITS.subagentEvidenceMaxItems)
+            if (!isRecord(result) || typeof result.path !== 'string' || result.error !== undefined)
                 continue;
             const evidence = {
                 path: result.path,
@@ -857,9 +1098,8 @@ function observeAgentEvent(state, event) {
                 state.evidence.push(evidence);
         }
     }
-    else if (event.toolName === 'exec' &&
-        state.verification.length < TOOL_EXECUTION_LIMITS.subagentVerificationMaxItems)
-        state.verification.push(truncateUtf8(event.summary, 2_000));
+    else if (event.toolName === 'exec')
+        state.verification.push(event.summary);
     return false;
 }
 function eventType(record) {
@@ -868,7 +1108,7 @@ function eventType(record) {
         : undefined;
 }
 function latestMessageFromEvent(event) {
-    const text = truncateCharacters(event.text, 10_000);
+    const text = event.text;
     return {
         itemId: event.itemId,
         turnId: event.turnId ?? '',
@@ -885,7 +1125,7 @@ function latestMessageFromPayload(payload) {
         typeof payload.text !== 'string' ||
         typeof payload.timestamp !== 'string')
         return undefined;
-    const text = truncateCharacters(payload.text, 10_000);
+    const text = payload.text;
     return {
         itemId: payload.itemId,
         turnId: payload.turnId,
@@ -931,7 +1171,7 @@ function waitForCompletionNotification(waiters, accepts, waitMs, signal) {
             if (settled)
                 return;
             settled = true;
-            clearTimeout(timer);
+            cancelTimer();
             signal?.removeEventListener('abort', abort);
             waiters.delete(notify);
             if (error === undefined)
@@ -943,14 +1183,13 @@ function waitForCompletionNotification(waiters, accepts, waitMs, signal) {
             if (!accepts(value) || settled)
                 return;
             settled = true;
-            clearTimeout(timer);
+            cancelTimer();
             signal?.removeEventListener('abort', abort);
             waiters.delete(notify);
             resolve(value);
         };
         const abort = () => finish(signal?.reason ?? new MarAgentError('MAR_AGENT_EXECUTION_CANCELLED', 'Execution cancelled.'));
-        const timer = setTimeout(finish, waitMs);
-        timer.unref();
+        const cancelTimer = waitDeadline(waitMs, () => finish());
         waiters.add(notify);
         signal?.addEventListener('abort', abort, { once: true });
         if (signal?.aborted)
@@ -964,7 +1203,7 @@ function waitForNotification(waiters, accepts, current, waitMs, signal) {
             if (settled)
                 return;
             settled = true;
-            clearTimeout(timer);
+            cancelTimer();
             signal?.removeEventListener('abort', abort);
             waiters.delete(notify);
             if (error === undefined)
@@ -977,8 +1216,7 @@ function waitForNotification(waiters, accepts, current, waitMs, signal) {
                 finish(value);
         };
         const abort = () => finish(undefined, signal?.reason ?? new MarAgentError('MAR_AGENT_EXECUTION_CANCELLED', 'Execution cancelled.'));
-        const timer = setTimeout(() => finish(), waitMs);
-        timer.unref();
+        const cancelTimer = waitDeadline(waitMs, () => finish());
         waiters.add(notify);
         signal?.addEventListener('abort', abort, { once: true });
         if (signal?.aborted)
@@ -990,14 +1228,16 @@ function waitForNotification(waiters, accepts, current, waitMs, signal) {
         }
     });
 }
-function validateOutputOptions(options) {
-    if ((options.waitFor !== undefined &&
-        options.waitFor !== 'completion' &&
-        options.waitFor !== 'message') ||
+function validateOutputOptions(options, native = false) {
+    if ((options.untilSettled !== undefined && options.untilSettled !== true) ||
+        (options.untilSettled === true && options.waitFor === 'message') ||
+        (options.waitFor !== undefined &&
+            options.waitFor !== 'completion' &&
+            options.waitFor !== 'message') ||
         (options.waitMs !== undefined &&
-            (!Number.isInteger(options.waitMs) ||
+            (!Number.isSafeInteger(options.waitMs) ||
                 options.waitMs < TOOL_EXECUTION_LIMITS.agentWaitMinWaitMs ||
-                options.waitMs > TOOL_EXECUTION_LIMITS.agentWaitMaxWaitMs)))
+                (!native && options.waitMs > TOOL_EXECUTION_LIMITS.agentWaitMaxWaitMs))))
         throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Task wait is invalid.');
 }
 function isTerminalState(state) {
@@ -1032,3 +1272,20 @@ function waitForPromise(promise, signal) {
             abort();
     });
 }
+/** Explicit waits retain their deadline without overflowing the platform timer. */
+function waitDeadline(waitMs, finish) {
+    const deadline = performance.now() + waitMs;
+    let timer;
+    const tick = () => {
+        const remaining = deadline - performance.now();
+        if (remaining <= 0)
+            finish();
+        else
+            arm(remaining);
+    };
+    const arm = (remaining) => {
+        timer = setTimeout(tick, Math.min(remaining, 2_147_483_647));
+    };
+    arm(waitMs);
+    return () => clearTimeout(timer);
+}