@myagentroam/agent 0.11.32 → 0.11.34

package/dist/agent-core/session/tool-result-resources.js

@@ -1,256 +0,0 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { lstat, mkdir, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { MarAgentError } from '../error.js';
-import { parseToolResultExtensions } from '../tools/result-extensions.js';
-const REF = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/u;
-const MAX_BYTES = 16 * 1024 * 1024;
-export async function writeToolResultResource(directory, text) {
-    const bytes = Buffer.from(text);
-    if (bytes.length > MAX_BYTES)
-        throw resourceError('LIMIT', 'Tool result resource exceeds its limit.');
-    const resourceRef = randomUUID();
-    const folder = join(directory, 'tool_results');
-    await mkdir(folder, { recursive: true, mode: 0o700 });
-    const temporary = join(folder, `.${resourceRef}.tmp`);
-    await writeFile(join(folder, `.${resourceRef}.pending`), '', {
-        flag: 'wx',
-        mode: 0o600,
-        flush: true
-    });
-    try {
-        await writeFile(temporary, bytes, { flag: 'wx', mode: 0o600, flush: true });
-        await rename(temporary, join(folder, `${resourceRef}.diff`));
-    }
-    finally {
-        await rm(temporary, { force: true });
-    }
-    return {
-        status: 'available',
-        resourceRef,
-        format: 'unified-diff',
-        byteSize: bytes.length,
-        sha256: createHash('sha256').update(bytes).digest('hex')
-    };
-}
-export function recordToolResources(record) {
-    if (!['tool.completed', 'tool.failed'].includes(record.type))
-        return [];
-    const payload = record.payload;
-    const sources = [
-        payload?.resultExtensions,
-        ...(Array.isArray(payload?.data?.calls)
-            ? payload.data.calls.map((call) => call.resultExtensions)
-            : [])
-    ];
-    return sources.flatMap((source) => (parseToolResultExtensions(source) ?? []).flatMap((extension) => extension.entries.flatMap((entry) => (entry.diff.status === 'available' ? [entry.diff] : []))));
-}
-/** A locator is only a hint: reads must verify its exact committed record identity. */
-export async function bindToolResultResources(directory, record, readRecord, degrade = false) {
-    for (const resource of recordToolResources(record)) {
-        try {
-            await bindToolResultResource(directory, record, resource, readRecord);
-        }
-        catch (error) {
-            if (!degrade)
-                throw error;
-            // Shared descriptors are downgraded before persistence and live publication, never the tool outcome.
-            const payload = record.payload;
-            for (const extensions of [
-                payload.resultExtensions,
-                ...(payload.data?.calls ?? []).map((call) => call.resultExtensions)
-            ]) {
-                for (const extension of extensions ?? [])
-                    for (const entry of extension.entries) {
-                        if (entry.diff.status === 'available' &&
-                            entry.diff.resourceRef === resource.resourceRef)
-                            entry.diff = { status: 'unavailable', reason: 'storage-failed' };
-                    }
-            }
-        }
-    }
-}
-async function bindToolResultResource(directory, record, resource, readRecord) {
-    const path = join(directory, 'tool_results', `${resource.resourceRef}.json`);
-    try {
-        await writeFile(path, JSON.stringify({ sequence: record.sequence, recordId: record.recordId }), { flag: 'wx', mode: 0o600, flush: true });
-    }
-    catch (error) {
-        if (error.code !== 'EEXIST')
-            throw error;
-        try {
-            const locator = JSON.parse(await readFile(path, 'utf8'));
-            const existing = locator.sequence === record.sequence && locator.recordId === record.recordId
-                ? record
-                : Number.isSafeInteger(locator.sequence)
-                    ? await readRecord?.(locator.sequence)
-                    : undefined;
-            if (!existing ||
-                existing.recordId !== locator.recordId ||
-                !recordToolResources(existing).some((entry) => entry.resourceRef === resource.resourceRef && entry.sha256 === resource.sha256))
-                throw resourceError('CORRUPT', 'Tool resource locator conflicts with committed history.');
-        }
-        catch (cause) {
-            throw normalizedResourceError(cause);
-        }
-    }
-}
-export function toolResultResourceFiles(records) {
-    return new Set(records.flatMap((record) => recordToolResources(record).flatMap((resource) => [
-        `${resource.resourceRef}.diff`,
-        `${resource.resourceRef}.json`
-    ])));
-}
-export async function copyToolResultResources(source, target, records) {
-    const copied = new Set();
-    for (const record of records) {
-        for (const resource of recordToolResources(record)) {
-            if (copied.has(resource.resourceRef))
-                continue;
-            copied.add(resource.resourceRef);
-            try {
-                const bytes = await readResourceBytes(source, resource);
-                const directory = join(target, 'tool_results');
-                await mkdir(directory, { recursive: true, mode: 0o700 });
-                await writeFile(join(directory, `${resource.resourceRef}.diff`), bytes, {
-                    flag: 'wx',
-                    mode: 0o600,
-                    flush: true
-                });
-            }
-            catch (error) {
-                if (error instanceof MarAgentError && error.code === 'MAR_AGENT_TOOL_RESOURCE_NOT_FOUND')
-                    continue;
-                throw error;
-            }
-        }
-        if (recordToolResources(record).length) {
-            await mkdir(join(target, 'tool_results'), { recursive: true, mode: 0o700 });
-            await bindToolResultResources(target, record, async (sequence) => records.find((item) => item.sequence === sequence));
-        }
-    }
-}
-export async function completeToolResultResources(directory, record) {
-    await Promise.all(recordToolResources(record).map((resource) => rm(join(directory, 'tool_results', `.${resource.resourceRef}.pending`), {
-        force: true
-    }).catch(() => undefined)));
-}
-export async function cleanupUnreferencedToolResources(directory, readRecords) {
-    const folder = join(directory, 'tool_results');
-    let names;
-    try {
-        names = await readdir(folder);
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return;
-        throw error;
-    }
-    const pending = names.filter((name) => name.startsWith('.') && name.endsWith('.pending') && REF.test(name.slice(1, -8)));
-    if (!pending.length)
-        return;
-    const retained = toolResultResourceFiles(await readRecords());
-    for (const marker of pending) {
-        const ref = marker.slice(1, -8);
-        for (const name of [`${ref}.diff`, `${ref}.json`, `.${ref}.tmp`]) {
-            if (retained.has(name))
-                continue;
-            const path = join(folder, name);
-            try {
-                if ((await lstat(path)).isFile())
-                    await rm(path);
-            }
-            catch (error) {
-                if (error.code !== 'ENOENT')
-                    throw error;
-            }
-        }
-        await rm(join(folder, marker), { force: true });
-    }
-}
-export async function readToolResultResource(directory, sessionId, input, readRecord) {
-    if (!REF.test(input.resourceRef) ||
-        (input.maxBytes !== undefined &&
-            (!Number.isSafeInteger(input.maxBytes) || input.maxBytes < 4 || input.maxBytes > 256 * 1024)))
-        throw resourceError('INPUT_INVALID', 'Invalid tool resource request.');
-    let locator;
-    try {
-        const file = join(directory, 'tool_results', `${input.resourceRef}.json`);
-        locator = JSON.parse(await readFile(file, 'utf8'));
-    }
-    catch (error) {
-        throw normalizedResourceError(error);
-    }
-    if (!Number.isSafeInteger(locator.sequence) ||
-        locator.sequence < 1 ||
-        typeof locator.recordId !== 'string')
-        throw resourceError('CORRUPT', 'Invalid tool resource locator.');
-    const record = await readRecord(locator.sequence);
-    const resource = record?.recordId === locator.recordId
-        ? recordToolResources(record).find((entry) => entry.resourceRef === input.resourceRef)
-        : undefined;
-    if (!resource)
-        throw resourceError('NOT_FOUND', 'Tool resource is not part of this session history.');
-    const bytes = await readResourceBytes(directory, resource);
-    let offset = 0;
-    if (input.cursor !== undefined) {
-        try {
-            if (input.cursor.length > 1024)
-                throw new Error('cursor');
-            const cursor = JSON.parse(Buffer.from(input.cursor, 'base64url').toString('utf8'));
-            if (cursor.sessionId !== sessionId ||
-                cursor.ref !== resource.resourceRef ||
-                cursor.sha256 !== resource.sha256 ||
-                !Number.isSafeInteger(cursor.offset) ||
-                cursor.offset < 0 ||
-                cursor.offset >= bytes.length)
-                throw new Error('cursor');
-            offset = cursor.offset;
-        }
-        catch {
-            throw resourceError('INPUT_INVALID', 'Invalid tool resource cursor.');
-        }
-    }
-    if (offset > 0 && (bytes[offset] & 0xc0) === 0x80)
-        throw resourceError('INPUT_INVALID', 'Invalid tool resource cursor boundary.');
-    let end = Math.min(bytes.length, offset + (input.maxBytes ?? 256 * 1024));
-    while (end < bytes.length && (bytes[end] & 0xc0) === 0x80)
-        end--;
-    if ((await readRecord(locator.sequence))?.recordId !== locator.recordId)
-        throw resourceError('NOT_FOUND', 'Tool resource history has changed.');
-    return {
-        type: 'file_changes',
-        version: 1,
-        format: resource.format,
-        resourceRef: resource.resourceRef,
-        byteSize: resource.byteSize,
-        sha256: resource.sha256,
-        content: bytes.subarray(offset, end).toString('utf8'),
-        ...(end < bytes.length
-            ? {
-                nextCursor: Buffer.from(JSON.stringify({
-                    sessionId,
-                    ref: resource.resourceRef,
-                    sha256: resource.sha256,
-                    offset: end
-                })).toString('base64url')
-            }
-            : {})
-    };
-}
-async function readResourceBytes(directory, resource) {
-    try {
-        return await readFile(join(directory, 'tool_results', `${resource.resourceRef}.diff`));
-    }
-    catch (error) {
-        throw normalizedResourceError(error);
-    }
-}
-function resourceError(suffix, message) {
-    return new MarAgentError(`MAR_AGENT_TOOL_RESOURCE_${suffix}`, message);
-}
-function normalizedResourceError(error) {
-    if (error instanceof MarAgentError)
-        return error;
-    return resourceError(error?.code === 'ENOENT' ? 'NOT_FOUND' : 'CORRUPT', 'Tool result resource is unavailable.');
-}

package/dist/agent-core/session/transaction-recovery.d.ts

@@ -1,16 +0,0 @@
-export declare function isUnjournaledTransactionFile(name: string): boolean;
-export interface SessionStorageTransaction {
-    readonly version: 1;
-    readonly id: string;
-    readonly kind: 'rollback' | 'clear';
-    readonly originalSegments: readonly string[];
-    readonly stagedSegments: readonly {
-        readonly path: string;
-        readonly temporary: string;
-    }[];
-    readonly sidecarBackup: string;
-}
-/** The index's transaction ID, not the journal's existence, decides the commit side. */
-export declare function beginSessionStorageTransaction(directory: string, transaction: SessionStorageTransaction): Promise<void>;
-/** Must run under the corresponding Session writer lock. Safe to repeat after interruption. */
-export declare function recoverSessionStorageTransaction(directory: string, committedTransactionId?: string): Promise<void>;

package/dist/agent-core/session/transaction-recovery.js

@@ -1,135 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { lstat, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { MarAgentError } from '../error.js';
-const JOURNAL = 'storage-transaction.json';
-const SEGMENT = /^events-\d{6}\.jsonl$/u;
-const TRANSACTION_ID = /^[0-9a-f-]{36}$/iu;
-const STAGING_FILE = /^events-\d{6}\.jsonl\.[0-9a-f-]{36}\.rollback-tmp$/iu;
-const JOURNAL_TEMP = /^storage-transaction\.json\.[0-9a-f-]{36}\.tmp$/iu;
-export function isUnjournaledTransactionFile(name) {
-    return STAGING_FILE.test(name) || JOURNAL_TEMP.test(name);
-}
-/** The index's transaction ID, not the journal's existence, decides the commit side. */
-export async function beginSessionStorageTransaction(directory, transaction) {
-    const temporary = join(directory, `${JOURNAL}.${randomUUID()}.tmp`);
-    try {
-        await writeFile(temporary, JSON.stringify(transaction), {
-            mode: 0o600,
-            flag: 'wx',
-            flush: true
-        });
-        await rename(temporary, join(directory, JOURNAL));
-    }
-    finally {
-        await rm(temporary, { force: true });
-    }
-}
-/** Must run under the corresponding Session writer lock. Safe to repeat after interruption. */
-export async function recoverSessionStorageTransaction(directory, committedTransactionId) {
-    const journal = join(directory, JOURNAL);
-    let raw;
-    try {
-        raw = await readFile(journal, 'utf8');
-    }
-    catch (error) {
-        if (error.code === 'ENOENT') {
-            await removeUnjournaledTransactionFiles(directory);
-            return;
-        }
-        throw error;
-    }
-    let transaction;
-    try {
-        transaction = JSON.parse(raw);
-        if (transaction?.version !== 1 ||
-            !TRANSACTION_ID.test(transaction.id) ||
-            (transaction.kind !== 'rollback' && transaction.kind !== 'clear') ||
-            !Array.isArray(transaction.originalSegments) ||
-            !transaction.originalSegments.every((name) => typeof name === 'string' && SEGMENT.test(name)) ||
-            !Array.isArray(transaction.stagedSegments) ||
-            !transaction.stagedSegments.every((entry) => typeof entry?.path === 'string' &&
-                SEGMENT.test(entry.path) &&
-                typeof entry.temporary === 'string' &&
-                /^events-\d{6}\.jsonl\.[0-9a-f-]{36}\.rollback-tmp$/iu.test(entry.temporary) &&
-                entry.temporary.startsWith(`${entry.path}.`)) ||
-            typeof transaction.sidecarBackup !== 'string' ||
-            !new RegExp(`^context-world-state\\.json\\.\\d+\\.${transaction.id}\\.${transaction.kind}-backup$`, 'u').test(transaction.sidecarBackup))
-            throw new Error('invalid session transaction');
-    }
-    catch (cause) {
-        throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Session storage transaction is corrupt.', {
-            cause
-        });
-    }
-    const committed = transaction.id === committedTransactionId;
-    const originals = new Set(transaction.originalSegments);
-    for (const name of transaction.originalSegments) {
-        const canonical = join(directory, name);
-        const backup = `${canonical}.${transaction.id}.${transaction.kind}-backup`;
-        if (!(await exists(backup)))
-            continue;
-        if (committed)
-            await rm(backup, { force: true });
-        else {
-            await rm(canonical, { force: true });
-            await rename(backup, canonical);
-        }
-    }
-    if (!committed)
-        for (const entry of transaction.stagedSegments)
-            if (!originals.has(entry.path))
-                await rm(join(directory, entry.path), { force: true });
-    for (const entry of transaction.stagedSegments)
-        await rm(join(directory, entry.temporary), { force: true });
-    const sidecar = join(directory, 'context-world-state.json');
-    const backup = join(directory, transaction.sidecarBackup);
-    if (await exists(backup)) {
-        if (committed)
-            await rm(backup, { force: true });
-        else {
-            await rm(sidecar, { force: true });
-            await rename(backup, sidecar);
-        }
-    }
-    for (const folder of ['generated_images', 'tool_results', 'resources']) {
-        const path = join(directory, folder);
-        let names;
-        try {
-            names = await readdir(path);
-        }
-        catch (error) {
-            if (error.code === 'ENOENT')
-                continue;
-            throw error;
-        }
-        const suffix = `.${transaction.id}.rollback-trash`;
-        for (const name of names) {
-            if (!name.startsWith('.') || !name.endsWith(suffix))
-                continue;
-            const trash = join(path, name);
-            if (committed)
-                await rm(trash, { force: true });
-            else
-                await rename(trash, join(path, name.slice(1, -suffix.length)));
-        }
-    }
-    await rm(journal);
-    await removeUnjournaledTransactionFiles(directory);
-}
-async function removeUnjournaledTransactionFiles(directory) {
-    for (const name of await readdir(directory))
-        if (isUnjournaledTransactionFile(name))
-            await rm(join(directory, name), { force: true });
-}
-async function exists(path) {
-    try {
-        await lstat(path);
-        return true;
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return false;
-        throw error;
-    }
-}

package/dist/agent-core/storage/file-lock.js

@@ -1,83 +0,0 @@
-import { open, readFile, rm } from 'node:fs/promises';
-import { setTimeout as delay } from 'node:timers/promises';
-import { MarAgentError } from '../error.js';
-export async function acquireFileLock(path, message = 'Session index is busy.', waitMs = 5000, options = {}) {
-    const deadline = Date.now() + waitMs;
-    for (;;) {
-        options.signal?.throwIfAborted();
-        let handle;
-        try {
-            handle = await open(path, 'wx', 0o600);
-        }
-        catch (cause) {
-            if (cause.code !== 'EEXIST')
-                throw cause;
-            if (await removeDeadOwner(path))
-                continue;
-            if (Date.now() >= deadline)
-                throw new MarAgentError(options.code ?? 'MAR_AGENT_SESSION_LOCKED', message, { cause });
-            await delay(25 + Math.floor(Math.random() * 25), undefined, options.signal ? { signal: options.signal } : {});
-            continue;
-        }
-        try {
-            await handle.writeFile(JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString() }));
-            options.signal?.throwIfAborted();
-        }
-        catch (error) {
-            try {
-                await handle.close();
-            }
-            finally {
-                await rm(path, { force: true });
-            }
-            throw error;
-        }
-        let released = false;
-        return async () => {
-            if (released)
-                return;
-            released = true;
-            await handle.close();
-            await rm(path, { force: true });
-        };
-    }
-}
-async function removeDeadOwner(path) {
-    const reclaimerPath = `${path}.reclaim`;
-    let reclaimer;
-    try {
-        // Only one process may unlink a dead owner's path; all other contenders wait.
-        reclaimer = await open(reclaimerPath, 'wx', 0o600);
-    }
-    catch (error) {
-        if (error.code === 'EEXIST')
-            return false;
-        throw error;
-    }
-    try {
-        const owner = JSON.parse(await readFile(path, 'utf8'));
-        if (typeof owner.pid !== 'number' || !Number.isSafeInteger(owner.pid))
-            return false;
-        try {
-            process.kill(owner.pid, 0);
-            return false;
-        }
-        catch (error) {
-            if (error.code !== 'ESRCH')
-                return false;
-            await rm(path, { force: true });
-            return true;
-        }
-    }
-    catch {
-        return false;
-    }
-    finally {
-        try {
-            await reclaimer.close();
-        }
-        finally {
-            await rm(reclaimerPath, { force: true });
-        }
-    }
-}

package/dist/agent-core/subagent/contracts.d.ts

@@ -1,117 +0,0 @@
-import type { MarAgentReasoningEffort } from '../model/configuration.js';
-export interface SubagentTaskInput {
-    description: string;
-    prompt: string;
-    role: 'general-purpose' | 'explore';
-    modelId?: string;
-    reasoningEffort?: MarAgentReasoningEffort;
-    background?: boolean;
-    parentSubagentId?: string;
-}
-export interface SubagentTaskResult {
-    summary: string;
-    changedFiles: string[];
-    verification: string[];
-    evidence: Array<{
-        path: string;
-        startLine?: number;
-        endLine?: number;
-    }>;
-}
-export interface SubagentLatestMessage {
-    itemId: string;
-    turnId: string;
-    phase: 'commentary' | 'final_answer';
-    text: string;
-    timestamp: string;
-    truncated: boolean;
-}
-export type SubagentLatestActivity = {
-    kind: 'message';
-    timestamp: string;
-    phase: 'commentary' | 'final_answer';
-} | {
-    kind: 'tool';
-    timestamp: string;
-    toolName: string;
-    status: 'started' | 'completed' | 'failed';
-};
-export interface SubagentTaskSnapshot extends Record<string, unknown> {
-    permissionStop?: import('../tools/permissions.js').PermissionStop;
-    agentId: string;
-    description: string;
-    role?: SubagentTaskInput['role'];
-    extensionId?: string;
-    status: 'queued' | 'running' | 'completed' | 'failed' | 'cancelled' | 'interrupted';
-    modelId?: string;
-    modelName?: string;
-    reasoningEffort?: MarAgentReasoningEffort;
-    latestMessage?: SubagentLatestMessage;
-    latestActivity?: SubagentLatestActivity;
-    summary?: string;
-    changedFiles?: string[];
-    verification?: string[];
-    evidence?: Array<{
-        path: string;
-        startLine?: number;
-        endLine?: number;
-    }>;
-    errorCode?: string;
-    errorMessage?: string;
-    messageId?: string;
-    turnId?: string;
-    deliveryStatus?: 'accepted' | 'applied' | 'cancelled' | 'failed';
-    waitOutcome?: SubagentWaitOutcome;
-    reason?: 'steer';
-}
-export type SubagentWaitFor = 'completion' | 'message';
-export type SubagentWaitOutcome = Exclude<import('../tools/wait.js').ToolWaitOutcome, 'yield'>;
-export interface SubagentMessageOptions {
-    delivery?: 'append' | 'replace';
-    signal?: AbortSignal;
-}
-export interface SubagentRunOptions {
-    turnSignal?: AbortSignal;
-    waitFor?: 'start' | 'completion';
-    signal?: AbortSignal;
-    onCreated?: (task: SubagentTaskSnapshot) => Promise<void> | void;
-}
-export interface SubagentOutputOptions {
-    waitInterrupt?: import('../tools/wait.js').ToolWaitInterrupt | undefined;
-    untilSettled?: true;
-    waitMs?: number;
-    waitFor?: SubagentWaitFor;
-    signal?: AbortSignal;
-}
-export type SubagentWaitMode = 'any' | 'all';
-export interface SubagentManyOutputOptions extends Omit<SubagentOutputOptions, 'untilSettled'> {
-    mode?: SubagentWaitMode;
-}
-export interface SubagentManyOutput {
-    mode: SubagentWaitMode;
-    waitFor: SubagentWaitFor;
-    waitOutcome: SubagentWaitOutcome;
-    reason?: 'steer';
-    agents: SubagentTaskSnapshot[];
-    pendingAgentIds: string[];
-}
-export interface SubagentHandledResult {
-    readonly outcome: 'handled';
-    readonly value?: unknown;
-}
-export type SubagentRunResult = SubagentTaskSnapshot | SubagentHandledResult;
-export interface SubagentController {
-    beginExecution?(runner: (task: SubagentTaskInput, signal: AbortSignal) => Promise<SubagentTaskResult>): void;
-    run(input: SubagentTaskInput, options?: SubagentRunOptions): Promise<SubagentRunResult>;
-    output(agentId: string, options?: SubagentOutputOptions): Promise<SubagentTaskSnapshot>;
-    outputAny(options?: SubagentOutputOptions): Promise<SubagentTaskSnapshot>;
-    outputMany(agentIds: readonly string[], options?: SubagentManyOutputOptions): Promise<SubagentManyOutput>;
-    message(agentId: string, message: string, options?: SubagentMessageOptions): Promise<SubagentTaskSnapshot>;
-    cancel(agentId: string): Promise<SubagentTaskSnapshot>;
-    listSessionResources(): readonly {
-        agentId: string;
-        status: SubagentTaskSnapshot['status'];
-        description: string;
-    }[];
-    dispose(): Promise<void>;
-}

package/dist/agent-core/subagent/model-update.js

@@ -1,81 +0,0 @@
-import { escapeMarkupText, markupAttributes } from '../prompts/markup.js';
-import { TOOL_EXECUTION_LIMITS } from '../tools/execution-limits.js';
-export function renderSubagentUpdate(snapshot, truncated = false) {
-    const attributes = (values) => markupAttributes(Object.fromEntries(Object.entries(values).map(([key, value]) => {
-        if (value === undefined)
-            return [key, undefined];
-        let bounded = '';
-        let count = 0;
-        for (const point of String(value)) {
-            if (count++ === 256) {
-                truncated = true;
-                break;
-            }
-            bounded += point;
-        }
-        return [key, bounded];
-    })));
-    const root = '<mar_subagent_update' +
-        attributes({
-            agentId: snapshot.agentId,
-            status: snapshot.status,
-            modelId: snapshot.modelId,
-            modelName: snapshot.modelName,
-            reasoningEffort: snapshot.reasoningEffort,
-            messageId: snapshot.messageId,
-            turnId: snapshot.turnId,
-            deliveryStatus: snapshot.deliveryStatus
-        });
-    const close = '</mar_subagent_update>';
-    let remaining = TOOL_EXECUTION_LIMITS.subagentUpdateMaxBytes -
-        Buffer.byteLength(root + ' truncated="false">\n' + close);
-    const lines = [];
-    const field = (name, value, metadata = {}, limit = remaining) => {
-        let attrs = attributes(metadata);
-        const overhead = Buffer.byteLength('  <' + name + attrs + '></' + name + '>\n');
-        if (overhead > remaining) {
-            truncated = true;
-            return;
-        }
-        let budget = Math.min(limit, remaining - overhead);
-        let text = '';
-        let clipped = false;
-        for (const point of value) {
-            const encoded = escapeMarkupText(point);
-            const bytes = Buffer.byteLength(encoded);
-            if (bytes > budget) {
-                clipped = true;
-                break;
-            }
-            text += encoded;
-            budget -= bytes;
-        }
-        if (clipped) {
-            truncated = true;
-            if ('truncated' in metadata)
-                attrs = attributes({ ...metadata, truncated: true });
-        }
-        const opening = '  <' + name + attrs;
-        const line = text === '' ? opening + ' />\n' : opening + '>' + text + '</' + name + '>\n';
-        remaining -= Buffer.byteLength(line);
-        lines.push(line);
-    };
-    // Preserve failure/permission facts before spending the remaining budget on result text.
-    if (snapshot.errorCode !== undefined || snapshot.errorMessage !== undefined)
-        field('error', snapshot.errorMessage ?? '', { code: snapshot.errorCode }, 1024);
-    if (snapshot.permissionStop)
-        field('permission_stop', snapshot.permissionStop.reason, { action: snapshot.permissionStop.action, ...snapshot.permissionStop.source }, 1024);
-    field('description', snapshot.description, {}, 1024);
-    if (snapshot.latestMessage) {
-        const { text, ...metadata } = snapshot.latestMessage;
-        truncated ||= metadata.truncated;
-        field('message', text, metadata, TOOL_EXECUTION_LIMITS.subagentSummaryMaxBytes);
-    }
-    if (snapshot.summary !== undefined)
-        field('summary', snapshot.summary);
-    for (const path of snapshot.changedFiles ?? [])
-        field('changed_file', path);
-    if (snapshot.latestActivity)
-        field('activity', '', snapshot.latestActivity);
-    return root + ' truncated="' + String(truncated) + '">\n' + lines.join('') + close;
-}