@myagentroam/agent 0.9.135 → 0.9.137

package/dist/session/jsonl-store.js

@@ -5,6 +5,7 @@ import { basename, join } from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
 import { isDeepStrictEqual } from 'node:util';
 import { MarAgentError } from '../error.js';
+import { applyCodeModeStateMutations, parseCodeModeStateMutations, restoreCodeModeState } from '../tools/code-mode/state.js';
 import { todoItemsFromSnapshot } from '../tools/todo.js';
 import { contextGcBaseFromRecords, contextGcBaseSequence, contextGcMinimumUsageGrowth, contextGcSourceProjectionHash, latestValidContextGcCheckpoint, normalizeContextGcReplacements, parseContextGcCheckpoint, sameContextGcBase, validateContextGcCheckpoint } from './context-gc-checkpoint.js';
 import { beginSessionStorageTransaction, isUnjournaledTransactionFile, recoverSessionStorageTransaction } from './transaction-recovery.js';
@@ -521,20 +522,31 @@ export class JsonlSessionStore {
             this.#shared.pendingSessions.set(target.id, target);
             let discard = false;
             try {
-                await this.append(target.id, {
-                    type: 'session.created',
-                    payload: {
-                        title: target.title,
-                        workspace: target.workspace,
-                        automaticTitle: false,
-                        source: target.source
+                const copied = [
+                    {
+                        schemaVersion: 1,
+                        recordId: randomUUID(),
+                        sequence: 1,
+                        timestamp: createdAt,
+                        sessionId: target.id,
+                        type: 'session.created',
+                        payload: {
+                            title: target.title,
+                            workspace: target.workspace,
+                            automaticTitle: false,
+                            source: target.source
+                        }
                     }
-                });
+                ];
                 const retained = input.boundaryTurnId === null ? [] : records.slice(1, boundaryIndex + 1);
                 for (const record of retained) {
                     if (record.type === 'context.gc.completed' || record.type === 'responses.continuation')
                         continue;
-                    await this.append(target.id, {
+                    copied.push({
+                        schemaVersion: 1,
+                        recordId: randomUUID(),
+                        sequence: copied.length + 1,
+                        sessionId: target.id,
                         type: record.type,
                         payload: forkedPayload(record.type, record.payload, sourceSessionId, target.id, input.title),
                         ...(record.executionId === undefined ? {} : { executionId: record.executionId }),
@@ -542,6 +554,15 @@ export class JsonlSessionStore {
                         timestamp: record.timestamp
                     });
                 }
+                // A fork is unpublished until every segment and referenced image is durable.
+                const staged = await stageSessionSegments(this.sessionDirectory(target.id), copied, 'fork');
+                for (const file of staged.files)
+                    await rename(file.temporaryPath, file.path);
+                target.segments = staged.segments;
+                target.nextSequence = copied.length + 1;
+                this.#shared.segments.set(target.id, staged.segments.length);
+                for (const record of copied)
+                    this.#applyRecordToResumeIndex(target, record);
                 await copyGeneratedImages(this.sessionDirectory(sourceSessionId), this.sessionDirectory(target.id), generatedImageFileNames(retained));
                 await copyInputImages(this.sessionDirectory(sourceSessionId), this.sessionDirectory(target.id), inputImageReferencesFromRecords(retained));
                 target.lastActivityAt = target.createdAt;
@@ -621,7 +642,7 @@ export class JsonlSessionStore {
             const retained = records
                 .slice(0, boundaryIndex + 1)
                 .filter((record) => record.type !== 'responses.continuation');
-            const staged = await stageRollbackSegments(this.sessionDirectory(sessionId), retained);
+            const staged = await stageSessionSegments(this.sessionDirectory(sessionId), retained);
             const transactionId = randomUUID();
             const targetNextSequence = (retained.at(-1)?.sequence ?? 0) + 1;
             const contextualWorldStatePath = join(this.sessionDirectory(sessionId), CONTEXTUAL_WORLD_STATE_FILE);
@@ -765,7 +786,7 @@ export class JsonlSessionStore {
                     }
                 }
             ];
-            const staged = await stageRollbackSegments(this.sessionDirectory(sessionId), retained);
+            const staged = await stageSessionSegments(this.sessionDirectory(sessionId), retained);
             const transactionId = randomUUID();
             const contextualWorldStatePath = join(this.sessionDirectory(sessionId), CONTEXTUAL_WORLD_STATE_FILE);
             const contextualWorldStateBackup = `${contextualWorldStatePath}.2.${transactionId}.clear-backup`;
@@ -966,6 +987,22 @@ export class JsonlSessionStore {
             throw new MarAgentError('MAR_AGENT_SESSION_NOT_FOUND', 'Session was not found.', { cause });
         }
     }
+    async readCodeModeState(sessionId) {
+        return restoreCodeModeState(await this.read(sessionId));
+    }
+    async commitCodeModeState(sessionId, mutations, input) {
+        const parsed = parseCodeModeStateMutations(mutations);
+        if (parsed.length === 0)
+            return this.readCodeModeState(sessionId);
+        const state = applyCodeModeStateMutations(await this.readCodeModeState(sessionId), parsed);
+        await this.append(sessionId, {
+            type: 'code.state.updated',
+            payload: { mutations: parsed },
+            executionId: input.executionId,
+            turnId: input.turnId
+        });
+        return state;
+    }
     async readExecutionState(sessionId) {
         this.#assertOpen();
         const meta = this.#shared.index.sessions.find((item) => item.id === sessionId);
@@ -1637,55 +1674,56 @@ function generatedImageFileNames(records) {
     }
     return [...names];
 }
-async function stageRollbackSegments(sessionDirectory, records) {
-    const groups = [];
-    for (const record of records) {
-        const line = `${JSON.stringify(record)}\n`;
-        const bytes = Buffer.byteLength(line);
-        let group = groups.at(-1);
-        if (group !== undefined && group.bytes > 0 && group.bytes + bytes > MAX_SEGMENT_BYTES)
-            group = undefined;
-        if (group === undefined) {
-            group = {
-                lines: [],
-                bytes: 0,
-                firstSequence: record.sequence,
-                lastSequence: record.sequence
-            };
-            groups.push(group);
-        }
-        group.lines.push(line);
-        group.bytes += bytes;
-        group.lastSequence = record.sequence;
-    }
-    if (groups.length === 0)
+async function stageSessionSegments(sessionDirectory, records, operation = 'rollback') {
+    let group;
+    if (records.length === 0)
         throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Session history is corrupt.');
     const transactionId = randomUUID();
     const files = [];
+    const segments = [];
+    const flush = async () => {
+        if (group === undefined)
+            return;
+        const number = segments.length + 1;
+        const path = join(sessionDirectory, `events-${String(number).padStart(6, '0')}.jsonl`);
+        const temporaryPath = `${path}.${transactionId}.${operation}-tmp`;
+        const handle = await open(temporaryPath, 'wx', 0o600);
+        files.push({ path, temporaryPath });
+        try {
+            await handle.writeFile(group.lines.join(''));
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        segments.push({
+            number,
+            firstSequence: group.firstSequence,
+            lastSequence: group.lastSequence,
+            bytes: group.bytes
+        });
+        group = undefined;
+    };
     try {
-        for (const [index, group] of groups.entries()) {
-            const number = index + 1;
-            const path = join(sessionDirectory, `events-${String(number).padStart(6, '0')}.jsonl`);
-            const temporaryPath = `${path}.${transactionId}.rollback-tmp`;
-            const handle = await open(temporaryPath, 'wx', 0o600);
-            try {
-                await handle.writeFile(group.lines.join(''));
-                await handle.sync();
-            }
-            finally {
-                await handle.close();
+        for (const record of records) {
+            const line = `${JSON.stringify(record)}\n`;
+            const bytes = Buffer.byteLength(line);
+            if (group !== undefined && group.bytes > 0 && group.bytes + bytes > MAX_SEGMENT_BYTES)
+                await flush();
+            if (group === undefined) {
+                group = {
+                    lines: [],
+                    bytes: 0,
+                    firstSequence: record.sequence,
+                    lastSequence: record.sequence
+                };
             }
-            files.push({ path, temporaryPath });
+            group.lines.push(line);
+            group.bytes += bytes;
+            group.lastSequence = record.sequence;
         }
-        return {
-            files,
-            segments: groups.map((group, index) => ({
-                number: index + 1,
-                firstSequence: group.firstSequence,
-                lastSequence: group.lastSequence,
-                bytes: group.bytes
-            }))
-        };
+        await flush();
+        return { files, segments };
     }
     catch (error) {
         await Promise.all(files.map((item) => rm(item.temporaryPath, { force: true }))).catch(() => undefined);

package/dist/subagent/scheduler.d.ts

@@ -125,7 +125,7 @@ export declare class SubagentScheduler implements SubagentController {
         turnId?: string;
         deliveryStatus?: "accepted" | "applied" | "cancelled" | "failed";
     } | {
-        waitOutcome: "timeout" | "completion";
+        waitOutcome: "completion" | "timeout";
         agentId: string;
         description: string;
         status: "queued" | "running" | "completed" | "failed" | "cancelled" | "interrupted";
@@ -172,7 +172,7 @@ export declare class SubagentScheduler implements SubagentController {
         turnId?: string;
         deliveryStatus?: "accepted" | "applied" | "cancelled" | "failed";
     } | {
-        waitOutcome: "timeout" | "completion";
+        waitOutcome: "completion" | "timeout";
         agentId: string;
         description: string;
         status: "queued" | "running" | "completed" | "failed" | "cancelled" | "interrupted";
@@ -199,7 +199,7 @@ export declare class SubagentScheduler implements SubagentController {
     message(_agentId: string, _message: string): Promise<SubagentTaskSnapshot>;
     listSessionResources(): {
         agentId: string;
-        status: "completed" | "cancelled" | "running" | "failed" | "queued";
+        status: "completed" | "cancelled" | "running" | "queued" | "failed";
         description: string;
     }[];
     dispose(): Promise<void>;

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

@@ -91,7 +91,7 @@ export declare class SubagentSessionController implements SubagentController {
     cancel(agentId: string): Promise<SubagentTaskSnapshot>;
     listSessionResources(): {
         agentId: string;
-        status: "completed" | "cancelled" | "running" | "failed" | "queued" | "interrupted";
+        status: "completed" | "cancelled" | "running" | "queued" | "failed" | "interrupted";
         description: string;
     }[];
     dispose(): Promise<void>;

package/dist/tools/agent-cancel.js

@@ -1,6 +1,7 @@
 import { MarAgentError } from '../error.js';
 export const agentCancelToolDefinition = {
     name: 'agent_cancel',
+    allowedCallers: ['direct', 'programmatic'],
     parallelSafety: 'serial',
     description: 'Idempotently cancel a child agent using the agentId returned by agent_start. For an exec processId, use exec with action:"cancel" instead. Waits for a running task to reach cancelled and returns its agentId and description.',
     inputSchema: {

package/dist/tools/agent-message.js

@@ -2,6 +2,7 @@ import { MarAgentError } from '../error.js';
 import { TOOL_EXECUTION_LIMITS } from './execution-limits.js';
 export const agentMessageToolDefinition = {
     name: 'agent_message',
+    allowedCallers: ['direct', 'programmatic'],
     parallelSafety: 'serial',
     description: 'Send a real user message to an existing child agent. Default delivery=append inserts guidance into a running child turn at the next safe boundary after the current model response or complete tool batch. Explicit delivery=replace immediately requests cancellation, waits for the old turn to close, then starts a new turn in the same Session. When idle, either mode starts a new turn using persisted history. Returns messageId, turnId, deliveryStatus, current status, and model metadata without repeating the child’s previous latestMessage, latestActivity, summary, or verification evidence. accepted means queued in memory; applied means persisted in model context, not that the guidance has been executed. Use agent_wait for subsequent progress or completion. Does not wait for the new task to complete or roll back existing side effects.',
     inputSchema: {

package/dist/tools/agent-start.js

@@ -3,6 +3,7 @@ import { marAgentReasoningEffortSchema } from '../model/configuration.js';
 import { TOOL_EXECUTION_LIMITS } from './execution-limits.js';
 export const agentStartToolDefinition = {
     name: 'agent_start',
+    allowedCallers: ['direct', 'programmatic'],
     parallelSafety: 'serial',
     description: 'Start one bounded, non-recursive child agent with self-contained context. Use when an independent investigation would consume substantial main-context space or when safe parallel work has real value; keep small or tightly coupled work in the main context. All agents share the filesystem, so avoid conflicting writes. The optional reasoningEffort overrides the parent effort and must be supported by the selected model; omit it to inherit. Returns agentId for agent_wait, agent_message, or agent_cancel, description, queued/running/completed/failed/cancelled status, bounded summary, changedFiles, verification, and read evidence; background returns immediately while foreground waits for a terminal result.',
     inputSchema: {

package/dist/tools/agent-wait.js

@@ -2,6 +2,7 @@ import { MarAgentError } from '../error.js';
 import { TOOL_EXECUTION_LIMITS } from './execution-limits.js';
 export const agentWaitToolDefinition = {
     name: 'agent_wait',
+    allowedCallers: ['direct', 'programmatic'],
     parallelSafety: 'serial',
     description: 'Read or wait a bounded time for a child agent result. waitFor defaults to "completion"; use "message" only when a fresh public commentary/final message would change the next decision. Omit agentId to wait for whichever live child returns first, matching Codex-style untargeted waiting and avoiding UUID transcription; provide the exact agentId returned by agent_start only when observing a specific child. If no child is live, untargeted waiting reads the most recently created child. For an exec processId, use exec with action:"poll" instead. Omitting waitMs waits up to 30 seconds by default; waitMs=0 returns the current snapshot immediately. Positive waits range up to 5 minutes, and positive values below 10 seconds are raised to 10 seconds. When blocked on a live child result, prefer one 300000 ms completion wait rather than repeated short waits. Every result includes waitOutcome as snapshot, message, completion, or timeout plus the real agentId and description. A message, timeout with unread progress, or first terminal completion result includes the newly observed latest public commentary/final message; snapshots and repeated observations omit previously observed message text. latestActivity can still identify a public message or bounded tool started/completed/failed status. A queued or running result is not completion. A message wait consumes only the latest unread public message in the current Session runtime; tool activity does not wake it, and parent cancellation preserves unread progress for a later Execution. Do not use message waits as heartbeat checks or request progress merely to confirm that a child is still running. First terminal results include bounded summary, changedFiles, verification, and read evidence with path/line ranges; use that evidence to avoid repeating the full exploration, while independently checking consequential edits and claims.',
     inputSchema: {

package/dist/tools/apply-patch.js

@@ -6,8 +6,9 @@ import { MarAgentError } from '../error.js';
 import { TOOL_EXECUTION_LIMITS } from './execution-limits.js';
 export const applyPatchToolDefinition = {
     name: 'apply_patch',
+    allowedCallers: ['direct', 'programmatic'],
     parallelSafety: 'serial',
-    description: `Preferred for precise, reviewable local edits. Do not batch all task files merely to reduce tool calls. Group only a few tightly coupled edits whose combined patch is quick to generate and review; split broad or independent work into successive bounded patches before composing them. Submit a raw *** Begin Patch / *** End Patch patch. Supports Add File, Update File, Delete File, and Move to. Add File may replace an existing regular file, and Move to may replace an existing regular destination; duplicate operations on the same resolved path remain invalid. Update hunks accept @@ or @@ <change context>; context-only hunks may also be used as ordered anchors before a later changing hunk. Context is searched forward with Codex-style exact, whitespace-tolerant, then common Unicode punctuation-tolerant matching. Syntax and resolved paths are validated before writing, then file units are committed in order. Each file unit is atomic, and a Move keeps its source and destination atomic. On MAR_AGENT_PATCH_PARTIAL, earlier files remain applied; the error lists applied, failed, and pending paths, so retry only failed and pending paths. Existing file permissions, line endings, and final-newline state are preserved. Returns changed file paths and operations with per-file and total line counts when all units succeed. Oversized patches are rejected without advertising defensive limits as recommended patch sizes. A first-unit MAR_AGENT_PATCH_CONFLICT applies nothing; hunk match conflicts identify the affected path and hunk so you can reread only that file before retrying.`,
+    description: `Preferred for precise, reviewable local edits. Do not batch all task files merely to reduce tool calls. Group only a few tightly coupled edits whose combined patch is quick to generate and review; split broad or independent work into successive bounded patches before composing them. Submit a raw *** Begin Patch / *** End Patch patch. Supports Add File, Update File, Delete File, and Move to. Add File may replace an existing regular file, and Move to may replace an existing regular destination; duplicate operations on the same resolved path remain invalid. Update hunks accept @@ or @@ <change context>; context-only hunks may also be used as ordered anchors before a later changing hunk. Context is searched forward with Codex-style exact, whitespace-tolerant, then common Unicode punctuation-tolerant matching. Syntax and resolved paths are validated before writing, then file units are committed in order. Each file unit is atomic, and a Move keeps its source and destination atomic. On MAR_AGENT_PATCH_PARTIAL, earlier files remain applied; the error lists applied, failed, and pending paths, so retry only failed and pending paths. Existing file permissions, line endings, and final-newline state are preserved. Returns changed file paths and operations with per-file and total line counts when all units succeed. In Code Mode, the Promise resolves on success and rejects with code/message on failure; the returned envelope has data.files and data.totals, not an ok or success flag. Oversized patches are rejected without advertising defensive limits as recommended patch sizes. A first-unit MAR_AGENT_PATCH_CONFLICT applies nothing; hunk match conflicts identify the affected path and hunk so you can reread only that file before retrying.`,
     inputMode: 'freeform',
     outputSchema: {
         type: 'object',

package/dist/tools/callers.d.ts

@@ -0,0 +1,6 @@
+import type { ClientToolDefinition, ToolCaller } from '../model/contracts.js';
+/** Normalize trusted Host policy independently of discovery, Agent scope and parallel safety. */
+export declare function toolCallers(tool: ClientToolDefinition): readonly ToolCaller[];
+export declare function allowsToolCaller(tool: ClientToolDefinition, caller: ToolCaller): boolean;
+/** Code Mode Only changes model exposure, never the Host's underlying caller permissions. */
+export declare function allowsDirectTool(tool: ClientToolDefinition, codeModeEnabled: boolean): boolean;

package/dist/tools/callers.js

@@ -0,0 +1,23 @@
+import { MarAgentError } from '../error.js';
+/** Normalize trusted Host policy independently of discovery, Agent scope and parallel safety. */
+export function toolCallers(tool) {
+    const value = tool.allowedCallers;
+    if (value === undefined)
+        return tool.name.startsWith('mcp__') ? ['direct', 'programmatic'] : ['direct'];
+    if (!Array.isArray(value) ||
+        value.length === 0 ||
+        value.some((caller) => caller !== 'direct' && caller !== 'programmatic'))
+        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Tool caller policy is invalid.');
+    return ['direct', 'programmatic'].filter((caller) => value.includes(caller));
+}
+export function allowsToolCaller(tool, caller) {
+    // Control tools cannot be widened by a Host override or historical definition.
+    if (caller === 'programmatic' && ['code_mode', 'tool_search', 'question'].includes(tool.name))
+        return false;
+    return toolCallers(tool).includes(caller);
+}
+/** Code Mode Only changes model exposure, never the Host's underlying caller permissions. */
+export function allowsDirectTool(tool, codeModeEnabled) {
+    return (allowsToolCaller(tool, 'direct') &&
+        (!codeModeEnabled || !allowsToolCaller(tool, 'programmatic')));
+}

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

@@ -0,0 +1,43 @@
+import type { ToolCall, ToolExecutionResult } from '../../sdk/types.js';
+import type { CodeModeStateEntry, CodeModeStateMutation } from './state.js';
+export interface CodeModeCatalogEntry {
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema: unknown;
+    readonly inputMode: 'json' | 'freeform';
+}
+/** A trusted, replaceable worker-side engine; no engine handles cross this interface. */
+export interface CodeModeEngine {
+    execute(input: {
+        code: string;
+        tools: readonly string[];
+        catalog: readonly CodeModeCatalogEntry[];
+        state: readonly CodeModeStateEntry[];
+        signal: AbortSignal;
+        limits: {
+            memoryBytes: number;
+            stackBytes: number;
+            timeoutMs: number;
+            outputBytes: number;
+            stateEntries: number;
+            stateMutations: number;
+            stateKeyBytes: number;
+            stateValueBytes: number;
+            stateTotalBytes: number;
+            sleepMs: number;
+        };
+        onToolCall(call: ToolCall): Promise<ToolExecutionResult>;
+        onText(value: string): void;
+        onImage(value: unknown): void;
+    }): Promise<{
+        readonly stateMutations: readonly CodeModeStateMutation[];
+    }>;
+    dispose(): Promise<void>;
+}
+/** Only the Local Host may supply this descriptor; it is never part of model tool input. */
+export interface CodeModeEngineFactory {
+    readonly moduleUrl: string;
+    readonly runtimeDirectories: readonly string[];
+    readonly options?: Readonly<Record<string, unknown>>;
+}
+export type CreateCodeModeEngine = (options: Readonly<Record<string, unknown>>) => Promise<CodeModeEngine>;

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

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

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

@@ -0,0 +1,2 @@
+/** @returns {Promise<import('./engine.js').CodeModeEngine>} */
+export function createCodeModeEngine(options: any): Promise<import("./engine.js").CodeModeEngine>;