@myagentroam/agent 0.11.43 → 0.11.45

package/dist/cli/subagent/index.js

@@ -7,6 +7,13 @@ import { registerQueryTools } from './query.js';
 import { nativeSubagentService, SUBAGENT_NATIVE_SERVICE } from './native.js';
 import { childResources } from './resources.js';
 import { sharedSessionHistory } from './history.js';
+const delegationPrompt = [
+    '# Delegation and coordination',
+    'Delegate bounded, self-contained tasks when independent progress or context savings materially helps. Keep simple or tightly coupled work local.',
+    'Give each child an objective, necessary context, expected output, and a read-only boundary or non-overlapping write scope.',
+    'While children run, continue meaningful non-overlapping work. Do not redo delegated work. Wait only when the next step needs the result.',
+    'Verify consequential findings and changes. Join or stop task-required child work before final delivery, and retain responsibility for the final result.'
+].join('\n\n');
 export { SUBAGENT_NATIVE_SERVICE } from './native.js';
 /** Optional local consumer of Core Session lifecycle and observation APIs. */
 export function createSubagentExtension(options) {
@@ -70,6 +77,18 @@ export function createSubagentExtension(options) {
                 registerControlTools(context, agent, observations, warmObservations, admission);
                 registerWait(context, agent, observations, history);
                 registerQueryTools(context, agent);
+                context.hooks.intercept('prompt.sections', (input, _call, next) => next({
+                    ...input,
+                    sections: [
+                        ...input.sections,
+                        {
+                            id: 'subagent:delegation',
+                            text: input.facts?.mode !== 'compact' && input.facts?.tools?.includes('agent_start')
+                                ? delegationPrompt
+                                : null
+                        }
+                    ]
+                }));
             }
             catch (error) {
                 disposed = true;

package/dist/runtime/event-projection.js

@@ -81,6 +81,7 @@ export function publicHostedToolEvents(event) {
             callId: event.itemId,
             summary,
             truncated,
+            ...(preview.truncated || event.truncated === true ? { summaryTruncated: true } : {}),
             data: started.data
         }
     ];

package/dist/runtime/events.d.ts

@@ -95,6 +95,7 @@ export type AgentEvent = AgentEventBase & ({
     callId: string;
     parentCallId?: string;
     output: import('../tools/contracts.js').ExecOutputSnapshot;
+    outputTruncation?: 'HEAD' | 'SOURCE';
 } | {
     type: 'tool.completed';
     resultExtensions?: readonly import('../tools/result-extension-contract.js').ToolResultExtension[];
@@ -103,6 +104,8 @@ export type AgentEvent = AgentEventBase & ({
     parentCallId?: string;
     summary: string;
     truncated?: boolean;
+    summaryTruncated?: boolean;
+    outputTruncation?: 'HEAD' | 'SOURCE';
     artifacts?: readonly AgentToolArtifact[];
     data?: CodeCellEventData | import('../tools/contracts.js').ExecResult | Omit<import('../tools/contracts.js').ExecResult, 'stdout' | 'stderr'> | import('../tools/contracts.js').ApplyPatchResult | import('../tools/contracts.js').ReadEventData | import('../tools/contracts.js').ViewImageResult | import('../tools/contracts.js').SleepResult | Readonly<Record<string, unknown>> | import('./public-tool-metadata.js').PublicToolMetadata;
 } | {
@@ -116,6 +119,7 @@ export type AgentEvent = AgentEventBase & ({
     message?: string;
     permissionStop?: import('../tools/permission-contract.js').PermissionStop;
     truncated?: boolean;
+    outputTruncation?: 'HEAD' | 'SOURCE';
 } | {
     type: 'sleep.started';
     callId: string;

package/dist/sdk/session-execution.js

@@ -241,6 +241,13 @@ export class SessionExecution {
                 const deliver = missed && full.output.displayOutput
                     ? {
                         ...full,
+                        ...(full.outputTruncation === 'SOURCE' ||
+                            full.output.displayOutput.stdoutDroppedBytes > 0 ||
+                            full.output.displayOutput.stderrDroppedBytes > 0
+                            ? {
+                                outputTruncation: full.outputTruncation === 'SOURCE' ? 'SOURCE' : 'HEAD'
+                            }
+                            : {}),
                         output: {
                             ...full.output,
                             mode: 'snapshot',

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

@@ -3,7 +3,7 @@ import type { ToolExecutionContext, ToolExecutionResult } from '../contracts.js'
 import type { CodeObservation, CodeToolCallRecord } from '../../session/code-observation-contract.js';
 export interface CellOutput {
     call(value: CodeToolCallRecord): void;
-    observe(value: CodeObservation): void;
+    observe(value: CodeObservation, display?: CodeObservation, displayHeadTruncated?: boolean): void;
     text(value: string, originalBytes?: number): void;
     image(value: NonNullable<ToolExecutionResult['images']>[number]): void;
     yield(): void;

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

@@ -6,6 +6,7 @@ import { TOOL_EXECUTION_LIMITS as limits } from '../execution-limits.js';
 import { waitForToolCondition, waitMetadata } from '../wait.js';
 import { BoundedTextOutput, renderCapturedText } from './text-output.js';
 import { boundObservations, newObservationId } from './observations.js';
+import { publicCodeObservations } from '../output-projection.js';
 import { selectObservationImages, visibleObservation } from '../../session/code-observation-projection.js';
 /** Keeps a failed tool call observable without discarding earlier explicit output. */
 export class CodeCellExecutionError extends AgentError {
@@ -214,7 +215,26 @@ export class CodeCells {
             releaseSession = await context.codeMode?.retainSession?.();
             return run(source, { ...context, signal: controller.signal, waitInterrupt: undefined }, {
                 call: (value) => cell.calls.set(value.callId, value),
-                observe: (value) => cell.observations.push(value),
+                observe: (value, display = value, displayHeadTruncated = false) => {
+                    cell.observations.push(value);
+                    const observations = [...(cell.display?.observations ?? []), display];
+                    cell.display = publicCodeObservations(observations, {
+                        cellId: cell.cellId,
+                        status: cell.status,
+                        observations,
+                        outputSourceKnown: true,
+                        ...(cell.display?.outputSourceTruncated ||
+                            (!displayHeadTruncated &&
+                                (display.type === 'value'
+                                    ? display.truncated === true
+                                    : display.result.truncated === true))
+                            ? { outputSourceTruncated: true }
+                            : {}),
+                        ...(cell.display?.outputHeadTruncated || displayHeadTruncated
+                            ? { outputHeadTruncated: true }
+                            : {})
+                    });
+                },
                 text: (text, originalBytes) => cell.text.append(text, originalBytes),
                 image: (image) => cell.images.push(image),
                 yield: () => {
@@ -359,7 +379,14 @@ export class CodeCells {
                         observations: visible.observations.map(visibleObservation)
                     }),
                     data,
-                    eventData: { ...data, executionSource: cell.source },
+                    eventData: {
+                        ...data,
+                        ...cell.display,
+                        status: cell.status,
+                        cached: true,
+                        ...wait,
+                        executionSource: cell.source
+                    },
                     truncated: data.truncated
                 };
             }
@@ -430,7 +457,12 @@ export class CodeCells {
             calls: [...cell.calls.values()],
             observations: remapped,
             data,
-            eventData: { ...data, executionSource: cell.source },
+            eventData: {
+                ...data,
+                ...cell.display,
+                status: cell.status,
+                executionSource: cell.source
+            },
             truncated: cell.truncated || structured.truncated,
             ...(visibleImages.length ? { images: visibleImages } : {})
         };

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

@@ -2,7 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { AgentError, describeAgentError } from '../../error.js';
 import { toolEventSummary } from '../../runtime/event-projection.js';
 import { allowsToolCaller } from '../callers.js';
-import { boundedModelToolOutput, structuredToolEventData, structuredToolFailureData } from '../output-projection.js';
+import { boundedModelToolOutput, publicToolEventInput, publicExtensionToolEventData, publicEventOutputData, publicOutputTruncation, structuredToolEventData, structuredToolFailureData } from '../output-projection.js';
 import { executeRegisteredTool } from '../runtime.js';
 import { failedToolResultExtensions } from '../result-extensions.js';
 import { permissionStopFromError } from '../permissions.js';
@@ -19,7 +19,13 @@ export function createCodeToolDispatch(input) {
             signal.throwIfAborted();
             const callId = call.callId ?? randomUUID();
             const identity = { toolName: call.name, callId, parentCallId: input.parentCallId };
-            await input.emit({ type: 'tool.started', ...identity, input: call.arguments });
+            await input.emit({
+                type: 'tool.started',
+                ...identity,
+                input: definition.eventInputFields === undefined
+                    ? call.arguments
+                    : publicToolEventInput(call.arguments, definition.eventInputFields)
+            });
             try {
                 input.assertLive();
                 signal.throwIfAborted();
@@ -32,23 +38,35 @@ export function createCodeToolDispatch(input) {
                     ...(expected ? { expectedMcpTool: expected } : {})
                 }, 'programmatic');
                 const bounded = boundedModelToolOutput(call.name, result.content, result.data);
-                const data = structuredToolEventData(call.name, call.name === 'exec' || call.name === 'exec_wait'
-                    ? (result.eventData ?? result.data)
-                    : result.data);
-                const preview = toolEventSummary(result.content);
+                const data = call.name === 'exec' || call.name === 'exec_wait'
+                    ? structuredToolEventData(call.name, result.eventData ?? result.data)
+                    : result.eventData === undefined
+                        ? structuredToolEventData(call.name, result.data)
+                        : publicExtensionToolEventData(result.eventData);
+                const preview = toolEventSummary(result.eventSummary === undefined
+                    ? result.content
+                    : typeof result.eventSummary === 'string'
+                        ? result.eventSummary
+                        : '');
+                const outputTruncation = publicOutputTruncation(call.name, data);
                 input.assertLive();
                 await input.emit({
                     type: 'tool.completed',
                     ...(result.resultExtensions ? { resultExtensions: result.resultExtensions } : {}),
                     ...identity,
                     summary: preview.summary,
-                    ...(data === undefined ? {} : { data }),
+                    ...(preview.truncated ? { summaryTruncated: true } : {}),
+                    ...(outputTruncation ? { outputTruncation } : {}),
+                    ...(data === undefined ? {} : { data: publicEventOutputData(data) }),
                     truncated: result.truncated === true || bounded.truncated || preview.truncated,
                     ...(result.artifacts ? { artifacts: result.artifacts } : {})
                 });
                 const { eventData: _eventData, ...guestResult } = result;
                 return {
                     ...guestResult,
+                    ...((call.name === 'exec' || call.name === 'exec_wait') && data !== undefined
+                        ? { eventData: { ...data } }
+                        : {}),
                     content: bounded.content,
                     truncated: result.truncated === true || bounded.truncated
                 };

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

@@ -41,6 +41,8 @@ export interface CodeModeEngine {
             format: 'text' | 'json';
             value: string;
             originalBytes: number;
+            /** Public display tail, independent of the model capture budget. */
+            displayValue?: string;
         } | {
             type: 'image';
             value: unknown;

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

@@ -300,7 +300,7 @@ export class CodeModeTool {
         const images = [];
         const observations = [];
         let observationBytes = 0;
-        const appendObservation = (value, originalBytes) => {
+        const appendObservation = (value, originalBytes, display) => {
             const capture = new BoundedTextOutput(Math.max(0, limits.codeMaxOutputBytes - observationBytes), '');
             const body = value.type === 'tool_result' ? value.result.content : value.value;
             capture.append(body);
@@ -323,7 +323,10 @@ export class CodeModeTool {
                     truncated: value.truncated === true || bounded.droppedBytes > 0
                 };
             observations.push(observation);
-            output?.observe(observation);
+            output?.observe(observation, display ?? value, display !== undefined &&
+                (display.type === 'tool_result'
+                    ? display.result.truncated === true
+                    : display.truncated === true));
         };
         const toolResults = new Map();
         let transportBytes = 0;
@@ -389,6 +392,7 @@ export class CodeModeTool {
                     return index;
                 };
                 let observation;
+                let displayObservation;
                 if (value.type === 'tool_result' && typeof value.operationId === 'string') {
                     const original = toolResults.get(value.operationId);
                     if (!original)
@@ -423,6 +427,23 @@ export class CodeModeTool {
                             ...(indices?.length ? { imageIndices: indices } : {})
                         }
                     };
+                    const display = original.result.eventData?.displayOutput;
+                    if ((original.source.toolName === 'exec' || original.source.toolName === 'exec_wait') &&
+                        display !== null &&
+                        typeof display === 'object' &&
+                        'stdout' in display &&
+                        'stderr' in display &&
+                        typeof display.stdout === 'string' &&
+                        typeof display.stderr === 'string')
+                        displayObservation = {
+                            ...observation,
+                            result: {
+                                content: '',
+                                data: { stdout: display.stdout, stderr: display.stderr },
+                                truncated: ('stdoutDroppedBytes' in display && Number(display.stdoutDroppedBytes) > 0) ||
+                                    ('stderrDroppedBytes' in display && Number(display.stderrDroppedBytes) > 0)
+                            }
+                        };
                 }
                 else if (value.type === 'image') {
                     observation = {
@@ -444,12 +465,22 @@ export class CodeModeTool {
                         truncated: typeof value.originalBytes === 'number' &&
                             value.originalBytes > Buffer.byteLength(value.value)
                     };
+                    if (typeof value.displayValue === 'string') {
+                        if (Buffer.byteLength(value.displayValue) > 10_000)
+                            throw new AgentError('MAR_AGENT_CODE_PROTOCOL_ERROR', 'Code Mode sent oversized display text.');
+                        displayObservation = {
+                            ...observation,
+                            value: value.displayValue,
+                            truncated: typeof value.originalBytes === 'number' &&
+                                value.originalBytes > Buffer.byteLength(value.displayValue)
+                        };
+                    }
                 }
                 else
                     throw new AgentError('MAR_AGENT_CODE_PROTOCOL_ERROR', 'Invalid observation frame.');
                 appendObservation(observation, value.type === 'value' && typeof value.originalBytes === 'number'
                     ? value.originalBytes
-                    : undefined);
+                    : undefined, displayObservation);
             }
             else if (frame.kind === 'text' && typeof frame.value === 'string') {
                 const originalBytes = frame.originalBytes ?? Buffer.byteLength(frame.value);
@@ -527,10 +558,11 @@ export class CodeModeTool {
                                     : undefined
                             }
                         });
-                        const { content, ...structured } = output;
+                        const { eventData: _eventData, ...guestOutput } = output;
+                        const { content, ...structured } = guestOutput;
                         const projected = output.data !== undefined && content === JSON.stringify(output.data)
                             ? structured
-                            : output;
+                            : guestOutput;
                         await write({ id, ok: true, output: projected });
                     }
                     catch (error) {

package/dist/tools/code-mode/quickjs-engine.js

@@ -354,6 +354,7 @@ export async function createCodeModeEngine(options) {
                 }
                 const separatorBytes = textCalls ? 1 : 0;
                 const capture = new BoundedTextOutput(Math.max(0, input.limits.outputBytes - outputBytes - separatorBytes), '');
+                const display = new BoundedTextOutput(10_000, '', 'tail');
                 const emit = vm.newFunction('textChunk', (chunk) => {
                     if (!chunk || vm.typeof(chunk) !== 'string')
                         return {
@@ -366,7 +367,9 @@ export async function createCodeModeEngine(options) {
                         return {
                             error: guestError('MAR_AGENT_TOOL_OUTPUT_LIMIT', 'Text serialization chunk limit exceeded.')
                         };
-                    capture.append(vm.getString(chunk));
+                    const text = vm.getString(chunk);
+                    capture.append(text);
+                    display.append(text);
                     return vm.undefined;
                 });
                 const result = callGuest(formatText, vm.undefined, handle ?? vm.undefined, emit);
@@ -381,6 +384,7 @@ export async function createCodeModeEngine(options) {
                         type: 'value',
                         format: handle && vm.typeof(handle) === 'object' ? 'json' : 'text',
                         value: captured.text,
+                        displayValue: display.snapshot().text,
                         originalBytes: captured.originalBytes
                     });
                 }

package/dist/tools/code-mode/text-output.d.ts

@@ -1,9 +1,10 @@
 export function renderCapturedText(snapshot: any, imageCount?: number): string;
 /** Bounded UTF-8 capture shared by trusted engines, the bridge and retained cells. */
 export class BoundedTextOutput {
-    constructor(maximumBytes: any, separator?: string);
+    constructor(maximumBytes: any, separator?: string, retention?: string);
     maximumBytes: any;
     separator: string;
+    retention: string;
     append(value: any, originalBytes?: number): void;
     snapshot(): {
         text: string;

package/dist/tools/code-mode/text-output.js

@@ -6,9 +6,10 @@ export class BoundedTextOutput {
     #retained = 0;
     #hasValue = false;
     #sealed = false;
-    constructor(maximumBytes, separator = '\n') {
+    constructor(maximumBytes, separator = '\n', retention = 'head') {
         this.maximumBytes = maximumBytes;
         this.separator = separator;
+        this.retention = retention;
     }
     append(value, originalBytes = Buffer.byteLength(value)) {
         const separator = this.#hasValue ? this.separator : '';
@@ -16,10 +17,22 @@ export class BoundedTextOutput {
         this.#original += Buffer.byteLength(separator) + originalBytes;
         this.#capture(separator);
         this.#capture(value);
-        if (originalBytes > Buffer.byteLength(value))
+        if (this.retention === 'head' && originalBytes > Buffer.byteLength(value))
             this.#sealed = true;
     }
     #capture(value) {
+        if (this.retention === 'tail') {
+            let start = Math.max(0, value.length - this.maximumBytes);
+            if (start > 0 && /[\uDC00-\uDFFF]/u.test(value[start]))
+                start++;
+            const bytes = Buffer.from(this.#chunks.join('') + value.slice(start));
+            let offset = Math.max(0, bytes.length - this.maximumBytes);
+            while (offset < bytes.length && (bytes[offset] & 0xc0) === 0x80)
+                offset++;
+            this.#chunks = [bytes.subarray(offset).toString('utf8')];
+            this.#retained = bytes.length - offset;
+            return;
+        }
         const remaining = Math.max(0, this.maximumBytes - this.#used);
         if (this.#sealed || !value.length)
             return;

package/dist/tools/contracts.d.ts

@@ -9,7 +9,7 @@ export interface ClientToolDefinition extends ModelToolDefinition {
     outputSchema?: Record<string, unknown>;
     /** Runtime-only policy. MCP defaults to both callers; other tools default to direct only. */
     allowedCallers?: readonly ToolCaller[];
-    /** Runtime-only allowlist of scalar fields in the public tool.started input. */
+    /** Runtime-only allowlist of scalars and bounded string arrays in public tool.started input. */
     eventInputFields?: readonly string[];
     /** Runtime-only exposure override; retains both permitted entry points with Code Mode enabled. */
     codeModeExposure?: 'both';
@@ -145,6 +145,9 @@ export interface CodeCellEventData {
     truncated?: boolean;
     /** Public output projection discarded older text; not inferred from source truncation. */
     outputHeadTruncated?: boolean;
+    /** Internal public-observation source fact, separate from local head clipping. */
+    outputSourceKnown?: boolean;
+    outputSourceTruncated?: boolean;
     observations?: readonly import('../session/code-observation-contract.js').CodeObservation[];
     error?: {
         code: string;

package/dist/tools/execution.js

@@ -3,7 +3,7 @@ import { toolEventSummary } from '../runtime/event-projection.js';
 import { allowsToolCaller } from './callers.js';
 import { CodeCellExecutionError } from './code-mode/cells.js';
 import { createCodeToolDispatch } from './code-mode/dispatch.js';
-import { boundedModelToolOutput, publicToolEventInput, structuredToolArtifacts, publicExtensionToolEventData, structuredToolEventData, structuredToolFailureData } from './output-projection.js';
+import { boundedModelToolOutput, publicToolEventInput, structuredToolArtifacts, publicExtensionToolEventData, publicOutputTruncation, publicEventOutputData, structuredToolEventData, structuredToolFailureData } from './output-projection.js';
 import { publishModelResources } from '../runtime/resource-publication.js';
 import { executeRegisteredTool } from './runtime.js';
 import { failedToolResultExtensions } from './result-extensions.js';
@@ -137,6 +137,7 @@ export async function executeRoundTools(calls, scope) {
                     ? structuredToolEventData(call.name, output.data)
                     : publicExtensionToolEventData(output.eventData);
             const artifacts = structuredToolArtifacts(output.artifacts);
+            const outputTruncation = publicOutputTruncation(call.name, structuredData);
             await scope.emit({
                 type: 'tool.completed',
                 ...(output.resultExtensions ? { resultExtensions: output.resultExtensions } : {}),
@@ -145,8 +146,10 @@ export async function executeRoundTools(calls, scope) {
                 ...(parentCallId === undefined ? {} : { parentCallId }),
                 summary: eventSummary.summary,
                 truncated: output.truncated === true || modelOutput.truncated || eventSummary.truncated,
+                ...(eventSummary.truncated ? { summaryTruncated: true } : {}),
+                ...(outputTruncation ? { outputTruncation } : {}),
                 ...(artifacts === undefined ? {} : { artifacts }),
-                ...(structuredData === undefined ? {} : { data: structuredData })
+                ...(structuredData === undefined ? {} : { data: publicEventOutputData(structuredData) })
             });
             return {
                 call,
@@ -173,6 +176,7 @@ export async function executeRoundTools(calls, scope) {
                 (partial?.data === undefined
                     ? undefined
                     : structuredToolEventData(call.name, partial.eventData ?? partial.data));
+            const outputTruncation = publicOutputTruncation(call.name, eventData);
             await scope.emit({
                 type: 'tool.failed',
                 ...(failedToolResultExtensions(error)
@@ -186,7 +190,8 @@ export async function executeRoundTools(calls, scope) {
                 ...(permissionStopFromError(error)
                     ? { permissionStop: permissionStopFromError(error) }
                     : {}),
-                ...(eventData === undefined ? {} : { data: eventData })
+                ...(outputTruncation ? { outputTruncation } : {}),
+                ...(eventData === undefined ? {} : { data: publicEventOutputData(eventData) })
             });
             return {
                 call,

package/dist/tools/output-projection.d.ts

@@ -12,6 +12,13 @@ export declare function boundedModelToolOutput(toolName: string, value: string,
 };
 /** The opted-in allowlist fails closed and never mutates the invocation arguments. */
 export declare function publicToolEventInput(value: unknown, fields: readonly string[]): Readonly<Record<string, unknown>>;
+/** Explicit observations are public, but their event projection must remain bounded. */
+export declare function publicCodeObservations(values: unknown, data: CodeCellEventData): CodeCellEventData;
+/** Classify only facts about the public body, never model or summary limits. */
+export declare function publicOutputTruncation(toolName: string, data: unknown): 'HEAD' | 'SOURCE' | undefined;
+/** Remove the internal display direction from published structured data. */
+export declare function publicEventOutputData<T>(data: T): T;
+export declare function liveOutputTruncation(output: import('./contracts.js').ExecOutputSnapshot): 'HEAD' | 'SOURCE' | undefined;
 /** Project only known, validated tool result shapes into public structured events. */
 export declare function structuredToolEventData(toolName: string, value: unknown): CodeCellEventData | ExecResult | ApplyPatchResult | ReadEventData | ViewImageResult | SleepResult | PublicToolMetadata | undefined;
 /** Partial patch facts are allowlisted; arbitrary error details never become public event data. */

package/dist/tools/output-projection.js

@@ -58,6 +58,9 @@ export function publicToolEventInput(value, fields) {
             .filter((key) => Object.hasOwn(value, key) &&
             (typeof value[key] === 'string' ||
                 typeof value[key] === 'boolean' ||
+                (Array.isArray(value[key]) &&
+                    value[key].length <= 100 &&
+                    value[key].every((item) => typeof item === 'string')) ||
                 (typeof value[key] === 'number' && Number.isFinite(value[key])) ||
                 value[key] === null))
             .map((key) => [key, value[key]]));
@@ -68,7 +71,7 @@ export function publicToolEventInput(value, fields) {
     }
 }
 /** Explicit observations are public, but their event projection must remain bounded. */
-function publicCodeObservations(values, data) {
+export function publicCodeObservations(values, data) {
     if (!Array.isArray(values))
         return data;
     const retained = new Set(data.observations ?? []);
@@ -77,6 +80,7 @@ function publicCodeObservations(values, data) {
     let remaining = 10_000;
     let truncated = false;
     let headTruncated = data.outputHeadTruncated === true;
+    let sourceTruncated = data.outputSourceTruncated === true;
     const clip = (text) => {
         let start = Math.max(0, text.length - remaining);
         if (start > 0 && /[\uDC00-\uDFFF]/u.test(text[start]))
@@ -101,6 +105,8 @@ function publicCodeObservations(values, data) {
                 continue;
             }
             displayedCount++;
+            if (!data.outputSourceKnown && entry.truncated === true)
+                sourceTruncated = true;
             truncated ||= entry.truncated === true;
             const value = clip(entry.value);
             selected.unshift({
@@ -116,8 +122,11 @@ function publicCodeObservations(values, data) {
         else if (entry.type === 'tool_result' && isRecord(entry.source) && isRecord(entry.result)) {
             const name = entry.source.toolName;
             if (name !== 'exec' && name !== 'exec_wait') {
-                if (retained.has(entry))
+                if (retained.has(entry)) {
+                    if (!data.outputSourceKnown && entry.result.truncated === true)
+                        sourceTruncated = true;
                     selected.unshift(entry);
+                }
             }
             else if ((name === 'exec' || name === 'exec_wait') &&
                 typeof entry.id === 'string' &&
@@ -129,10 +138,12 @@ function publicCodeObservations(values, data) {
                     continue;
                 }
                 displayedCount++;
+                if (!data.outputSourceKnown && entry.result.truncated === true)
+                    sourceTruncated = true;
                 truncated ||= entry.result.truncated === true;
-                const data = isRecord(entry.result.data) ? entry.result.data : undefined;
-                const stderr = typeof data?.stderr === 'string' ? clip(data.stderr) : undefined;
-                const stdout = typeof data?.stdout === 'string' ? clip(data.stdout) : undefined;
+                const resultData = isRecord(entry.result.data) ? entry.result.data : undefined;
+                const stderr = typeof resultData?.stderr === 'string' ? clip(resultData.stderr) : undefined;
+                const stdout = typeof resultData?.stdout === 'string' ? clip(resultData.stdout) : undefined;
                 const content = stdout === undefined && stderr === undefined && typeof entry.result.content === 'string'
                     ? clip(entry.result.content)
                     : '';
@@ -153,10 +164,48 @@ function publicCodeObservations(values, data) {
     return {
         ...data,
         observations: selected,
+        outputSourceKnown: true,
+        ...(sourceTruncated ? { outputSourceTruncated: true } : {}),
         ...(truncated ? { truncated: true } : {}),
         ...(headTruncated ? { outputHeadTruncated: true } : {})
     };
 }
+/** Classify only facts about the public body, never model or summary limits. */
+export function publicOutputTruncation(toolName, data) {
+    if (!isRecord(data))
+        return undefined;
+    if (toolName === 'code_exec' || toolName === 'code_exec_wait') {
+        if (data.outputSourceTruncated === true)
+            return 'SOURCE';
+        if (data.outputHeadTruncated === true)
+            return 'HEAD';
+    }
+    if (toolName === 'exec' || toolName === 'exec_wait') {
+        const display = isRecord(data.displayOutput) ? data.displayOutput : undefined;
+        if (display)
+            return Number(display.stdoutDroppedBytes) > 0 || Number(display.stderrDroppedBytes) > 0
+                ? 'HEAD'
+                : undefined;
+        if (data.truncated === true)
+            return 'SOURCE';
+    }
+    return undefined;
+}
+/** Remove the internal display direction from published structured data. */
+export function publicEventOutputData(data) {
+    if (!isRecord(data))
+        return data;
+    const { outputHeadTruncated: _head, outputSourceKnown: _known, outputSourceTruncated: _source, ...rest } = data;
+    return rest;
+}
+export function liveOutputTruncation(output) {
+    if (!output.truncated)
+        return undefined;
+    return output.displayOutput &&
+        (output.displayOutput.stdoutDroppedBytes > 0 || output.displayOutput.stderrDroppedBytes > 0)
+        ? 'HEAD'
+        : 'SOURCE';
+}
 /** Project only known, validated tool result shapes into public structured events. */
 export function structuredToolEventData(toolName, value) {
     if (!isRecord(value))
@@ -199,6 +248,8 @@ export function structuredToolEventData(toolName, value) {
                 : {}),
             status: value.status,
             ...(value.outputHeadTruncated === true ? { outputHeadTruncated: true } : {}),
+            ...(value.outputSourceKnown === true ? { outputSourceKnown: true } : {}),
+            ...(value.outputSourceTruncated === true ? { outputSourceTruncated: true } : {}),
             cached: value.cached === true,
             ...(['snapshot', 'completion', 'timeout', 'yield', 'interrupted'].includes(String(value.waitOutcome))
                 ? { waitOutcome: value.waitOutcome }

package/dist/tools/runtime.js

@@ -2,7 +2,7 @@ import { AgentError } from '../error.js';
 import { randomUUID } from 'node:crypto';
 import { AGENT_TOOL_HANDLERS, BUILTIN_TOOL_DEFINITIONS } from './registry.js';
 import { normalizeToolInput } from './input.js';
-import { validateToolResult } from './output-projection.js';
+import { liveOutputTruncation, validateToolResult } from './output-projection.js';
 import { withToolResultExtensions } from './result-extensions.js';
 import { viewResourceImage } from './local/view-image.js';
 export async function executeRegisteredTool(name, arguments_, callId, context, caller = 'direct') {
@@ -58,6 +58,9 @@ export async function executeCapturedTool(kind, call, context) {
                     toolName: name,
                     callId,
                     ...(context.parentCallId === undefined ? {} : { parentCallId: context.parentCallId }),
+                    ...(liveOutputTruncation(output)
+                        ? { outputTruncation: liveOutputTruncation(output) }
+                        : {}),
                     output
                 })
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/agent",
-  "version": "0.11.43",
+  "version": "0.11.45",
   "description": "Embeddable MAR coding agent SDK and CLI.",
   "license": "Apache-2.0",
   "type": "module",