@myagentroam/agent 0.9.156 → 0.9.158

package/dist/agent-core/model/anthropic-messages.js

@@ -160,13 +160,16 @@ export class AnthropicMessagesAdapter {
                         delta: text(block.text) ?? ''
                     };
                 else if (blockType === 'server_tool_use') {
-                    const kind = text(block.name) === 'web_fetch' ? 'WEB_FETCH' : 'WEB_SEARCH';
+                    const toolName = text(block.name) ?? 'unknown';
+                    const kind = toolName === 'web_fetch' ? 'WEB_FETCH' : 'WEB_SEARCH';
                     const summary = anthropicHostedInputSummary(record(block.input));
-                    hostedTools.set(id, { kind, summary });
+                    hostedTools.set(id, { kind, toolName, summary });
                     yield {
                         type: 'hosted_tool',
                         itemId: id,
                         kind,
+                        toolName,
+                        ...(Object.keys(summary).length ? { input: summary } : {}),
                         status: 'RUNNING',
                         summary
                     };
@@ -188,6 +191,19 @@ export class AnthropicMessagesAdapter {
                             type: 'hosted_tool',
                             itemId: toolId,
                             kind: hosted.kind,
+                            toolName: hosted.toolName,
+                            ...(Object.keys(anthropicHostedInputSummary(hosted.summary)).length
+                                ? { input: anthropicHostedInputSummary(hosted.summary) }
+                                : {}),
+                            ...(sources.length
+                                ? {
+                                    output: {
+                                        sources,
+                                        ...(summary.sourcesTruncated ? { sourcesTruncated: true } : {})
+                                    }
+                                }
+                                : {}),
+                            ...(summary.sourcesTruncated ? { truncated: true } : {}),
                             status: anthropicHostedResultFailed(result) ? 'FAILED' : 'COMPLETED',
                             summary
                         };
@@ -267,6 +283,8 @@ export class AnthropicMessagesAdapter {
                                 type: 'hosted_tool',
                                 itemId: block.id,
                                 kind: hosted.kind,
+                                toolName: hosted.toolName,
+                                input: anthropicHostedInputSummary(record(input)),
                                 status: 'RUNNING',
                                 summary
                             };

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

@@ -118,6 +118,10 @@ export type ModelEvent = {
     itemId: string;
     kind: 'WEB_SEARCH' | 'WEB_FETCH';
     status: 'RUNNING' | 'COMPLETED' | 'FAILED';
+    toolName?: string;
+    input?: Record<string, unknown>;
+    output?: unknown;
+    truncated?: boolean;
     summary: {
         query?: string | undefined;
         url?: string | undefined;

package/dist/agent-core/model/openai-responses.js

@@ -475,11 +475,25 @@ export class OpenAiResponsesAdapter {
                         ? 'WEB_FETCH'
                         : (previous?.kind ?? 'WEB_SEARCH');
                     const summary = { ...previous?.summary, ...hostedWebActionSummary(action) };
-                    hostedWebCalls.set(itemId, { kind, summary });
+                    const projected = hostedWebActionInput(action);
+                    const input = { ...previous?.input, ...projected.input };
+                    const truncated = previous?.truncated === true || projected.truncated;
+                    hostedWebCalls.set(itemId, { kind, summary, input, truncated });
+                    const output = {
+                        ...(summary.title === undefined ? {} : { title: summary.title }),
+                        ...(summary.sources === undefined ? {} : { sources: summary.sources }),
+                        ...(summary.sourcesTruncated === undefined
+                            ? {}
+                            : { sourcesTruncated: summary.sourcesTruncated })
+                    };
                     yield {
                         type: 'hosted_tool',
                         itemId,
                         kind,
+                        toolName: 'web_search',
+                        ...(Object.keys(input).length ? { input } : {}),
+                        ...(Object.keys(output).length ? { output } : {}),
+                        ...(truncated || summary.sourcesTruncated === true ? { truncated: true } : {}),
                         status: type.endsWith('.failed')
                             ? 'FAILED'
                             : type.endsWith('.completed') || type === 'response.output_item.done'
@@ -1510,6 +1524,29 @@ const RESPONSE_ITEM_TYPES = new Set([
 ]);
 // A freeform patch item can contain the complete 4 MiB patch plus its JSON envelope.
 const MAX_RESPONSE_ITEM_BYTES = 5 * 1024 * 1024;
+function hostedWebActionInput(action) {
+    const input = {};
+    let truncated = false;
+    for (const [key, limit] of [
+        ['type', 128],
+        ['query', 10_000],
+        ['url', 2_048],
+        ['pattern', 10_000]
+    ]) {
+        const value = action[key];
+        if (typeof value !== 'string')
+            continue;
+        input[key] = value.slice(0, limit);
+        truncated ||= value.length > limit;
+    }
+    if (Array.isArray(action.queries)) {
+        const queries = action.queries.filter((value) => typeof value === 'string');
+        input.queries = queries.slice(0, 10).map((value) => value.slice(0, 10_000));
+        truncated ||=
+            queries.length > 10 || queries.slice(0, 10).some((value) => value.length > 10_000);
+    }
+    return { input, truncated };
+}
 function hostedWebActionSummary(action) {
     const queries = Array.isArray(action.queries)
         ? action.queries

package/dist/agent-core/runtime/event-projection.d.ts

@@ -1,5 +1,9 @@
-import type { ModelUsage } from '../model/contracts.js';
-import type { MarAgentEvent } from './events.js';
+import type { ModelEvent, ModelUsage } from '../model/contracts.js';
+import type { EventPayload, MarAgentEvent } from './events.js';
 /** Keep streaming deltas live-only; exec output has one durable copy in model context records. */
 export declare function eventForPersistence(event: MarAgentEvent): MarAgentEvent | undefined;
 export declare function publicModelUsage(usage: ModelUsage): Omit<ModelUsage, 'rolloutBudgetUnits'>;
+/** Provider-hosted calls are ordinary public tools, never local execution requests. */
+export declare function publicHostedToolEvents(event: Extract<ModelEvent, {
+    type: 'hosted_tool';
+}>): readonly EventPayload[];

package/dist/agent-core/runtime/event-projection.js

@@ -1,3 +1,4 @@
+import { AGENT_EXECUTION_POLICY } from './execution-policy.js';
 /** Keep streaming deltas live-only; exec output has one durable copy in model context records. */
 export function eventForPersistence(event) {
     if (event.type === 'message.delta' ||
@@ -15,3 +16,47 @@ export function publicModelUsage(usage) {
     void rolloutBudgetUnits;
     return publicUsage;
 }
+/** Provider-hosted calls are ordinary public tools, never local execution requests. */
+export function publicHostedToolEvents(event) {
+    const toolName = event.toolName ?? (event.kind === 'WEB_SEARCH' ? 'web_search' : 'web_fetch');
+    const legacyInput = {
+        ...(event.summary.query === undefined ? {} : { query: event.summary.query }),
+        ...(event.summary.url === undefined ? {} : { url: event.summary.url })
+    };
+    const input = event.input ?? (Object.keys(legacyInput).length ? legacyInput : undefined);
+    const legacyOutput = {
+        ...(event.summary.title === undefined ? {} : { title: event.summary.title }),
+        ...(event.summary.sources?.length ? { sources: event.summary.sources.slice(0, 20) } : {}),
+        ...(event.summary.sourcesTruncated === true || (event.summary.sources?.length ?? 0) > 20
+            ? { sourcesTruncated: true }
+            : {})
+    };
+    const output = event.output ?? (Object.keys(legacyOutput).length ? legacyOutput : undefined);
+    const text = typeof output === 'string' ? output : output === undefined ? '' : JSON.stringify(output);
+    const summary = text.slice(0, AGENT_EXECUTION_POLICY.toolEventSummaryCharacters);
+    const truncated = event.truncated === true ||
+        legacyOutput.sourcesTruncated === true ||
+        summary.length < text.length;
+    const started = {
+        type: 'tool.started',
+        toolName,
+        callId: event.itemId,
+        ...(input === undefined ? {} : { input }),
+        ...(truncated ? { truncated: true } : {})
+    };
+    if (event.status === 'RUNNING')
+        return [started];
+    if (event.status === 'FAILED')
+        return [
+            started,
+            {
+                type: 'tool.failed',
+                toolName,
+                callId: event.itemId,
+                code: 'HOSTED_TOOL_FAILED',
+                message: summary || 'Hosted tool failed.',
+                truncated
+            }
+        ];
+    return [started, { type: 'tool.completed', toolName, callId: event.itemId, summary, truncated }];
+}

package/dist/agent-core/runtime/events.d.ts

@@ -46,6 +46,7 @@ export type MarAgentEvent = MarAgentEventBase & ({
     type: 'reasoning.summary';
     text: string;
 } | {
+    /** Legacy persisted event; the Catalog exposes standard tool events instead. */
     type: 'hosted_tool.updated';
     itemId: string;
     kind: 'WEB_SEARCH' | 'WEB_FETCH';
@@ -71,6 +72,7 @@ export type MarAgentEvent = MarAgentEventBase & ({
     callId: string;
     parentCallId?: string;
     input?: unknown;
+    truncated?: boolean;
 } | {
     type: 'tool.completed';
     toolName: string;
@@ -88,6 +90,7 @@ export type MarAgentEvent = MarAgentEventBase & ({
     parentCallId?: string;
     code: string;
     message?: string;
+    truncated?: boolean;
 } | {
     type: 'usage.updated';
     inputTokens?: number | undefined;

package/dist/agent-core/runtime/execution.js

@@ -3,7 +3,7 @@ import { isProviderContextOverflow, recoverModelStream } from '../model/recovery
 import { modelStreamEventObservedAt } from '../model/sse.js';
 import { modelOutputContinuationMessage } from '../prompts/output.js';
 import { executeRoundTools } from '../tools/execution.js';
-import { publicModelUsage } from './event-projection.js';
+import { publicHostedToolEvents, publicModelUsage } from './event-projection.js';
 import { PlanOutputPrefix, splitPlanOutput } from './plan-output.js';
 /** Own the single model/tool loop; the SDK owns its handle, terminal events and cleanup. */
 export class ExecutionLoop {
@@ -215,13 +215,8 @@ export class ExecutionLoop {
                     }
                     else if (event.type === 'hosted_tool') {
                         if (mode !== 'compact')
-                            await input.publish({
-                                type: 'hosted_tool.updated',
-                                itemId: event.itemId,
-                                kind: event.kind,
-                                status: event.status,
-                                summary: event.summary
-                            });
+                            for (const toolEvent of publicHostedToolEvents(event))
+                                await input.publish(toolEvent);
                     }
                     else if (event.type === 'citation') {
                         if (mode !== 'compact')

package/dist/agent-core/session/catalog.d.ts

@@ -4,6 +4,8 @@ import type { SessionListInput, SessionSource } from './types.js';
 export interface MarAgentSessionSummary {
     id: string;
     title: string;
+    /** First non-empty user input, whitespace-normalized and bounded to 160 characters. */
+    firstUserMessagePreview?: string;
     workspace: string;
     createdAt: string;
     lastActivityAt: string;
@@ -54,6 +56,7 @@ export interface MarAgentSessionImage {
 /** Public session catalog facade. Storage details remain SDK-private. */
 export interface MarAgentSessionCatalog {
     list(input?: SessionListInput): Promise<MarAgentSessionPage>;
+    firstUserMessagePreview(sessionId: string): Promise<string | undefined>;
     executionConfiguration(sessionId: string): Promise<{
         readonly modelId: string;
         readonly modelName?: string;

package/dist/agent-core/session/catalog.js

@@ -1,4 +1,5 @@
 import { MarAgentError } from '../error.js';
+import { publicHostedToolEvents } from '../runtime/event-projection.js';
 import { JsonlSessionStore } from './jsonl-store.js';
 const MAX_INPUT_IMAGE_BYTES = 5 * 1024 * 1024;
 const INPUT_IMAGE_MIME_TYPES = new Set(['image/png', 'image/jpeg', 'image/gif', 'image/webp']);
@@ -6,6 +7,7 @@ export async function openMarAgentSessionCatalog(input) {
     const store = await JsonlSessionStore.open(input.homeDirectory);
     return {
         list: (options) => store.list(options),
+        firstUserMessagePreview: (sessionId) => store.firstUserMessagePreview(sessionId),
         executionConfiguration: (sessionId) => store.executionConfiguration(sessionId),
         history: async (sessionId, options = {}) => {
             const beforeSequence = parseCursor(options.cursor);
@@ -39,6 +41,22 @@ export async function openMarAgentSessionCatalog(input) {
                         }
                     ];
                 }
+                if (isMarAgentEvent(record.payload) && record.payload.type === 'hosted_tool.updated') {
+                    const legacy = record.payload;
+                    return publicHostedToolEvents({ ...legacy, type: 'hosted_tool' }).map((event) => ({
+                        kind: 'event',
+                        sequence: record.sequence,
+                        event: {
+                            sequence: legacy.sequence,
+                            timestamp: legacy.timestamp,
+                            sessionId: legacy.sessionId,
+                            executionId: legacy.executionId,
+                            ...(legacy.turnId === undefined ? {} : { turnId: legacy.turnId }),
+                            ...event,
+                            eventId: `${legacy.eventId}:${event.type}`
+                        }
+                    }));
+                }
                 if (isMarAgentEvent(record.payload))
                     return [{ kind: 'event', sequence: record.sequence, event: record.payload }];
                 return [];

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

@@ -64,6 +64,8 @@ interface SessionMeta {
         todoSequence?: number;
         todoRevision: number;
         executionModelIndexed?: true;
+        firstUserMessageIndexed?: true;
+        firstUserMessagePreview?: string;
         modelId?: string;
         modelName?: string;
         reasoningEffort?: string;
@@ -184,12 +186,13 @@ export declare class JsonlSessionStore {
             reasoningEffort?: string;
             modelName?: string;
             modelId?: string;
-            id: string;
-            title: string;
             workspace: string;
             createdAt: string;
             lastActivityAt: string;
             source: SessionSource;
+            firstUserMessagePreview?: string;
+            id: string;
+            title: string;
         }[];
     }>;
     listSubagentChildren(parentSessionId: string): Promise<{
@@ -216,6 +219,7 @@ export declare class JsonlSessionStore {
         readonly reasoningEffort?: string;
     } | undefined>;
     sessionTree(sessionId: string): Promise<readonly string[]>;
+    firstUserMessagePreview(sessionId: string): Promise<string | undefined>;
     delete(sessionId: string): Promise<{
         readonly deleted: boolean;
     }>;

package/dist/agent-core/session/jsonl-store.js

@@ -158,6 +158,7 @@ export class JsonlSessionStore {
             closed: false,
             indexDirty: false,
             dirtySessionVersions: new Map(),
+            previewOnlyDirtySessions: new Set(),
             pendingPublishIds: new Set(),
             codeStateWrites: new Map(),
             recordWrites: new Map(),
@@ -176,19 +177,26 @@ export class JsonlSessionStore {
             if (!disk)
                 throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Session index is missing.');
             const dirty = new Map(this.#shared.dirtySessionVersions);
+            const previewOnly = new Set(this.#shared.previewOnlyDirtySessions);
             const sessions = new Map(disk.sessions.map((session) => [session.id, session]));
             const created = new Set(createdIds);
             for (const session of this.#shared.index.sessions) {
                 const current = sessions.get(session.id);
                 // Disk membership is authoritative: a stale in-memory snapshot cannot revive a deletion.
                 if (created.has(session.id) || (current && dirty.has(session.id)))
-                    sessions.set(session.id, structuredClone(session));
+                    sessions.set(session.id, current && previewOnly.has(session.id)
+                        ? mergeFirstUserMessagePreviewCache(current, session)
+                        : structuredClone(session));
             }
             for (const deletedId of typeof deletedIds === 'string' ? [deletedIds] : (deletedIds ?? []))
                 sessions.delete(deletedId);
             const updated = {
                 version: 1,
-                revision: Math.max(disk.revision, this.#shared.index.revision) + 1,
+                revision: createdIds.length > 0 ||
+                    deletedIds !== undefined ||
+                    [...dirty.keys()].some((id) => !previewOnly.has(id))
+                    ? Math.max(disk.revision, this.#shared.index.revision) + 1
+                    : disk.revision,
                 sessions: [...sessions.values()]
             };
             await persistSessionIndex(path, updated);
@@ -196,8 +204,10 @@ export class JsonlSessionStore {
                 // A different creation still needs its own index transaction to publish its directory.
                 if (this.#shared.pendingPublishIds.has(id) && !created.has(id))
                     continue;
-                if (this.#shared.dirtySessionVersions.get(id) === version)
+                if (this.#shared.dirtySessionVersions.get(id) === version) {
                     this.#shared.dirtySessionVersions.delete(id);
+                    this.#shared.previewOnlyDirtySessions.delete(id);
+                }
             }
             for (const id of created)
                 this.#shared.pendingPublishIds.delete(id);
@@ -234,7 +244,11 @@ export class JsonlSessionStore {
             sessions: disk.sessions
                 .map((session) => {
                 const current = local.get(session.id);
-                return current && this.#shared.dirtySessionVersions.has(session.id) ? current : session;
+                if (!current || !this.#shared.dirtySessionVersions.has(session.id))
+                    return session;
+                return this.#shared.previewOnlyDirtySessions.has(session.id)
+                    ? mergeFirstUserMessagePreviewCache(session, current)
+                    : current;
             })
                 .concat(this.#shared.index.sessions.filter((session) => this.#shared.pendingPublishIds.has(session.id) && !published.has(session.id)))
         };
@@ -272,7 +286,12 @@ export class JsonlSessionStore {
             source: normalizeSessionSource(input.source),
             nextSequence: 1,
             automaticTitlePending: input.title === undefined,
-            resume: { version: 1, todoRevision: 0, executionModelIndexed: true },
+            resume: {
+                version: 1,
+                todoRevision: 0,
+                executionModelIndexed: true,
+                firstUserMessageIndexed: true
+            },
             segments: []
         };
         const publication = await this.#beginUnpublishedSession(id);
@@ -520,7 +539,12 @@ export class JsonlSessionStore {
                 source: { type: 'user' },
                 nextSequence: 1,
                 automaticTitlePending: false,
-                resume: { version: 1, todoRevision: 0, executionModelIndexed: true },
+                resume: {
+                    version: 1,
+                    todoRevision: 0,
+                    executionModelIndexed: true,
+                    firstUserMessageIndexed: true
+                },
                 segments: []
             };
             const publication = await this.#beginUnpublishedSession(target.id);
@@ -852,7 +876,7 @@ export class JsonlSessionStore {
                 meta.lastActivityAt = clearedAt;
                 meta.nextSequence = 2;
                 meta.storageTransactionId = transactionId;
-                meta.resume = { version: 1, todoRevision: 0 };
+                meta.resume = { version: 1, todoRevision: 0, firstUserMessageIndexed: true };
                 meta.segments = staged.segments;
                 this.#shared.segments.set(sessionId, 1);
                 this.#shared.index.revision++;
@@ -1316,6 +1340,9 @@ export class JsonlSessionStore {
         const sessions = ordered.slice(start, start + limit).map((session) => ({
             id: session.id,
             title: session.title,
+            ...(session.resume?.firstUserMessagePreview === undefined
+                ? {}
+                : { firstUserMessagePreview: session.resume.firstUserMessagePreview }),
             workspace: session.workspace,
             createdAt: session.createdAt,
             lastActivityAt: session.lastActivityAt,
@@ -1403,6 +1430,11 @@ export class JsonlSessionStore {
         const resume = meta.resume;
         if (resume?.version !== 1 || !Number.isSafeInteger(resume.todoRevision))
             return;
+        if (resume.firstUserMessageIndexed === true && resume.firstUserMessagePreview === undefined) {
+            const preview = userMessagePreviewFromRecord(record);
+            if (preview !== undefined)
+                resume.firstUserMessagePreview = preview;
+        }
         const executionModel = executionModelFromRecord(record);
         if (executionModel !== undefined) {
             resume.executionModelIndexed = true;
@@ -1488,6 +1520,56 @@ export class JsonlSessionStore {
             contextRecords: state.contextRecords
         };
     }
+    async firstUserMessagePreview(sessionId) {
+        this.#assertOpen();
+        await this.#refreshIndex();
+        await this.#ensureFirstUserMessageIndexed(sessionId);
+        return this.#shared.index.sessions.find((session) => session.id === sessionId)?.resume
+            ?.firstUserMessagePreview;
+    }
+    async #ensureFirstUserMessageIndexed(sessionId) {
+        for (;;) {
+            const before = this.#shared.index.sessions.find((session) => session.id === sessionId);
+            if (before === undefined)
+                throw new MarAgentError('MAR_AGENT_SESSION_NOT_FOUND', 'Session was not found.');
+            if (before.resume?.firstUserMessageIndexed === true)
+                return;
+            const nextSequence = before.nextSequence;
+            const transactionId = before.storageTransactionId;
+            let preview;
+            try {
+                for (const path of await this.#segmentPaths(sessionId)) {
+                    for await (const record of readRecordsFromHead(path)) {
+                        preview = userMessagePreviewFromRecord(record);
+                        if (preview !== undefined)
+                            break;
+                    }
+                    if (preview !== undefined)
+                        break;
+                }
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT' &&
+                    !(error instanceof MarAgentError && error.code === 'MAR_AGENT_SESSION_NOT_FOUND'))
+                    throw error;
+            }
+            await this.#refreshIndex();
+            const current = this.#shared.index.sessions.find((session) => session.id === sessionId);
+            if (current === undefined)
+                throw new MarAgentError('MAR_AGENT_SESSION_NOT_FOUND', 'Session was not found.');
+            if (current.resume?.firstUserMessageIndexed === true)
+                return;
+            if (current.nextSequence !== nextSequence || current.storageTransactionId !== transactionId)
+                continue;
+            const resume = (current.resume ??= { version: 1, todoRevision: 0 });
+            resume.firstUserMessageIndexed = true;
+            if (preview !== undefined)
+                resume.firstUserMessagePreview = preview;
+            // Derived preview caches do not change list membership, ordering or filters.
+            this.#markIndexDirty(sessionId, true);
+            return;
+        }
+    }
     async #ensureExecutionModelIndexed(sessionId) {
         const pending = this.#shared.executionModelReads.get(sessionId);
         if (pending !== undefined)
@@ -1586,7 +1668,11 @@ export class JsonlSessionStore {
         if (this.#leaseClosed || this.#shared.closed)
             throw new MarAgentError('MAR_AGENT_DISPOSED', 'Session store is closed.');
     }
-    #markIndexDirty(sessionId) {
+    #markIndexDirty(sessionId, previewOnly = false) {
+        if (!previewOnly)
+            this.#shared.previewOnlyDirtySessions.delete(sessionId);
+        else if (!this.#shared.dirtySessionVersions.has(sessionId))
+            this.#shared.previewOnlyDirtySessions.add(sessionId);
         this.#shared.indexDirty = true;
         this.#shared.dirtySessionVersions.set(sessionId, (this.#shared.dirtySessionVersions.get(sessionId) ?? 0) + 1);
     }
@@ -1679,6 +1765,26 @@ export class JsonlSessionStore {
         JsonlSessionStore.#instances.delete(this.#shared.root);
     }
 }
+/** Merge a derived cache only onto the unchanged history it was computed from. */
+function mergeFirstUserMessagePreviewCache(current, cached) {
+    if (cached.resume?.firstUserMessageIndexed !== true ||
+        current.nextSequence !== cached.nextSequence ||
+        current.storageTransactionId !== cached.storageTransactionId ||
+        current.resume?.firstUserMessagePreview !== undefined ||
+        (current.resume?.firstUserMessageIndexed === true &&
+            cached.resume.firstUserMessagePreview === undefined))
+        return current;
+    return {
+        ...current,
+        resume: {
+            ...(current.resume ?? { version: 1, todoRevision: 0 }),
+            firstUserMessageIndexed: true,
+            ...(cached.resume?.firstUserMessagePreview === undefined
+                ? {}
+                : { firstUserMessagePreview: cached.resume.firstUserMessagePreview })
+        }
+    };
+}
 async function readSessionIndex(path) {
     let raw;
     try {
@@ -2157,7 +2263,9 @@ function deriveExecutionState(records) {
     let todoRevision = 0;
     let todoItems = [];
     let executionModel;
+    let firstUserMessagePreview;
     for (const record of records) {
+        firstUserMessagePreview ??= userMessagePreviewFromRecord(record);
         if (record.type === 'session.created')
             automaticTitle =
                 record.payload?.automaticTitle === true;
@@ -2198,10 +2306,21 @@ function deriveExecutionState(records) {
             ...(todoSequence === undefined ? {} : { todoSequence }),
             todoRevision,
             executionModelIndexed: true,
+            firstUserMessageIndexed: true,
+            ...(firstUserMessagePreview === undefined ? {} : { firstUserMessagePreview }),
             ...(executionModel === undefined ? {} : executionModel)
         }
     };
 }
+function userMessagePreviewFromRecord(record) {
+    if (record.type !== 'turn.user' ||
+        !isObject(record.payload) ||
+        record.payload.inputSource === 'parent_agent' ||
+        typeof record.payload.prompt !== 'string')
+        return undefined;
+    const preview = record.payload.prompt.trim().replace(/\s+/gu, ' ').slice(0, 160);
+    return preview || undefined;
+}
 function executionModelFromRecord(record) {
     if (record.type !== 'execution.header' || !isObject(record.payload))
         return undefined;
@@ -2254,10 +2373,63 @@ function sameResumeIndex(left, right) {
         left.todoSequence === right.todoSequence &&
         left.todoRevision === right.todoRevision &&
         left.executionModelIndexed === right.executionModelIndexed &&
+        left.firstUserMessageIndexed === right.firstUserMessageIndexed &&
+        left.firstUserMessagePreview === right.firstUserMessagePreview &&
         left.modelId === right.modelId &&
         left.modelName === right.modelName &&
         left.reasoningEffort === right.reasoningEffort);
 }
+/** Read only the prefix needed by discovery; never load the entire transcript. */
+async function* readRecordsFromHead(path) {
+    const handle = await open(path, 'r');
+    try {
+        const { size } = await handle.stat();
+        const chunk = Buffer.allocUnsafe(REVERSE_READ_CHUNK_BYTES);
+        let position = 0;
+        let pending = Buffer.alloc(0);
+        while (position < size) {
+            const { bytesRead } = await handle.read(chunk, 0, Math.min(chunk.length, size - position), position);
+            if (bytesRead === 0)
+                break;
+            position += bytesRead;
+            const data = Buffer.concat([pending, chunk.subarray(0, bytesRead)]);
+            let start = 0;
+            for (;;) {
+                const end = data.indexOf(0x0a, start);
+                if (end < 0)
+                    break;
+                const line = data.subarray(start, end).toString('utf8');
+                start = end + 1;
+                if (!line)
+                    continue;
+                let record;
+                try {
+                    record = JSON.parse(line);
+                }
+                catch (cause) {
+                    throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Session history is corrupt.', {
+                        cause
+                    });
+                }
+                yield record;
+            }
+            pending = Buffer.from(data.subarray(start));
+        }
+        if (pending.length > 0) {
+            let record;
+            try {
+                record = JSON.parse(pending.toString('utf8'));
+            }
+            catch {
+                return; // Readers ignore only an interrupted final line.
+            }
+            yield record;
+        }
+    }
+    finally {
+        await handle.close();
+    }
+}
 async function readRecords(path) {
     const value = await readFile(path, 'utf8');
     const lines = value.split('\n');

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

@@ -13,6 +13,18 @@ export async function createCodeModeEngine(options) {
             if (disposed || runtime)
                 throw diagnostic('MAR_AGENT_CODE_FAILED', 'Engine is not reusable.');
             runtime = quickjs.newRuntime();
+            // QuickJS 0.32.0 caches the job's context-pointer view across WASM memory growth
+            // (upstream #240). A detached view creates an unowned Context and breaks disposal.
+            // Keep this dependency-specific correction inside the worker engine; preserve its
+            // pointer allocation/free lifecycle and always read from the current heap.
+            const newMutablePointerArray = runtime.memory.newMutablePointerArray.bind(runtime.memory);
+            runtime.memory.newMutablePointerArray = (length) => {
+                const pointer = newMutablePointerArray(length);
+                Object.defineProperty(pointer.value, 'typedArray', {
+                    get: () => new Int32Array(runtime.module.HEAP8.buffer, pointer.value.ptr, length)
+                });
+                return pointer;
+            };
             runtime.setMemoryLimit(input.limits.memoryBytes);
             runtime.setMaxStackSize(input.limits.stackBytes);
             let executionMs = 0;

package/package.json

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