@myagentroam/agent 0.10.59 → 0.10.61

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

@@ -0,0 +1,23 @@
+import type { SessionRecord } from './types.js';
+export interface HistoryPagePositions {
+    readonly signature: string;
+    readonly offsets: Map<number, number>;
+}
+export declare const MAX_SEGMENT_BYTES: number;
+/** Read only the prefix needed by discovery; never load the entire transcript. */
+export declare function readRecordsFromHead(path: string): AsyncGenerator<SessionRecord>;
+export declare function readRecords(path: string): Promise<SessionRecord[]>;
+/** Repair only the final record under the Session writer lock; never skip middle damage. */
+export declare function repairSegmentTail(path: string): Promise<void>;
+export declare function readRecordPageFromTail(path: string, beforeSequence: number, limit: number, positions: Map<string, HistoryPagePositions>): Promise<{
+    records: SessionRecord[];
+    hasEarlier: boolean;
+}>;
+/** Decode complete records newest-first, releasing the file as soon as a reader stops. */
+export declare function readRecordsFromTail(path: string, page?: {
+    readonly beforeSequence: number;
+    readonly limit: number;
+    readonly positions: Map<string, HistoryPagePositions>;
+}): AsyncGenerator<SessionRecord>;
+export declare function segmentNumberFromPath(path: string): number | undefined;
+export declare function appendRecordBytes(path: string, serialized: string): Promise<void>;

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

@@ -0,0 +1,249 @@
+import { open, readFile } from 'node:fs/promises';
+import { MarAgentError } from '../../error.js';
+export const MAX_SEGMENT_BYTES = 16 * 1024 * 1024;
+const REVERSE_READ_CHUNK_BYTES = 64 * 1024;
+const MAX_HISTORY_PAGE_FILES = 32;
+const MAX_HISTORY_PAGE_OFFSETS = 128;
+/** Read only the prefix needed by discovery; never load the entire transcript. */
+export async function* readRecordsFromHead(path) {
+    const handle = await open(path, 'r');
+    try {
+        const { size } = await handle.stat();
+        let position = 0;
+        let pending = [];
+        while (position < size) {
+            const chunk = Buffer.allocUnsafe(Math.min(REVERSE_READ_CHUNK_BYTES, size - position));
+            const { bytesRead } = await handle.read(chunk, 0, Math.min(chunk.length, size - position), position);
+            if (bytesRead === 0)
+                break;
+            position += bytesRead;
+            const data = chunk.subarray(0, bytesRead);
+            let start = 0;
+            for (;;) {
+                const end = data.indexOf(0x0a, start);
+                if (end < 0)
+                    break;
+                const part = data.subarray(start, end);
+                const line = (pending.length === 0 ? part : Buffer.concat([...pending, part])).toString('utf8');
+                pending = [];
+                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;
+            }
+            if (start < data.length)
+                pending.push(data.subarray(start));
+        }
+        if (pending.length > 0) {
+            let record;
+            try {
+                record = JSON.parse(Buffer.concat(pending).toString('utf8'));
+            }
+            catch {
+                return; // Readers ignore only an interrupted final line.
+            }
+            yield record;
+        }
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function readRecords(path) {
+    const value = await readFile(path, 'utf8');
+    const lines = value.split('\n');
+    if (lines.at(-1) === '')
+        lines.pop();
+    const records = [];
+    for (const [index, line] of lines.entries()) {
+        if (!line)
+            continue;
+        try {
+            records.push(JSON.parse(line));
+        }
+        catch (cause) {
+            if (index === lines.length - 1 && !value.endsWith('\n'))
+                break;
+            throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Session history is corrupt.', {
+                cause
+            });
+        }
+    }
+    return records;
+}
+/** Repair only the final record under the Session writer lock; never skip middle damage. */
+export async function repairSegmentTail(path) {
+    const data = await readFile(path);
+    if (data.length === 0 || data.at(-1) === 10)
+        return;
+    const boundary = data.lastIndexOf(10);
+    let complete = false;
+    try {
+        const record = JSON.parse(data.subarray(boundary + 1).toString('utf8'));
+        complete =
+            record?.schemaVersion === 1 &&
+                Number.isSafeInteger(record.sequence) &&
+                typeof record.sessionId === 'string' &&
+                typeof record.type === 'string';
+    }
+    catch {
+        // An interrupted final line is discarded before another record can be appended.
+    }
+    const handle = await open(path, 'r+');
+    try {
+        if (complete) {
+            const { bytesWritten } = await handle.write(Buffer.from('\n'), 0, 1, data.length);
+            if (bytesWritten !== 1)
+                throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Session tail repair is incomplete.');
+        }
+        else
+            await handle.truncate(boundary + 1);
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function readRecordPageFromTail(path, beforeSequence, limit, positions) {
+    const newestFirst = [];
+    for await (const record of readRecordsFromTail(path, { beforeSequence, limit, positions })) {
+        if (!(record.sequence < beforeSequence))
+            continue;
+        newestFirst.push(record);
+        if (newestFirst.length > limit)
+            break;
+    }
+    return {
+        records: newestFirst.slice(0, limit).reverse(),
+        hasEarlier: newestFirst.length > limit
+    };
+}
+/** Decode complete records newest-first, releasing the file as soon as a reader stops. */
+export async function* readRecordsFromTail(path, page) {
+    const handle = await open(path, 'r');
+    try {
+        const metadata = await handle.stat({ bigint: true });
+        const size = Number(metadata.size);
+        let position = size;
+        let cached;
+        if (page !== undefined) {
+            const signature = `${metadata.dev}:${metadata.ino}:${metadata.size}:${metadata.mtimeNs}:${metadata.ctimeNs}`;
+            const previous = page.positions.get(path);
+            cached = previous?.signature === signature ? previous : { signature, offsets: new Map() };
+            page.positions.delete(path);
+            page.positions.set(path, cached);
+            if (page.positions.size > MAX_HISTORY_PAGE_FILES)
+                page.positions.delete(page.positions.keys().next().value);
+            let nearestSequence = Number.POSITIVE_INFINITY;
+            for (const [sequence, offset] of cached.offsets) {
+                if (sequence >= page.beforeSequence && sequence < nearestSequence) {
+                    nearestSequence = sequence;
+                    position = offset;
+                }
+            }
+        }
+        let accepted = 0;
+        const remember = (record, offset) => {
+            if (page === undefined || cached === undefined || record.sequence >= page.beforeSequence)
+                return;
+            if (++accepted !== page.limit)
+                return;
+            cached.offsets.set(record.sequence, offset);
+            if (cached.offsets.size > MAX_HISTORY_PAGE_OFFSETS)
+                cached.offsets.delete(cached.offsets.keys().next().value);
+        };
+        let pendingLineParts = [];
+        let invalidFinalLineMayBeIgnored = false;
+        let inspectedFileEnd = position !== size;
+        const decode = (line, allowInvalidFinalLine) => {
+            if (line.length === 0)
+                return undefined;
+            try {
+                return JSON.parse(line.toString('utf8'));
+            }
+            catch (cause) {
+                if (allowInvalidFinalLine)
+                    return undefined;
+                throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Session history is corrupt.', {
+                    cause
+                });
+            }
+        };
+        while (position > 0) {
+            const start = Math.max(0, position - REVERSE_READ_CHUNK_BYTES);
+            const chunk = Buffer.allocUnsafe(position - start);
+            let bytesRead = 0;
+            while (bytesRead < chunk.length) {
+                const result = await handle.read(chunk, bytesRead, chunk.length - bytesRead, start + bytesRead);
+                if (result.bytesRead === 0)
+                    break;
+                bytesRead += result.bytesRead;
+            }
+            const value = chunk.subarray(0, bytesRead);
+            if (!inspectedFileEnd) {
+                inspectedFileEnd = true;
+                invalidFinalLineMayBeIgnored = value.at(-1) !== 0x0a;
+            }
+            let lineEnd = value.length;
+            for (let index = value.length - 1; index >= 0; index--) {
+                if (value[index] !== 0x0a)
+                    continue;
+                const currentPart = value.subarray(index + 1, lineEnd);
+                const line = pendingLineParts.length === 0
+                    ? currentPart
+                    : Buffer.concat([currentPart, ...pendingLineParts.reverse()]);
+                const record = decode(line, invalidFinalLineMayBeIgnored);
+                invalidFinalLineMayBeIgnored = false;
+                pendingLineParts = [];
+                lineEnd = index;
+                if (record !== undefined) {
+                    remember(record, start + index + 1);
+                    yield record;
+                }
+            }
+            if (lineEnd > 0)
+                pendingLineParts.push(value.subarray(0, lineEnd));
+            position = start;
+        }
+        if (pendingLineParts.length > 0) {
+            const record = decode(Buffer.concat(pendingLineParts.reverse()), invalidFinalLineMayBeIgnored);
+            if (record !== undefined) {
+                remember(record, 0);
+                yield record;
+            }
+        }
+    }
+    finally {
+        await handle.close();
+    }
+}
+export function segmentNumberFromPath(path) {
+    const match = /events-(\d{6})\.jsonl$/.exec(path);
+    return match === null ? undefined : Number(match[1]);
+}
+export async function appendRecordBytes(path, serialized) {
+    const handle = await open(path, 'a', 0o600);
+    try {
+        const bytes = Buffer.from(serialized);
+        let offset = 0;
+        while (offset < bytes.length) {
+            const { bytesWritten } = await handle.write(bytes, offset, bytes.length - offset);
+            if (bytesWritten === 0)
+                throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Session append is incomplete.');
+            offset += bytesWritten;
+        }
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+}

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

@@ -0,0 +1,84 @@
+import type { ModelInputMetadata } from '../../model/contracts.js';
+import type { TodoSnapshot } from '../../tools/agent/todo.js';
+import type { SessionSource } from '../types.js';
+export interface SessionRecord {
+    schemaVersion: 1;
+    recordId: string;
+    sequence: number;
+    timestamp: string;
+    sessionId: string;
+    executionId?: string;
+    turnId?: string;
+    type: string;
+    payload: unknown;
+}
+export interface SessionExecutionState {
+    automaticTitlePending: boolean;
+    todo: TodoSnapshot;
+    contextRecords: SessionRecord[];
+}
+export interface CompactUserInput {
+    content: string;
+    metadata?: ModelInputMetadata;
+}
+export interface CompactHistoryMessage extends CompactUserInput {
+    role: 'user';
+    kind: 'user_input' | 'extension_input' | 'summary';
+}
+export interface SessionInputImage {
+    readonly name: string;
+    readonly mimeType: string;
+    readonly dataBase64: string;
+}
+export interface SessionInputImageMetadata {
+    readonly name: string;
+    readonly mimeType: string;
+    readonly byteSize: number;
+    readonly fileName: string;
+    readonly sha256: string;
+}
+export interface RestoredSessionInputImage {
+    readonly mimeType: string;
+    readonly dataBase64: string;
+}
+export interface SessionInputImageData extends SessionInputImageMetadata {
+    readonly dataBase64: string;
+}
+export interface SessionMeta {
+    id: string;
+    title: string;
+    workspace: string;
+    createdAt: string;
+    lastActivityAt: string;
+    source?: SessionSource;
+    nextSequence: number;
+    automaticTitlePending?: boolean;
+    storageTransactionId?: string;
+    resume?: {
+        version: 1;
+        userTurns?: number;
+        compactSequence?: number;
+        gcSequence?: number;
+        gcGeneration?: number;
+        gcBaseSequence?: number;
+        todoSequence?: number;
+        todoRevision: number;
+        executionModelIndexed?: true;
+        firstUserMessageIndexed?: true;
+        firstUserMessagePreview?: string;
+        modelId?: string;
+        modelName?: string;
+        reasoningEffort?: string;
+    };
+    segments?: Array<{
+        number: number;
+        firstSequence: number;
+        lastSequence: number;
+        bytes: number;
+    }>;
+}
+export interface SessionIndex {
+    version: 1;
+    revision: number;
+    sessions: SessionMeta[];
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/agent-core/session/tool-result-resources.d.ts

@@ -1,5 +1,5 @@
 import { type AvailableToolResultResource } from '../tools/result-extensions.js';
-import type { SessionRecord } from './jsonl-store.js';
+import type { SessionRecord } from './store/index.js';
 export interface ToolResultResourceInput {
     resourceRef: string;
     cursor?: string;

package/dist/agent-core/subagent/scheduler.js

@@ -12,7 +12,7 @@ export class SubagentScheduler {
     #disposed = false;
     #createdInExecution = 0;
     #runner;
-    constructor(runner, limits = { maxTasks: 8, maxConcurrent: 4 }) {
+    constructor(runner, limits = { maxTasks: 16, maxConcurrent: 16 }) {
         this.limits = limits;
         this.#runner = runner;
     }

package/dist/agent-core/subagent/session-controller.d.ts

@@ -3,7 +3,7 @@ import type { CoreOperationContext } from '../extensions/operation.js';
 import type { MarAgentReasoningEffort } from '../model/configuration.js';
 import type { ExecutionResult } from '../runtime/contracts.js';
 import type { MarAgentEvent } from '../runtime/events.js';
-import type { SessionRecord, SessionSource } from '../session/jsonl-store.js';
+import type { SessionRecord, SessionSource } from '../session/store/index.js';
 import type { SubagentManyOutput, SubagentManyOutputOptions } from './contracts.js';
 import type { SubagentController, SubagentMessageOptions, SubagentOutputOptions, SubagentRunOptions, SubagentTaskInput, SubagentTaskSnapshot } from './scheduler.js';
 export interface SubagentModelOption {
@@ -78,7 +78,7 @@ export interface SubagentSessionControllerBackend {
     }>;
     deleteSession(sessionId: string): Promise<void>;
     /** Returns children in durable creation order. */
-    listChildren(parentSessionId: string): Promise<readonly PersistedSubagentSession[]>;
+    listChildren(parentSessionId: string): Promise<readonly Omit<PersistedSubagentSession, 'records'>[]>;
     loadChild(parentSessionId: string, sessionId: string): Promise<PersistedSubagentSession | undefined>;
 }
 export declare class SubagentSessionController implements SubagentController {
@@ -109,6 +109,9 @@ export declare class SubagentSessionController implements SubagentController {
     withOperation<T>(operation: SubagentParentOperation, run: () => T): T;
     inspect(agentId: string): Promise<SubagentTaskSnapshot>;
     inspectAll(): readonly SubagentTaskSnapshot[];
+    /** Full listing is explicit; ordinary opens and executions never require it. */
+    prepareAll(signal?: AbortSignal): Promise<void>;
+    prepareSessionResources(signal?: AbortSignal): Promise<void>;
     collectModelUpdates(): readonly {
         snapshot: SubagentTaskSnapshot;
         truncated: boolean;

package/dist/agent-core/subagent/session-controller.js

@@ -4,12 +4,16 @@ import { randomUUID } from 'node:crypto';
 import { MarAgentError, describeMarAgentError } from '../error.js';
 import { TOOL_EXECUTION_LIMITS } from '../tools/execution-limits.js';
 import { parseAgentWaitTargets, waitForAgentCondition } from './wait.js';
+const RECENT_TERMINAL_RESOURCE_LIMIT = 16;
 export class SubagentSessionController {
     parentSessionId;
     rootSessionId;
     backend;
     limits;
     #agents = new Map();
+    // Discovery order is independent of the order in which history is requested.
+    #discovered = new Map();
+    #loading = new Map();
     #queue = [];
     #completionWaiters = new Set();
     #activityWaiters = new Set();
@@ -35,7 +39,7 @@ export class SubagentSessionController {
     #retainedExecution = new AsyncLocalStorage();
     #execution;
     #pendingDeliveries = new Set();
-    constructor(parentSessionId, rootSessionId, backend, limits = { maxTasks: 8, maxConcurrent: 4 }) {
+    constructor(parentSessionId, rootSessionId, backend, limits = { maxTasks: 16, maxConcurrent: 16 }) {
         this.parentSessionId = parentSessionId;
         this.rootSessionId = rootSessionId;
         this.backend = backend;
@@ -43,11 +47,12 @@ export class SubagentSessionController {
     }
     static async open(input) {
         const controller = new SubagentSessionController(input.parentSessionId, input.rootSessionId, input.backend, input.limits);
-        const sessions = [...(await input.backend.listChildren(input.parentSessionId))].sort((a, b) => a.lastActivityAt.localeCompare(b.lastActivityAt));
-        for (const session of sessions) {
-            const state = restoreAgentState(session);
-            state.resourceRevision = ++controller.#resourceRevision;
-            controller.#agents.set(session.id, state);
+        const sessions = await input.backend.listChildren(input.parentSessionId);
+        // Map insertion order is creation order; values independently rank activity.
+        for (const session of sessions)
+            controller.#discovered.set(session.id, 0);
+        for (const session of [...sessions].sort((a, b) => a.lastActivityAt.localeCompare(b.lastActivityAt))) {
+            controller.#discovered.set(session.id, ++controller.#resourceRevision);
         }
         return controller;
     }
@@ -98,7 +103,49 @@ export class SubagentSessionController {
     inspectAll() {
         if (this.#disposed)
             throw new MarAgentError('MAR_AGENT_DISPOSED', 'Subagent controller is disposed.');
-        return [...this.#agents.values()].map((state) => this.#snapshot(state, { full: true }));
+        return this.#orderedStates().map((state) => this.#snapshot(state, { full: true }));
+    }
+    /** Full listing is explicit; ordinary opens and executions never require it. */
+    async prepareAll(signal) {
+        for (const id of this.#discovered.keys()) {
+            signal?.throwIfAborted();
+            await this.#restoreDiscovered(id);
+        }
+        signal?.throwIfAborted();
+    }
+    async prepareSessionResources(signal) {
+        const candidates = [...this.#discovered]
+            .filter(([id]) => {
+            const state = this.#agents.get(id);
+            return !state || isTerminalState(state);
+        })
+            .sort(([a, ar], [b, br]) => (this.#agents.get(b)?.resourceRevision ?? br) -
+            (this.#agents.get(a)?.resourceRevision ?? ar));
+        let prepared = 0;
+        for (const [id] of candidates) {
+            signal?.throwIfAborted();
+            const state = await this.#restoreDiscovered(id);
+            if (state && isTerminalState(state) && ++prepared === RECENT_TERMINAL_RESOURCE_LIMIT)
+                break;
+        }
+        signal?.throwIfAborted();
+    }
+    async #restoreDiscovered(agentId) {
+        try {
+            return await this.#find(agentId);
+        }
+        catch (error) {
+            if (!(error instanceof MarAgentError) || error.code !== 'MAR_AGENT_SUBAGENT_NOT_FOUND')
+                throw error;
+            this.#discovered.delete(agentId);
+            return undefined;
+        }
+    }
+    #orderedStates() {
+        return [...this.#discovered.keys()].flatMap((id) => {
+            const state = this.#agents.get(id);
+            return state ? [state] : [];
+        });
     }
     collectModelUpdates() {
         return [...this.#agents.values()]
@@ -223,6 +270,7 @@ export class SubagentSessionController {
         if (!native)
             (this.#retainedExecution.getStore()?.budget ?? this.#creationBudget).count++;
         this.#agents.set(state.agentId, state);
+        this.#discovered.set(state.agentId, state.resourceRevision);
         const knownModel = execution.models.get(input.modelId ?? execution.modelId);
         if (knownModel) {
             state.modelId = knownModel.id;
@@ -335,7 +383,16 @@ export class SubagentSessionController {
         if (options.untilSettled)
             throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'An unbounded wait requires an agent id.');
         validateOutputOptions(options, this.#retainedExecution.getStore()?.native === true);
-        const states = [...this.#agents.values()];
+        const hasLive = [...this.#agents.values()].some((state) => !isTerminalState(state));
+        if (!hasLive) {
+            for (const id of [...this.#discovered.keys()].reverse()) {
+                options.signal?.throwIfAborted();
+                if (await this.#restoreDiscovered(id))
+                    break;
+            }
+        }
+        options.signal?.throwIfAborted();
+        const states = this.#orderedStates();
         if (states.length === 0)
             throw new MarAgentError('MAR_AGENT_SUBAGENT_NOT_FOUND', 'Subagent was not found.');
         const live = states.filter((state) => state.status === 'queued' || state.status === 'running');
@@ -625,7 +682,7 @@ export class SubagentSessionController {
         const terminal = states
             .filter((state) => state.status !== 'queued' && state.status !== 'running')
             .sort((left, right) => right.resourceRevision - left.resourceRevision)
-            .slice(0, 8);
+            .slice(0, RECENT_TERMINAL_RESOURCE_LIMIT);
         return [...active, ...terminal].map((state) => ({
             agentId: state.agentId,
             status: state.status,
@@ -946,6 +1003,7 @@ export class SubagentSessionController {
     }
     async #deleteUnstartedSession(agentId, error) {
         this.#agents.delete(agentId);
+        this.#discovered.delete(agentId);
         try {
             await this.backend.deleteSession(agentId);
         }
@@ -957,15 +1015,41 @@ export class SubagentSessionController {
         throw error;
     }
     async #find(agentId) {
+        if (this.#disposed)
+            throw new MarAgentError('MAR_AGENT_DISPOSED', 'Subagent controller is disposed.');
         const known = this.#agents.get(agentId);
         if (known)
             return known;
-        const persisted = await this.backend.loadChild(this.parentSessionId, agentId);
-        if (!persisted)
-            throw new MarAgentError('MAR_AGENT_SUBAGENT_NOT_FOUND', 'Subagent was not found.');
-        const restored = restoreAgentState(persisted);
-        this.#agents.set(agentId, restored);
-        return restored;
+        const pending = this.#loading.get(agentId);
+        if (pending)
+            return pending;
+        const load = (async () => {
+            const persisted = await this.backend.loadChild(this.parentSessionId, agentId);
+            if (this.#disposed)
+                throw new MarAgentError('MAR_AGENT_DISPOSED', 'Subagent controller is disposed.');
+            if (!persisted)
+                throw new MarAgentError('MAR_AGENT_SUBAGENT_NOT_FOUND', 'Subagent was not found.');
+            const existing = this.#agents.get(agentId);
+            if (existing)
+                return existing;
+            const restored = restoreAgentState(persisted);
+            let revision = this.#discovered.get(agentId);
+            if (revision === undefined) {
+                revision = ++this.#resourceRevision;
+                this.#discovered.set(agentId, revision);
+            }
+            restored.resourceRevision = revision;
+            this.#agents.set(agentId, restored);
+            return restored;
+        })();
+        this.#loading.set(agentId, load);
+        try {
+            return await load;
+        }
+        finally {
+            if (this.#loading.get(agentId) === load)
+                this.#loading.delete(agentId);
+        }
     }
     #requireExecution() {
         if (this.#disposed)

package/dist/agent-core/tools/code-mode/state.d.ts

@@ -5,5 +5,5 @@ type StateRecord = {
     readonly payload: unknown;
 };
 export declare function parseCodeModeStateMutations(value: unknown): CodeModeStateMutation[];
-export declare function restoreCodeModeState(records: readonly StateRecord[]): CodeModeStateEntry[];
+export declare function restoreCodeModeState(records: readonly StateRecord[], initialState?: CodeModeStateEntry[]): CodeModeStateEntry[];
 export declare function applyCodeModeStateMutations(entries: readonly CodeModeStateEntry[], mutations: readonly CodeModeStateMutation[]): CodeModeStateEntry[];

package/dist/agent-core/tools/code-mode/state.js

@@ -16,8 +16,8 @@ export function parseCodeModeStateMutations(value) {
         throw invalidState();
     });
 }
-export function restoreCodeModeState(records) {
-    let state = [];
+export function restoreCodeModeState(records, initialState = []) {
+    let state = initialState;
     for (const record of records) {
         if (record.type !== 'code.state.updated')
             continue;

package/package.json

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