@myagentroam/agent 0.9.157 → 0.9.158

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

@@ -7,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);

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.157",
+  "version": "0.9.158",
   "description": "Embeddable MAR coding agent SDK and CLI.",
   "license": "Apache-2.0",
   "type": "module",