@myagentroam/agent 0.9.139 → 0.9.140

package/dist/host/local-agent-host.d.ts

@@ -1,6 +1,6 @@
 import type { CodeModeEngineFactory } from '../tools/code-mode/engine.js';
 import type { HostDescription } from './contracts.js';
-import type { LocalProcessExecutor } from './local-process-executor.js';
+import { type LocalProcessExecutor } from './local-process-executor.js';
 import type { WorkspacePathMount } from '../tools/shared/path-resolver.js';
 import type { MarAgentEvent, MarAgentHost, HostExecutionExtensions, McpToolCatalogContext, McpToolCatalog, McpToolCallContext, ToolCall, ToolExecutionContext, ToolExecutionResult } from '../sdk/types.js';
 export interface LocalAgentMcpBinding {
@@ -13,6 +13,8 @@ export interface LocalAgentExecutionMcpBinding extends LocalAgentMcpBinding {
     readonly extensions?: LocalAgentExecutionExtensions;
 }
 export interface LocalAgentExecutionExtensions extends HostExecutionExtensions {
+    /** Host-private process environment, snapshotted when bound to an execution. */
+    readonly environment?: Readonly<Record<string, string>>;
     executeTool?(call: ToolCall, context: ToolExecutionContext): Promise<ToolExecutionResult>;
 }
 export declare class LocalAgentHost implements MarAgentHost {

package/dist/host/local-agent-host.js

@@ -2,6 +2,7 @@ import { existsSync } from 'node:fs';
 import { createHash, randomUUID } from 'node:crypto';
 import { mkdir } from 'node:fs/promises';
 import { basename, delimiter, isAbsolute, join, resolve, win32 } from 'node:path';
+import { directLocalProcessExecutor } from './local-process-executor.js';
 import { MAR_AGENT_HOST_API_VERSION } from './contracts.js';
 import { MarAgentError } from '../error.js';
 import { LocalToolRegistry } from '../tools/local-registry.js';
@@ -36,6 +37,7 @@ export class LocalAgentHost {
         this.#hasWebSearch = input.webSearch !== undefined;
         this.#hasWebFetch = input.webFetch !== false;
         this.#resourceIdleTtlMs = input.resourceIdleTtlMs;
+        const processExecutor = input.processExecutor ?? directLocalProcessExecutor;
         this.#tools = new LocalToolRegistry(this.#workspace, this.#environment, this.#shell.path, {
             ...(input.webSearch ? { webSearch: input.webSearch } : {}),
             webFetch: this.#hasWebFetch,
@@ -44,7 +46,25 @@ export class LocalAgentHost {
             ...(input.codeModeEngineFactory === undefined
                 ? {}
                 : { codeModeEngineFactory: input.codeModeEngineFactory }),
-            ...(input.processExecutor === undefined ? {} : { processExecutor: input.processExecutor }),
+            processExecutor: {
+                spawn: (request) => {
+                    const binding = request.owner && this.#executionMcp.get(request.owner.executionId);
+                    const environment = binding?.active ? binding.extensions?.environment : undefined;
+                    return processExecutor.spawn(environment === undefined
+                        ? request
+                        : {
+                            ...request,
+                            environment: { ...request.environment, ...environment },
+                            ...(request.environmentKeys === undefined
+                                ? {}
+                                : {
+                                    environmentKeys: [
+                                        ...new Set([...request.environmentKeys, ...Object.keys(environment)])
+                                    ]
+                                })
+                        });
+                }
+            },
             ...(input.restrictPaths === undefined ? {} : { restrictPaths: input.restrictPaths }),
             ...(input.workspaceWritable === undefined
                 ? {}
@@ -108,7 +128,12 @@ export class LocalAgentHost {
                 (async () => {
                     throw new MarAgentError('MAR_AGENT_MCP_FAILED', 'MCP execution is unavailable.');
                 }),
-            extensions,
+            extensions: {
+                ...extensions,
+                ...(extensions.environment === undefined
+                    ? {}
+                    : { environment: { ...extensions.environment } })
+            },
             active: true
         };
         this.#currentExecutionMcp = binding;
@@ -116,7 +141,8 @@ export class LocalAgentHost {
     }
     async listExecutionExtensions(context) {
         const binding = this.#executionBinding(context);
-        return binding?.extensions ?? this.#extensions ?? {};
+        const { environment: _environment, ...extensions } = binding?.extensions ?? this.#extensions ?? {};
+        return extensions;
     }
     emit(event) {
         this.events.push(event);

package/dist/prompts/resources.js

@@ -12,7 +12,9 @@ export function retainedSessionResourcesSnapshot(input) {
             ]
             : []),
         'These resources belong to this Session and survived the previous Execution. Reuse their stable IDs instead of starting duplicate processes or subagents.',
-        processes.length === 0 ? '' : 'Cancelling a managed process releases that process resource.',
+        processes.length === 0
+            ? ''
+            : 'Use exec_wait with processId to wait, write stdin or cancel; in Code Mode use tools.exec_wait. Cancelling a wait leaves the process running; explicit cancel releases the process resource.',
         subagents.length === 0
             ? ''
             : 'agent_cancel stops only the current child turn and retains its Session for later messages or explicit deletion.',
@@ -40,7 +42,7 @@ export function retainedSessionResourcesUpdate(snapshot, previousSnapshot, previ
         return undefined;
     if (!snapshot)
         return previousSnapshot || previousMayContainResources
-            ? 'The previously provided retained Session resources no longer apply. No retained processes, code cells or subagents remain.'
+            ? 'The previously provided retained Session resources no longer apply. No retained processes, code cells or subagents remain. Historical resource IDs are not live handles; do not poll or wait on them. Use already recorded results or saved artifacts to recover completed work before starting anything again.'
             : undefined;
     return previousSnapshot || previousMayContainResources
         ? `This replaces all previously provided retained Session resources.\n\n${snapshot}`

package/dist/prompts/workflow.js

@@ -16,6 +16,8 @@ export function toolUsagePrompt(tools, directTools = tools) {
         clauses.push('If the request names or clearly matches an available Skill description, call skill before generic tools and follow the loaded workflow; semantic matches do not require the user to know the Skill name. Do not load unrelated Skills or claim to use one without calling skill.');
     if (names.has('exec'))
         clauses.push('Use exec for platform-native commands, scripts, verification, and mechanical edits. Prefer rg or rg --files for search. Batch independent lookups and already-decided commands, preserving failure ordering. Use scripts for mechanical substitutions instead of reproducing long unchanged text in a patch; inspect actual effects afterward.');
+    if (names.has('exec_wait'))
+        clauses.push('Use exec_wait with processId for subsequent process waits, stdin writes or cancellation; in Code Mode use tools.exec_wait. exec only starts commands.');
     if (names.has('read'))
         clauses.push('Use read to batch known files and ranges. Batch only already-located, bounded ranges that are likely to fit together; for large files or documents, locate relevant sections before reading them. Read only what can affect the next decision, continue only relevant incomplete results using returned metadata, and avoid rereading unchanged content. Do not edit from an incomplete oversized-line preview. Obtain exact source with exec; if it still cannot fit, use a preconditioned deterministic replacement and verify the result.');
     if (names.has('apply_patch'))

package/dist/runtime/context-gc.js

@@ -690,7 +690,7 @@ function collectExecCandidates(input, groups, existingTargets, usageRatio) {
     let protectedTokens = 0;
     let retryAfterRollouts = Infinity;
     const execGroups = [...groups.values()]
-        .filter((group) => group.toolName === 'exec')
+        .filter((group) => group.toolName === 'exec' || group.toolName === 'exec_wait')
         .sort((left, right) => (left.call?.record.sequence ?? Number.MAX_SAFE_INTEGER) -
         (right.call?.record.sequence ?? Number.MAX_SAFE_INTEGER));
     const invocations = new Map();
@@ -713,15 +713,32 @@ function collectExecCandidates(input, groups, existingTargets, usageRatio) {
     }
     for (const startGroup of execGroups) {
         const start = invocations.get(startGroup.callId);
-        if (!start ||
-            (start.input.action !== 'start' &&
-                !(start.input.action == null && typeof start.input.command === 'string')))
+        if (!start)
             continue;
+        const isStart = start.group.toolName === 'exec' &&
+            (start.input.action === 'start' ||
+                (start.input.action == null && typeof start.input.command === 'string'));
+        const processId = typeof start.input.processId === 'string'
+            ? start.input.processId
+            : typeof start.result.processId === 'string'
+                ? start.result.processId
+                : undefined;
+        if (!isStart) {
+            if (start.group.toolName !== 'exec_wait' || !processId)
+                continue;
+            // A process may start inside a cell or before the visible history boundary.
+            // Begin with its first visible wait, but never split an unfinished lifecycle.
+            const previous = execGroups.findLast((group) => (group.call?.record.sequence ?? Infinity) < start.group.call.record.sequence &&
+                ((isRecord(group.call?.message.arguments) &&
+                    group.call.message.arguments.processId === processId) ||
+                    invocations.get(group.callId)?.result.processId === processId));
+            const previousStatus = previous && invocations.get(previous.callId)?.result.status;
+            if (previous && previousStatus !== 'completed' && previousStatus !== 'cancelled')
+                continue;
+        }
         const lifecycle = [start];
-        let processId;
         let terminal = start.result.status !== 'running';
         if (!terminal) {
-            processId = typeof start.result.processId === 'string' ? start.result.processId : undefined;
             if (!processId)
                 continue;
             const relatedGroups = execGroups.filter((group) => (group.call?.record.sequence ?? 0) > start.group.call.record.sequence &&
@@ -765,10 +782,10 @@ function collectExecCandidates(input, groups, existingTargets, usageRatio) {
             if (!existingTargets.has(contextGcTargetKey(callTarget)))
                 replacements.push({
                     kind: 'TOOL_CALL_INPUT',
-                    toolName: 'exec',
+                    toolName: invocation.group.toolName,
                     callId: invocation.group.callId,
                     target: callTarget,
-                    replacementArguments: contextGcExecInputReplacement(invocation.input),
+                    replacementArguments: contextGcExecInputReplacement(invocation.input, 3, invocation.group.toolName),
                     providerAliasTargets: invocation.group.aliases
                         .map(({ record, message }) => targetFor(record, message))
                         .filter((target) => target !== undefined),

package/dist/sdk/agent.js

@@ -1,6 +1,7 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { isDeepStrictEqual } from 'node:util';
 import { describeMarAgentError, MarAgentError } from '../error.js';
+import { CodeCellExecutionError } from '../tools/code-mode/cells.js';
 import { negotiateHost } from '../host/contracts.js';
 import { AnthropicMessagesAdapter, isAnthropicRecoverableStreamError } from '../model/anthropic-messages.js';
 import { marAgentReasoningEffortSchema, resolveModelDefaultReasoningEffort, usesResponsesConfigurationUpdates } from '../model/configuration.js';
@@ -37,7 +38,6 @@ import { createSessionToolScheduler, scheduleToolCallBatch } from '../tools/sche
 import { projectCodeModeSearchResult, projectCodeModeTools } from '../tools/code-mode.js';
 import { allowsDirectTool, allowsToolCaller, toolCallers } from '../tools/callers.js';
 import { SubagentSessionController } from '../subagent/session-controller.js';
-const MODEL_PERFORMANCE_MIN_INTERVAL_MS = 1_000;
 /** Retry only classified recoverable failures within the attempt budget; never retry cancellation. */
 async function recoverModelStream(error, retryState, signal) {
     if (signal.aborted ||
@@ -612,7 +612,14 @@ export async function createMarAgentWithAdapter(options) {
                         instructionContent: renderAgentInstructions(instructionEntries, compactMayContainAgentInstructions ||
                             contextualWorldState.instructionSnapshot !== undefined),
                         resourceSnapshot: currentResourceSnapshot,
-                        previousMayContainResources: compactMayContainRetainedResources
+                        previousMayContainResources: (!contextualWorldState.initialized && compactMayContainRetainedResources) ||
+                            (options.host.listSessionResources !== undefined &&
+                                currentResourceSnapshot === undefined &&
+                                messages
+                                    .slice(contextualWorldState.entries.findLast((entry) => entry.kind === 'resources')
+                                    ?.index ?? 0)
+                                    .some((message) => message.role === 'tool_call' &&
+                                    ['exec', 'code_exec', 'code_mode', 'agent_start'].includes(message.name ?? '')))
                     });
                     sessionRuntime.contextualWorldState = contextualWorldState;
                     if (!isDeepStrictEqual(previousContextualWorldState, contextualWorldState))
@@ -900,38 +907,29 @@ export async function createMarAgentWithAdapter(options) {
                         let firstModelResponseAt;
                         let requestCompletedAt;
                         let requestOutputTokens;
-                        let outputTokenRevision = 0;
-                        let lastPerformanceEmittedAt;
-                        let lastPublishedOutputTokenRevision = 0;
-                        let performanceEmitted = false;
                         const roundMessageCount = messages.length;
-                        const emitPerformance = async (sampledAt, force = false) => {
+                        const emitLatency = async () => {
                             if (mode === 'compact' || firstModelResponseAt === undefined)
                                 return;
-                            const outputDurationMs = Math.max(0, Math.round(sampledAt - firstModelResponseAt));
-                            const outputTokens = requestOutputTokens;
-                            const tokensPerSecond = outputTokens !== undefined && outputDurationMs > 0
-                                ? Number(((outputTokens * 1000) / outputDurationMs).toFixed(2))
-                                : undefined;
-                            if (performanceEmitted &&
-                                (tokensPerSecond === undefined ||
-                                    outputTokenRevision === lastPublishedOutputTokenRevision))
+                            await emit({
+                                type: 'model.performance',
+                                latencyMs: Math.max(0, Math.round(firstModelResponseAt - requestStartedAt))
+                            });
+                        };
+                        const emitFinalPerformance = async (completedAt) => {
+                            if (mode === 'compact' || firstModelResponseAt === undefined)
                                 return;
-                            if (!force &&
-                                lastPerformanceEmittedAt !== undefined &&
-                                sampledAt - lastPerformanceEmittedAt < MODEL_PERFORMANCE_MIN_INTERVAL_MS)
+                            const outputDurationMs = Math.max(0, Math.round(completedAt - firstModelResponseAt));
+                            const outputTokens = requestOutputTokens;
+                            if (outputTokens === undefined || outputDurationMs <= 0)
                                 return;
                             await emit({
                                 type: 'model.performance',
                                 latencyMs: Math.max(0, Math.round(firstModelResponseAt - requestStartedAt)),
-                                ...(outputTokens === undefined ? {} : { outputTokens }),
+                                outputTokens,
                                 outputDurationMs,
-                                ...(tokensPerSecond === undefined ? {} : { tokensPerSecond })
+                                tokensPerSecond: Number(((outputTokens * 1000) / outputDurationMs).toFixed(2))
                             });
-                            performanceEmitted = true;
-                            lastPerformanceEmittedAt = sampledAt;
-                            if (tokensPerSecond !== undefined)
-                                lastPublishedOutputTokenRevision = outputTokenRevision;
                         };
                         const persistToolCalls = async (calls) => {
                             for (const call of calls) {
@@ -979,6 +977,7 @@ export async function createMarAgentWithAdapter(options) {
                                 onAttemptDiagnostic: recordModelAttempt(mode === 'compact' ? 'COMPACTION' : 'EXECUTION')
                             })) {
                                 const modelResponseAt = mode !== 'compact' && isModelResponseEvent(event) ? performance.now() : undefined;
+                                const isFirstModelResponse = modelResponseAt !== undefined && firstModelResponseAt === undefined;
                                 if (modelResponseAt !== undefined) {
                                     sawModelSemanticEvent = true;
                                     firstModelResponseAt ??= modelResponseAt;
@@ -1070,7 +1069,6 @@ export async function createMarAgentWithAdapter(options) {
                                         : undefined;
                                     if (outputTokens !== undefined) {
                                         requestOutputTokens = outputTokens;
-                                        outputTokenRevision++;
                                     }
                                     const reportedContext = event.usage.contextInputTokens ?? event.usage.inputTokens;
                                     if (reportedContext !== undefined &&
@@ -1121,12 +1119,12 @@ export async function createMarAgentWithAdapter(options) {
                                     stop = event.reason;
                                     requestCompletedAt = performance.now();
                                 }
-                                if (modelResponseAt !== undefined)
-                                    await emitPerformance(modelResponseAt);
+                                if (isFirstModelResponse)
+                                    await emitLatency();
                             }
                             if (mode !== 'compact' && firstModelResponseAt !== undefined) {
                                 const completedAt = requestCompletedAt ?? performance.now();
-                                await emitPerformance(completedAt, true);
+                                await emitFinalPerformance(completedAt);
                             }
                             pendingOutputContinuation = undefined;
                             incompleteToolCall = pendingTools.some((call) => call.argumentError !== undefined);
@@ -1291,6 +1289,7 @@ export async function createMarAgentWithAdapter(options) {
                             }
                             catch (error) {
                                 const diagnostic = describeMarAgentError(error, 'MAR_AGENT_HOST_OPERATION_FAILED');
+                                const partial = error instanceof CodeCellExecutionError ? error.result : undefined;
                                 await emit({
                                     type: 'tool.failed',
                                     toolName: call.name,
@@ -1301,13 +1300,16 @@ export async function createMarAgentWithAdapter(options) {
                                 });
                                 return {
                                     call,
-                                    content: JSON.stringify({
-                                        error: diagnostic.code,
-                                        message: diagnostic.message,
-                                        ...(error instanceof MarAgentError && error.retryable
-                                            ? { retryable: true }
-                                            : {})
-                                    }),
+                                    content: partial === undefined
+                                        ? JSON.stringify({
+                                            error: diagnostic.code,
+                                            message: diagnostic.message,
+                                            ...(error instanceof MarAgentError && error.retryable
+                                                ? { retryable: true }
+                                                : {})
+                                        })
+                                        : boundedModelToolOutput(call.name, partial.content, partial.data).content,
+                                    ...(partial?.images?.length ? { images: partial.images } : {}),
                                     failed: true,
                                     error
                                 };
@@ -2237,7 +2239,7 @@ function updateContextualWorldState(state, index, current) {
         if (current.instructionContent !== undefined)
             entries.push({ index, kind: 'instructions', content: current.instructionContent });
     }
-    const resourceContent = retainedSessionResourcesUpdate(current.resourceSnapshot, state.initialized ? state.resourceSnapshot : undefined, !state.initialized && current.previousMayContainResources);
+    const resourceContent = retainedSessionResourcesUpdate(current.resourceSnapshot, state.initialized ? state.resourceSnapshot : undefined, current.previousMayContainResources);
     if (resourceContent !== undefined)
         entries.push({ index, kind: 'resources', content: resourceContent });
     return {
@@ -2283,7 +2285,7 @@ function estimatedRequestTokens(system, messages, tools, images) {
         transientImageCount * AGENT_EXECUTION_POLICY.estimatedTokensPerImage);
 }
 function boundedModelToolOutput(toolName, value, data) {
-    const execDiagnostics = toolName === 'exec' &&
+    const execDiagnostics = (toolName === 'exec' || toolName === 'exec_wait') &&
         isRecord(data) &&
         typeof data.stdout === 'string' &&
         typeof data.stderr === 'string'
@@ -2390,7 +2392,7 @@ function structuredToolEventData(toolName, value) {
         typeof value.sha256 === 'string' &&
         /^[a-f0-9]{64}$/u.test(value.sha256))
         return value;
-    if (toolName === 'exec' &&
+    if ((toolName === 'exec' || toolName === 'exec_wait') &&
         (value.status === 'running' || value.status === 'completed' || value.status === 'cancelled') &&
         typeof value.stdout === 'string' &&
         typeof value.stderr === 'string' &&

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

@@ -50,7 +50,7 @@ export type ContextGcReplacement = {
     readonly evidenceSequences: readonly number[];
 } | {
     readonly kind: 'TOOL_CALL_INPUT';
-    readonly toolName: 'apply_patch' | 'exec' | 'code_mode' | 'code_exec';
+    readonly toolName: 'apply_patch' | 'exec' | 'exec_wait' | 'code_mode' | 'code_exec';
     readonly callId: string;
     readonly target: ContextGcTarget;
     readonly replacementArguments: unknown;

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

@@ -350,8 +350,9 @@ function replacementMatchesRecords(replacement, records, recordsBySequence, work
     if (!isSuccessfulExecLifecycleEvidence(replacement, source, records, recordsBySequence))
         return false;
     if (replacement.kind === 'TOOL_CALL_INPUT')
-        return isDeepStrictEqual(replacement.replacementArguments, contextGcExecInputReplacement(source.payload.arguments, execInputReplacementFormatVersion(replacement.replacementArguments)));
-    const targetEvidence = successfulToolEvidence(records, recordsBySequence, source.sequence, 'exec');
+        return isDeepStrictEqual(replacement.replacementArguments, contextGcExecInputReplacement(source.payload.arguments, execInputReplacementFormatVersion(replacement.replacementArguments), replacement.toolName));
+    const targetEvidence = successfulToolEvidence(records, recordsBySequence, source.sequence, 'exec') ??
+        successfulToolEvidence(records, recordsBySequence, source.sequence, 'exec_wait');
     const result = normalizeContextGcExecResult(source.payload.content, targetEvidence?.completed.payload);
     return (result !== undefined &&
         replacement.replacementContent ===
@@ -474,7 +475,8 @@ function successfulPatchEvidenceForPath(records, recordsBySequence, evidenceSequ
         : undefined;
 }
 function isSuccessfulExecLifecycleEvidence(replacement, source, records, recordsBySequence) {
-    const evidence = successfulToolEvidence(records, recordsBySequence, replacement.evidenceSequence, 'exec');
+    const evidence = successfulToolEvidence(records, recordsBySequence, replacement.evidenceSequence, 'exec') ??
+        successfulToolEvidence(records, recordsBySequence, replacement.evidenceSequence, 'exec_wait');
     if (!evidence || !isRecord(evidence.call.payload) || !isRecord(evidence.result.payload))
         return false;
     const finalResult = normalizeContextGcExecResult(evidence.result.payload.content, evidence.completed.payload);
@@ -487,7 +489,7 @@ function isSuccessfulExecLifecycleEvidence(replacement, source, records, records
         targetCall.sequence > evidence.call.sequence ||
         !isRecord(targetCall.payload) ||
         targetCall.payload.role !== 'tool_call' ||
-        targetCall.payload.name !== 'exec' ||
+        (targetCall.payload.name !== 'exec' && targetCall.payload.name !== 'exec_wait') ||
         targetCall.payload.callId !== replacement.callId)
         return false;
     const targetResult = replacement.kind === 'EXEC_OUTPUT'
@@ -495,7 +497,7 @@ function isSuccessfulExecLifecycleEvidence(replacement, source, records, records
         : modelToolResultForCall(records, targetCall, evidence.result.sequence);
     if (!targetResult)
         return false;
-    const targetEvidence = successfulToolEvidence(records, recordsBySequence, targetResult.sequence, 'exec');
+    const targetEvidence = successfulToolEvidence(records, recordsBySequence, targetResult.sequence, targetCall.payload.name);
     if (!targetEvidence || targetEvidence.call.sequence !== targetCall.sequence)
         return false;
     if (targetEvidence.callId === evidence.callId)
@@ -631,6 +633,7 @@ function isContextGcReplacement(value) {
             value.target.role === 'tool_call' &&
             (value.toolName === 'apply_patch' ||
                 value.toolName === 'exec' ||
+                value.toolName === 'exec_wait' ||
                 value.toolName === 'code_mode' ||
                 value.toolName === 'code_exec') &&
             value.target.toolName === value.toolName &&

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

@@ -56,7 +56,7 @@ export declare function contextGcStaleReadReplacement(input: {
     readonly formatVersion?: 1 | 2;
 }): string;
 export declare function contextGcWebOutputReplacement(toolName: ContextGcWebToolName, originalContent: string, truncated: boolean): string;
-export declare function contextGcExecInputReplacement(arguments_: unknown, formatVersion?: 1 | 2 | 3): unknown;
+export declare function contextGcExecInputReplacement(arguments_: unknown, formatVersion?: 1 | 2 | 3, toolName?: string): unknown;
 export declare function contextGcExecOutputReplacement(result: ContextGcExecResult, formatVersion?: 1 | 2 | 3): string;
 export declare function normalizeContextGcExecResult(modelContent: unknown, completedPayload: unknown): ContextGcExecResult | undefined;
 export declare function parseContextGcExecResult(value: unknown): ContextGcExecResult | undefined;

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

@@ -97,14 +97,16 @@ 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.'
     });
 }
-export function contextGcExecInputReplacement(arguments_, formatVersion = 3) {
+export function contextGcExecInputReplacement(arguments_, formatVersion = 3, toolName = 'exec') {
     if (!isRecord(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
         : typeof arguments_.command === 'string'
             ? 'start'
-            : 'unknown';
+            : toolName === 'exec_wait'
+                ? 'poll'
+                : 'unknown';
     const original = stableJson(arguments_);
     const retained = {
         action,
@@ -190,7 +192,7 @@ export function normalizeContextGcExecResult(modelContent, completedPayload) {
     if (typeof modelContent !== 'string' ||
         !isRecord(completedPayload) ||
         completedPayload.type !== 'tool.completed' ||
-        completedPayload.toolName !== 'exec' ||
+        (completedPayload.toolName !== 'exec' && completedPayload.toolName !== 'exec_wait') ||
         completedPayload.truncated !== true)
         return undefined;
     const data = completedPayload.data;

package/dist/tools/agent-wait.js

@@ -4,7 +4,7 @@ export const agentWaitToolDefinition = {
     name: 'agent_wait',
     allowedCallers: ['direct', 'programmatic'],
     parallelSafety: 'serial',
-    description: 'Read or wait a bounded time for a child agent result. waitFor defaults to "completion"; use "message" only when a fresh public commentary/final message would change the next decision. Omit agentId to wait for whichever live child returns first, matching Codex-style untargeted waiting and avoiding UUID transcription; provide the exact agentId returned by agent_start only when observing a specific child. If no child is live, untargeted waiting reads the most recently created child. For an exec processId, use exec with action:"poll" instead. Omitting waitMs waits up to 30 seconds by default; waitMs=0 returns the current snapshot immediately. Positive waits range up to 5 minutes, and positive values below 10 seconds are raised to 10 seconds. When blocked on a live child result, prefer one 300000 ms completion wait rather than repeated short waits. Every result includes waitOutcome as snapshot, message, completion, or timeout plus the real agentId and description. A message, timeout with unread progress, or first terminal completion result includes the newly observed latest public commentary/final message; snapshots and repeated observations omit previously observed message text. latestActivity can still identify a public message or bounded tool started/completed/failed status. A queued or running result is not completion. A message wait consumes only the latest unread public message in the current Session runtime; tool activity does not wake it, and parent cancellation preserves unread progress for a later Execution. Do not use message waits as heartbeat checks or request progress merely to confirm that a child is still running. First terminal results include bounded summary, changedFiles, verification, and read evidence with path/line ranges; use that evidence to avoid repeating the full exploration, while independently checking consequential edits and claims.',
+    description: 'Read or wait a bounded time for a child agent result. waitFor defaults to "completion"; use "message" only when a fresh public commentary/final message would change the next decision. Omit agentId to wait for whichever live child returns first, matching Codex-style untargeted waiting and avoiding UUID transcription; provide the exact agentId returned by agent_start only when observing a specific child. If no child is live, untargeted waiting reads the most recently created child. For an exec processId, use exec_wait instead (tools.exec_wait in Code Mode). Omitting waitMs waits up to 30 seconds by default; waitMs=0 returns the current snapshot immediately. Positive waits range up to 5 minutes, and positive values below 10 seconds are raised to 10 seconds. When blocked on a live child result, prefer one 300000 ms completion wait rather than repeated short waits. Every result includes waitOutcome as snapshot, message, completion, or timeout plus the real agentId and description. A message, timeout with unread progress, or first terminal completion result includes the newly observed latest public commentary/final message; snapshots and repeated observations omit previously observed message text. latestActivity can still identify a public message or bounded tool started/completed/failed status. A queued or running result is not completion. A message wait consumes only the latest unread public message in the current Session runtime; tool activity does not wake it, and parent cancellation preserves unread progress for a later Execution. Do not use message waits as heartbeat checks or request progress merely to confirm that a child is still running. First terminal results include bounded summary, changedFiles, verification, and read evidence with path/line ranges; use that evidence to avoid repeating the full exploration, while independently checking consequential edits and claims.',
     inputSchema: {
         type: 'object',
         properties: {

package/dist/tools/apply-patch.js

@@ -8,7 +8,7 @@ export const applyPatchToolDefinition = {
     name: 'apply_patch',
     allowedCallers: ['direct', 'programmatic'],
     parallelSafety: 'serial',
-    description: `Preferred for precise, reviewable local edits. Do not batch all task files merely to reduce tool calls. Group only a few tightly coupled edits whose combined patch is quick to generate and review; split broad or independent work into successive bounded patches before composing them. Submit a raw *** Begin Patch / *** End Patch patch. Supports Add File, Update File, Delete File, and Move to. Add File may replace an existing regular file, and Move to may replace an existing regular destination; duplicate operations on the same resolved path remain invalid. Update hunks accept @@ or @@ <change context>; context-only hunks may also be used as ordered anchors before a later changing hunk. Context is searched forward with Codex-style exact, whitespace-tolerant, then common Unicode punctuation-tolerant matching. Syntax and resolved paths are validated before writing, then file units are committed in order. Each file unit is atomic, and a Move keeps its source and destination atomic. On MAR_AGENT_PATCH_PARTIAL, earlier files remain applied; the error lists applied, failed, and pending paths, so retry only failed and pending paths. Existing file permissions, line endings, and final-newline state are preserved. Returns changed file paths and operations with per-file and total line counts when all units succeed. In Code Mode, the Promise resolves on success and rejects with code/message on failure; the returned envelope has data.files and data.totals, not an ok or success flag. Oversized patches are rejected without advertising defensive limits as recommended patch sizes. A first-unit MAR_AGENT_PATCH_CONFLICT applies nothing; hunk match conflicts identify the affected path and hunk so you can reread only that file before retrying.`,
+    description: `Preferred for precise, reviewable local edits. Do not batch all task files merely to reduce tool calls. Group only a few tightly coupled edits whose combined patch is quick to generate and review; split broad or independent work into successive bounded patches before composing them. Submit a raw *** Begin Patch / *** End Patch patch. Supports Add File, Update File, Delete File, and Move to. Add File may replace an existing regular file, and Move to may replace an existing regular destination; duplicate operations on the same resolved path remain invalid. Update hunks accept @@ or @@ <change context>; context-only hunks may also be used as ordered anchors before a later changing hunk. Omit unchanged file sections: an Update File must change or move the file, and its last hunk must not be context-only. Context is searched forward with Codex-style exact, whitespace-tolerant, then common Unicode punctuation-tolerant matching. Syntax and resolved paths are validated before writing, then file units are committed in order. Each file unit is atomic, and a Move keeps its source and destination atomic. On MAR_AGENT_PATCH_PARTIAL, earlier files remain applied; the error lists applied, failed, and pending paths, so retry only failed and pending paths. Existing file permissions, line endings, and final-newline state are preserved. Returns changed file paths and operations with per-file and total line counts when all units succeed. In Code Mode, the Promise resolves on success and rejects with code/message on failure; the returned envelope has data.files and data.totals, not an ok or success flag. Oversized patches are rejected without advertising defensive limits as recommended patch sizes. A first-unit MAR_AGENT_PATCH_CONFLICT applies nothing; hunk match conflicts identify the affected path and hunk so you can reread only that file before retrying.`,
     inputMode: 'freeform',
     outputSchema: {
         type: 'object',

package/dist/tools/callers.js

@@ -13,7 +13,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', 'code_mode', 'tool_search', 'question'].includes(tool.name))
+        ['code_exec', 'code_exec_wait', 'code_mode', 'tool_search', 'question', 'skill'].includes(tool.name))
         return false;
     return toolCallers(tool).includes(caller);
 }

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

@@ -1,9 +1,15 @@
+import { MarAgentError } from '../../error.js';
 import type { ToolExecutionContext, ToolExecutionResult } from '../../sdk/types.js';
 export interface CellOutput {
-    text(value: string): void;
+    text(value: string, originalBytes?: number): void;
     image(value: NonNullable<ToolExecutionResult['images']>[number]): void;
     yield(): void;
 }
+/** Keeps a failed tool call observable without discarding earlier explicit output. */
+export declare class CodeCellExecutionError extends MarAgentError {
+    readonly result: ToolExecutionResult;
+    constructor(error: unknown, result: ToolExecutionResult);
+}
 type Status = 'running' | 'completed' | 'failed' | 'cancelled';
 /** Session-owned execution, separate from the cancellable model-tool wait. */
 export declare class CodeCells {

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

@@ -2,6 +2,19 @@ import { randomUUID } from 'node:crypto';
 import { MarAgentError, describeMarAgentError } from '../../error.js';
 import { TOOL_EXECUTION_LIMITS as limits } from '../execution-limits.js';
 import { truncateModelText } from '../../runtime/token-budget.js';
+import { BoundedTextOutput, renderCapturedText } from './text-output.js';
+/** Keeps a failed tool call observable without discarding earlier explicit output. */
+export class CodeCellExecutionError extends MarAgentError {
+    result;
+    constructor(error, result) {
+        const diagnostic = describeMarAgentError(error, 'MAR_AGENT_CODE_FAILED');
+        super(diagnostic.code, diagnostic.message.replace(`${diagnostic.code}: `, ''), {
+            cause: error,
+            ...(error instanceof MarAgentError ? { retryable: error.retryable } : {})
+        });
+        this.result = result;
+    }
+}
 function options(value, wait) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Code Exec options must be an object.');
@@ -11,11 +24,11 @@ function options(value, wait) {
         : ['yieldMs', 'maxOutputTokens'];
     if (Object.keys(input).some((key) => !keys.includes(key)))
         throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Unknown Code Exec option.');
-    const yieldMs = input.yieldMs ?? limits.codeDefaultYieldMs;
+    const yieldMs = input.yieldMs ?? (wait ? limits.codeDefaultWaitYieldMs : limits.codeDefaultYieldMs);
     const maxOutputTokens = input.maxOutputTokens ?? limits.codeMaxOutputTokens;
     if (!Number.isSafeInteger(yieldMs) ||
         Number(yieldMs) < 0 ||
-        Number(yieldMs) > limits.codeMaxYieldMs ||
+        Number(yieldMs) > (wait ? limits.codeMaxWaitYieldMs : limits.codeMaxYieldMs) ||
         !Number.isSafeInteger(maxOutputTokens) ||
         Number(maxOutputTokens) < 1 ||
         Number(maxOutputTokens) > limits.codeMaxOutputTokens ||
@@ -73,9 +86,10 @@ export class CodeCells {
             executionId: context.executionId,
             controller,
             status: 'running',
-            text: [],
+            text: new BoundedTextOutput(limits.codeMaxOutputBytes),
             images: [],
             yielded: false,
+            truncated: false,
             listeners: new Set(),
             done: Promise.resolve()
         };
@@ -90,7 +104,7 @@ export class CodeCells {
             .then(async () => {
             releaseSession = await context.codeMode?.retainSession?.();
             return run(source, { ...context, signal: controller.signal }, {
-                text: (text) => cell.text.push(text),
+                text: (text, originalBytes) => cell.text.append(text, originalBytes),
                 image: (image) => cell.images.push(image),
                 yield: () => {
                     cell.yielded = true;
@@ -187,7 +201,12 @@ export class CodeCells {
         if (cell.terminal) {
             const snapshot = cell.terminal.data;
             const bounded = truncateModelText(snapshot.output, input.maxOutputTokens);
-            const data = { ...snapshot, output: bounded.content, cached: true };
+            const data = {
+                ...snapshot,
+                output: bounded.content,
+                truncated: cell.terminal.truncated || bounded.truncated,
+                cached: true
+            };
             return {
                 ...cell.terminal,
                 data,
@@ -195,10 +214,12 @@ export class CodeCells {
                 truncated: cell.terminal.truncated || bounded.truncated
             };
         }
-        const text = cell.text.splice(0).join('\n');
+        const captured = cell.text.drain();
         const images = cell.images.splice(0);
+        const text = renderCapturedText(captured, images.length);
         cell.yielded = false;
         const bounded = truncateModelText(text, input.maxOutputTokens);
+        cell.truncated ||= captured.droppedBytes > 0 || bounded.truncated;
         const error = cell.error === undefined
             ? undefined
             : describeMarAgentError(cell.error, 'MAR_AGENT_CODE_FAILED');
@@ -207,13 +228,16 @@ export class CodeCells {
             status: cell.status,
             output: bounded.content,
             ...cell.result?.data,
+            outputBytes: captured.originalBytes,
+            outputDroppedBytes: captured.droppedBytes,
+            truncated: cell.truncated,
             ...(error ? { error: { code: error.code, message: error.message } } : {}),
             cached: false
         };
         const result = {
             content: JSON.stringify(data),
             data,
-            truncated: bounded.truncated,
+            truncated: cell.truncated,
             ...(images.length ? { images } : {})
         };
         if (cell.status !== 'running')
@@ -221,7 +245,7 @@ export class CodeCells {
         // Keep synchronous completion compatible; retained waits always include explicit lifecycle metadata.
         if (initial && cell.status !== 'running') {
             if (cell.error !== undefined)
-                throw cell.error;
+                throw new CodeCellExecutionError(cell.error, result);
             return { ...result, content: bounded.content || 'Code Exec completed without emitted text.' };
         }
         return result;