@myagentroam/node 0.11.23 → 0.11.25

package/dist/connector.js

@@ -372,6 +372,7 @@ export class NodeConnector {
         onTerminalRun: (run, status) => {
             if (this.database !== undefined)
                 this.scheduledSessions.executionTerminated(run, status);
+            this.continuousRunCoordinator.runTerminated(run.sessionId);
         },
         dispatchQueue: async (sessionId, delayMs = 0) => {
             if (this.upgradeCoordinator.pending())
@@ -543,7 +544,7 @@ export class NodeConnector {
             emit: (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status),
             nativeGoalUpdated: (runId, goal) => this.goalCoordinator.handleNativeGoalUpdate(runId, goal),
             cancel: (runId, threadId, turnId, cwd, status) => this.runnerInteractionService.cancelCodexTurn(runId, threadId, turnId, cwd, status),
-            createApproval: (input) => this.runtime.createApproval(input),
+            createApproval: (input) => this.runnerInteractionService.createCodexApproval(input),
             publishApproval: (input) => this.runnerInteractionService.publishApproval(input),
             emitItem: (runId, item) => this.emitConversationItem(runId, item),
             appendImages: (runId, images) => this.runAttachmentService.append(runId, images.filter(isRunnerImageAttachment)),

package/dist/marctl-guidance.js

@@ -5,7 +5,7 @@ export function hasMarctlContext(environment) {
         !!environment['MAR_CTL_NODE_ID'] &&
         !!environment['MAR_CTL_WORKSPACE_ID']);
 }
-export const marctlDescription = 'You are in a MAR-managed Workspace with marctl on PATH. Load this guide to create, coordinate, message or stop independent Sessions; inspect Session status/history/results; change titles or models; manage Goals or scheduled tasks for the current or other Sessions; or run commands/transfer files on other authorized MAR Nodes, even when marctl is not named. Ordinary local shell work and built-in subagents alone do not require it.';
+export const marctlDescription = 'You are in a MAR-managed Workspace with marctl on PATH. Load this guide to create, coordinate, message or stop independent Sessions; inspect status/history/results; change titles, prompts or models; observe and decide approvals; manage Goals or scheduled tasks; or run commands/transfer files on other authorized MAR Nodes, even when marctl is not named. Ordinary local shell work and built-in subagents alone do not require it.';
 export const marctlInstructions = [
     '## MAR Workspace CLI',
     'Use your native shell tool to run marctl. Reuse loaded guidance while it remains in context. Consult local marctl help sessions for unclear options (shared by all Session subcommands) and marctl --version when version matters; neither needs a network request. Capabilities and permissions still apply.',
@@ -15,15 +15,16 @@ export const marctlInstructions = [
     'Change an existing Session with sessions config <session-id> --model <id> --effort high --json; either option can be set alone. Use show for current settings; active execution is not restarted.',
     'Prefer -m / --message for short text; use --message-file for longer UTF-8 text or an existing file (- reads stdin). These options are mutually exclusive. Example: marctl sessions start --runner codex --title "fixer#42 Handle empty totals" -m "Implement issue #42 and report test evidence" --json. Other Runner names are mar-agent, claude-code and opencode. An omitted model uses the target Runner configuration, not the Coordinator model.',
     'For start/send, repeat --image <local-path> to attach PNG, JPEG, GIF or WebP images, with or without text. Images are read on this CLI host, not by remote path. Limits: 5 images, 5 MiB each, 10 MiB total. Actual Runner/model image capabilities apply; goal set accepts text only.',
-    'Create workers only as tasks need them, named fixer#<task-id> <description> or reviewer#<task-or-change-id> <description>. These are conventions, not product roles or a fixed pool. Put role, scope, acceptance criteria and delivery requirements in the first message. Follow the repository workflow for development and review. Session Prompt is edited in the Web UI only; marctl has no editing command, and sends to existing Sessions use normal prompt injection.',
+    'Create workers only as tasks need them, named fixer#<task-id> <description> or reviewer#<task-or-change-id> <description>. These are conventions, not product roles or a fixed pool. Put role, scope, acceptance criteria and delivery requirements in the first message. Follow the repository workflow for development and review. Use sessions prompt get/set/clear [session-id] to read, set or clear persistent instructions; set uses -m or --message-file. Changes apply to future executions, including queued work, without interrupting current execution.',
     'Reuse recorded Session/Run IDs and receipts. Refresh execution state with show only when the next action depends on it; use goal get or schedule get for those details. Select needed JSON fields instead of dumping full Session lists or tool transcripts. Hidden reasoning, credentials and raw model requests are not collaboration artifacts.',
-    'list returns id/title/runner/status/runId and one latestActivity per Session. show --json fields: session.id, session.title, session.runner, session.status, session.runId, session.model, session.effort, session.queuedCount, session.latestMessage, session.recentTools (at most three). Status is RUNNING/IDLE/SLEEPING; tools keep their original states. Activity is bounded public evidence, not proof of task completion; use history for full results.',
+    'list returns id/title/runner/status/runId and one latestActivity per Session. show --json fields: session.id, session.title, session.runner, session.status, session.runId, session.model, session.effort, session.queuedCount, session.latestMessage, session.recentTools (at most three), session.pendingApprovals and pendingApprovalsTruncated. Approvals use public Run IDs, without raw tool input. Status is RUNNING/IDLE/SLEEPING; tools keep their original states. Activity is bounded public evidence, not proof of task completion; use history for full results.',
     'Rename any authorized Workspace Session with sessions rename <session-id> --title <name> --json; parent relationships do not restrict renaming.',
-    'show/config/history/graph/rename and schedule get/create/update may omit the Session ID to use the current Session. Without a current Session, specify an ID. send/goal/stop/wait always require explicit target IDs.',
+    'show/config/history/graph/rename, prompt and schedule get/create/update may omit the Session ID to use the current Session. Without a current Session, specify an ID. send/goal/stop/wait/approval always require explicit target IDs.',
     'Use sessions schedule list/get/create/update for the same tasks as the built-in schedule MCP, which remains available in other Runners and is hidden in MAR Agent while its marctl skill is available. list is Workspace-scoped. create requires --cron and text (-m/--message-file, up to 20,000 characters). update requires --expected-revision from get and at least cron or text. get returns task (null if absent), with id, revision, objective, cron, timezone and enabled; applied updates also return task. Reuse that task instead of probing its shape or refetching unchanged state. Schedule text is trimmed at both ends; compare after the same trimming; a conclusive update response needs no extra get. Other-owner edits return a PENDING proposal, not an applied change. Scheduled execution uses normal user permissions. Follow existing approval rules and do not retry conflicts or uncertain writes blindly.',
     'Read results with sessions history <session-id> --limit 10 --json (default: latest 10 SEGMENTs, not messages; --limit 1..100). In segments[].items[], select kind === "assistant_message" and read payload.text; keep segment runId and user_message.payload.clientMessageId for queued-input correlation. Reuse the returned page; follow --cursor <nextCursor> only for missing evidence.',
-    'Use sessions send <session-id> --steer -m "Additional context: focus on the resume path." --json for decision-changing updates rather than routine reports: it may switch the current execution. Node decides delivery from actual state; an idle Session receives ordinary input. Choose exactly one of --steer or --queue, even when idle; missing, conflicting, repeated, or obsolete options are rejected locally before input is read or a request is sent. Use --queue to place input in a subsequent turn; with an active Goal, ordinary queued input waits until the Goal exits. start/send return clientMessageId and the accepted/queued result. A queued result may refer to the currently active Run: associate queueItemId/clientMessageId with history before deciding that input finished. There are no queue-item edit/delete/reorder commands; show returns only queuedCount.',
+    'Use sessions send <session-id> --steer -m "Additional context: focus on the resume path." --json for decision-changing updates rather than routine reports: it may switch the current execution. Node decides delivery from actual state; an idle Session receives ordinary input. Choose exactly one of --steer or --queue, even when idle; missing, conflicting, repeated, or obsolete options are rejected locally before input is read or a request is sent. Use --queue to place input in a subsequent turn without interrupting active execution. New input resumes a paused queue using ordinary send admission after cancellation settles; later explicit stops still apply; with an active Goal, ordinary queued input waits until the Goal exits. start/send return clientMessageId and the accepted/queued result. A queued result may refer to the currently active Run: associate queueItemId/clientMessageId with history before deciding that input finished. There are no queue-item edit/delete/reorder commands; show returns only queuedCount.',
     'Wait with sessions wait <session-id> --run <run-id> --timeout 5m --json through the existing Watch. Prefer --timeout 5m when blocked on task completion; use 30s for a short deadline. Continue useful independent work before waiting. If your shell tool returns a running process or cell, reuse its process/cell handle rather than starting another wait or polling show/list. A timeout may include progress, the last observed snapshot, not a fresh query. Timeout or cancelled waiting does not stop the task. Use sessions stop <session-id> --run <run-id> --json only to stop that active Run; ownership rules still apply.',
+    'Use wait --until approval to return early when a Run needs a decision. Inspect show/history, then use sessions approval decide <session-id> --run <public-run-id> --approval <approval-id> --decision approve|reject --json for one explicitly authorized request. This does not grant authority or auto-approve tools. Acknowledgment is not completion; observe status/history and wait again as needed.',
     'Goal get/set/clear use the existing Session Goal semantics; see marctl help sessions. A Coordinator can work from ordinary messages or its existing schedule without a Goal. Worker completion never automatically wakes it. Actively wait/read results, or finish and reconcile on the next user message or scheduled input.',
     '## Verify, recover and respect authorization',
     'An accepted message or SUCCEEDED Run is not proof of business completion. Inspect artifacts and test evidence.',

package/dist/runner/codex/managed-run-controller.js

@@ -1,6 +1,7 @@
 import { NODE_MCP } from '../../mcp/naming.js';
 import { nodeExecutionEnvironment } from '../../node-execution-environment.js';
 import { extractId } from './conversation-parser.js';
+import { normalizeCodexApproval } from './tool-normalizer.js';
 import { parseSecretEnvironment } from '../../util/secret-environment.js';
 import { safeErrorCode } from '../../util/safe-error.js';
 import { runnerErrorProjection } from '../../util/runner-error.js';
@@ -499,6 +500,11 @@ export class CodexManagedRunController {
     requestApproval(runId, notification) {
         const approvalId = `codex:${runId}:${notification.requestId}`;
         const expiresAt = Date.now() + 10 * 60_000;
+        const payload = {
+            method: notification.method,
+            params: notification.params,
+            ...normalizeCodexApproval(notification.method)
+        };
         this.runner.execution.approvals.set(approvalId, {
             runId,
             requestId: notification.requestId
@@ -507,7 +513,7 @@ export class CodexManagedRunController {
             this.host.createApproval({
                 runId,
                 approvalId,
-                payload: { method: notification.method, params: notification.params },
+                payload,
                 expiresAt
             });
         }
@@ -518,7 +524,7 @@ export class CodexManagedRunController {
         this.host.publishApproval({
             runId,
             approvalId,
-            payload: { method: notification.method, params: notification.params },
+            payload,
             expiresAt
         });
     }

package/dist/runner/codex/tool-normalizer.js

@@ -1,4 +1,9 @@
 import { compactRunnerText } from '../../util/node-operation-parsers.js';
+export function normalizeCodexApproval(method) {
+    return method === 'item/commandExecution/requestApproval'
+        ? { toolName: 'command_execution', reason: 'Command execution requires approval.' }
+        : { toolName: 'file_change', reason: 'File changes require approval.' };
+}
 export function normalizeCodexTool(input) {
     const name = compactRunnerText(input.name, 128) || 'tool';
     const rawInput = input.rawInput;

package/dist/runner/codex-runner.js

@@ -564,6 +564,12 @@ export class CodexRunner extends AbstractRunner {
         this.runClients.set(runId, client);
     }
     releaseEnvironment(runId) {
+        for (const [id, approval] of this.execution.approvals) {
+            if (approval.runId !== runId)
+                continue;
+            clearTimeout(approval.timer);
+            this.execution.approvals.delete(id);
+        }
         const client = this.runClients.get(runId);
         if (client === undefined)
             return;
@@ -575,6 +581,9 @@ export class CodexRunner extends AbstractRunner {
         }
     }
     stop() {
+        for (const approval of this.execution.approvals.values())
+            clearTimeout(approval.timer);
+        this.execution.approvals.clear();
         this.profileGeneration += 1;
         for (const profileClient of this.profileClients)
             profileClient.stop();

package/dist/runner/mar-agent/conversation-normalizer.js

@@ -356,7 +356,8 @@ export class MarAgentConversationNormalizer {
             if (observation.id !== undefined)
                 this.#codeModeObservationIds.add(observation.id);
             this.#codeModeSourceCallIds.add(observation.source.callId);
-            items.push(...projected.map((item) => 'callId' in event ? { ...item, parentItemId: itemId('tool', event.callId) } : item));
+            // An execution/observation container does not own these public tool records.
+            items.push(...projected);
         }
         return items;
     }

package/dist/runner/mar-agent/history-projection.js

@@ -102,7 +102,7 @@ export function projectMarAgentHistory(session, entries, options = {}) {
             const attachments = projected.generatedImages === undefined
                 ? []
                 : (options.registerGeneratedImages?.(event.sessionId, projected.generatedImages) ?? []);
-            replace(projectionTurn, historyItem(session, projectionTurn, projected.itemId, projected.kind, projected.status, attachments.length === 0 ? projected.payload : { ...projected.payload, attachments }, at, projected.permissionStop, projected.parentItemId));
+            replace(projectionTurn, historyItem(session, projectionTurn, projected.itemId, projected.kind, projected.status, attachments.length === 0 ? projected.payload : { ...projected.payload, attachments }, at, projected.permissionStop));
         }
     }
     return [...turns.values()];
@@ -129,13 +129,13 @@ function record(value) {
         ? value
         : undefined;
 }
-function historyItem(session, turn, id, kind, status, payload, at, permissionStop, parentItemId) {
+function historyItem(session, turn, id, kind, status, payload, at, permissionStop) {
     return {
         id,
         sessionId: session.id,
         turnId: turn.id,
         runId: turn.runId,
-        parentItemId: parentItemId ?? null,
+        parentItemId: null,
         sourceSequence: null,
         revision: 0,
         kind,

package/dist/runner/mar-agent/managed-run-controller.js

@@ -701,7 +701,6 @@ export class MarAgentManagedRunController {
                         []);
                 this.host.emitItem(runId, {
                     itemId: item.itemId,
-                    ...(item.parentItemId === undefined ? {} : { parentItemId: item.parentItemId }),
                     kind: item.kind,
                     status: item.status,
                     payload: attachments.length === 0 ? item.payload : { ...item.payload, attachments },

package/dist/service/continuous-run-coordinator.js

@@ -13,6 +13,7 @@ export class ContinuousRunCoordinator {
     immediateQueueItems = new Set();
     queueExecutionAdmissions = new Map();
     steerInFlight = new Map();
+    deferredQueueResumes = new Map();
     suspended = false;
     constructor(options) {
         this.options = options;
@@ -164,9 +165,22 @@ export class ContinuousRunCoordinator {
             this.canSteer(active) &&
             (input.steerTarget.executionId === undefined ||
                 this.options.runtime.currentExecutionId(active.id) === input.steerTarget.executionId);
-        const intent = input.steerTarget !== undefined && !steering ? 'SEND' : input.intent;
-        if (active?.status === 'CANCELLING' && intent !== 'REPLACE_CURRENT')
+        const pauseVersion = this.options.runtime.sessionQueuePauseVersion(sessionId);
+        // An explicit pause after this input's admission takes precedence over automatic recovery.
+        if (input.externalInput &&
+            pauseVersion !== undefined &&
+            pauseVersion !== input.queuePauseVersion)
             return 'QUEUED';
+        const intent = input.steerTarget !== undefined && !steering
+            ? 'SEND'
+            : input.externalInput && input.queueBefore.paused && input.intent === 'QUEUE'
+                ? 'SEND'
+                : input.intent;
+        if (active?.status === 'CANCELLING' && intent !== 'REPLACE_CURRENT') {
+            if (input.externalInput && item && pauseVersion !== undefined)
+                this.deferredQueueResumes.set(item.id, pauseVersion);
+            return 'QUEUED';
+        }
         if (steering)
             this.prepareSteering(input.submissionId);
         const executionEnded = active !== undefined &&
@@ -517,6 +531,9 @@ export class ContinuousRunCoordinator {
         if ([...this.steerInFlight.values()].some((entry) => entry.sessionId === sessionId))
             return;
         const active = this.options.runtime.activeSessionRun(sessionId);
+        if (active?.status === 'CANCELLING')
+            return;
+        this.resumeDeferredQueue(sessionId);
         if (active === undefined) {
             await this.startIdleQueue(sessionId);
             return;
@@ -694,6 +711,7 @@ export class ContinuousRunCoordinator {
         }
     }
     remove(id) {
+        this.deferredQueueResumes.delete(id);
         this.immediateQueueItems.delete(id);
         this.environmentLeases.get(id)?.();
         this.environmentLeases.delete(id);
@@ -739,10 +757,31 @@ export class ContinuousRunCoordinator {
         this.startedExecutions.clear();
         this.immediateQueueItems.clear();
         this.queueExecutionAdmissions.clear();
+        this.deferredQueueResumes.clear();
         for (const timer of this.scheduledSessions.values())
             clearTimeout(timer);
         this.scheduledSessions.clear();
     }
+    runTerminated(sessionId) {
+        const queue = this.options.runtime.sessionQueue(sessionId);
+        if ((!queue.paused && queue.itemIds.length > 0) ||
+            [...this.deferredQueueResumes.keys()].some((id) => this.options.runtime.getQueueItem(id)?.sessionId === sessionId))
+            this.schedule(sessionId);
+    }
+    resumeDeferredQueue(sessionId) {
+        for (const [id, pauseVersion] of this.deferredQueueResumes) {
+            const item = this.options.runtime.getQueueItem(id);
+            if (item?.sessionId !== sessionId)
+                continue;
+            this.deferredQueueResumes.delete(id);
+            if (this.options.runtime.sessionQueuePauseVersion(sessionId) !== pauseVersion)
+                continue;
+            this.options.runtime.resumeSessionQueue(sessionId);
+            if (!this.options.goalActive?.(sessionId))
+                this.options.runtime.prioritizeQueueItem(id);
+            this.publish(sessionId);
+        }
+    }
     async startIdleQueue(sessionId, throwOnError = false) {
         if (this.options.runtime.activeSessionRun(sessionId) !== undefined) {
             this.schedule(sessionId);

package/dist/service/direct-transfer-service.js

@@ -1,9 +1,11 @@
 import { createSocket } from 'node:dgram';
+import { isIP } from 'node:net';
 import { directDataControlFrameSchema, directNodeCommandSchema } from '@myagentroam/protocol';
 import { TerminalDirectService } from './terminal-direct-service.js';
 import { IceUdpMuxListener as NativeIceUdpMuxListener } from 'node-datachannel';
 import { RTCPeerConnection } from 'node-datachannel/polyfill';
 const MAX_HOST_CANDIDATES = 32;
+const LOOPBACK_CANDIDATE_PRIORITY = '2130706431';
 const MAX_ACTIVE_TRANSPORTS = 128;
 const MAX_ACTIVE_TRANSFERS = 128;
 const DATA_CHANNEL_HIGH_WATER_BYTES = 4 * 1024 * 1024;
@@ -159,6 +161,7 @@ export class DirectTransferService {
         };
         transport.leaseTimer = this.startLeaseWatch(() => transport.leaseExpiresAt, () => transport.lastLeaseAliveAt, () => this.removeTransport(transport, 'DIRECT_TRANSFER_CONTROL_UNAVAILABLE'));
         this.transports.set(command.directSessionId, transport);
+        const sentLoopbackAddresses = new Set();
         peer.onicecandidate = (event) => {
             const candidate = event.candidate;
             if (candidate === null) {
@@ -170,8 +173,29 @@ export class DirectTransferService {
                 return;
             }
             const json = candidate.toJSON();
-            if (typeof json.candidate !== 'string' ||
-                !acceptHostCandidate(json.candidate, transport.sentCandidateKeys))
+            if (typeof json.candidate !== 'string')
+                return;
+            const loopback = loopbackHostCandidate(json.candidate);
+            const loopbackAddress = loopback?.trim().split(/\s+/u)[4];
+            if (loopback !== undefined &&
+                loopbackAddress !== undefined &&
+                !sentLoopbackAddresses.has(loopbackAddress)) {
+                sentLoopbackAddresses.add(loopbackAddress);
+                if (acceptHostCandidate(loopback, transport.sentCandidateKeys))
+                    this.emit(command.directSessionId, {
+                        type: 'direct.signal',
+                        directSessionId: command.directSessionId,
+                        signal: {
+                            kind: 'CANDIDATE',
+                            candidate: {
+                                candidate: loopback,
+                                sdpMid: json.sdpMid ?? null,
+                                sdpMLineIndex: json.sdpMLineIndex ?? null
+                            }
+                        }
+                    });
+            }
+            if (!acceptHostCandidate(json.candidate, transport.sentCandidateKeys))
                 return;
             this.emit(command.directSessionId, {
                 type: 'direct.signal',
@@ -543,6 +567,19 @@ export function probeUdp4Port(port) {
         socket.bind({ port, address: '0.0.0.0', exclusive: true }, () => socket.close(() => resolve()));
     });
 }
+export function loopbackHostCandidate(candidate) {
+    if (!safeHostCandidate(candidate))
+        return undefined;
+    const address = candidate.trim().split(/\s+/u)[4];
+    const family = isIP(address ?? '');
+    const loopback = family === 4 ? '127.0.0.1' : family === 6 ? '::1' : undefined;
+    if (loopback === undefined || address === loopback)
+        return undefined;
+    const fields = candidate.trim().split(/\s+/u);
+    fields[3] = LOOPBACK_CANDIDATE_PRIORITY;
+    fields[4] = loopback;
+    return fields.join(' ');
+}
 export function fingerprint(sdp) {
     const match = sdp?.match(/^a=fingerprint:(sha-256 [A-F0-9:]+)\r?$/imu);
     return match?.[1];
@@ -583,20 +620,26 @@ function filterIceCandidates(sdp, accepted) {
     if (sdp === undefined)
         return { sdp: undefined };
     const included = new Set();
-    const lines = sdp.split(/\r?\n/u).filter((line) => {
+    const lines = sdp.split(/\r?\n/u).flatMap((line) => {
         if (!line.startsWith('a=candidate:'))
-            return true;
+            return [line];
         const candidate = line.slice(2);
         if (!safeHostCandidate(candidate))
-            return false;
-        const key = candidateKey(candidate);
-        if (key === undefined || included.has(key))
-            return false;
-        if (!accepted.has(key) && accepted.size >= MAX_HOST_CANDIDATES)
-            return false;
-        accepted.add(key);
-        included.add(key);
-        return true;
+            return [];
+        const loopback = loopbackHostCandidate(candidate);
+        const candidates = loopback === undefined ? [candidate] : [loopback, candidate];
+        const retained = [];
+        for (const value of candidates) {
+            const key = candidateKey(value);
+            if (key === undefined || included.has(key))
+                continue;
+            if (!accepted.has(key) && accepted.size >= MAX_HOST_CANDIDATES)
+                continue;
+            accepted.add(key);
+            included.add(key);
+            retained.push(`a=${value}`);
+        }
+        return retained;
     });
     return { sdp: lines.join('\r\n') };
 }

package/dist/service/run-event-service.js

@@ -134,7 +134,8 @@ export class RunEventService {
             const interrupted = this.options.state.interruptRequested.delete(executionId);
             manuallyInterrupted = interrupted;
             const queue = this.options.runtime.sessionQueue(run.sessionId);
-            const continues = permissionStop === undefined &&
+            const continues = run.status !== 'CANCELLING' &&
+                permissionStop === undefined &&
                 ((!queue.paused && queue.itemIds.length > 0) ||
                     this.options.keepRunActive?.(run.sessionId) === true);
             if (!continues) {

package/dist/service/run-workbench-service.js

@@ -109,6 +109,11 @@ export class RunWorkbenchService {
         const current = this.options.runtime.getApproval(input.approvalId);
         if (current === undefined || this.options.runtime.canonicalRunId(current.runId) !== input.runId)
             throw new Error('APPROVAL_NOT_FOUND');
+        const run = this.options.runtime.activeSessionRun(this.requireRun(input.runId).sessionId);
+        if (run?.id !== input.runId ||
+            (current.runId !== run.id &&
+                current.runId !== this.options.runtime.currentExecutionId(run.id)))
+            throw new Error('APPROVAL_NOT_FOUND');
         this.assertRunOwner(current.runId, input.__requestUserId);
         const approval = this.options.runtime.decideApproval(input.approvalId, input.decision);
         this.options.emitRun(approval.runId, 'approval.decided', {

package/dist/service/runner-interaction-service.js

@@ -130,11 +130,40 @@ export class RunnerInteractionService {
             delivery
         }));
     }
+    createCodexApproval(input) {
+        this.options.runtime.createApproval(input);
+        const approvals = this.options.codex().execution.approvals;
+        const pending = approvals.get(input.approvalId);
+        const expire = () => {
+            const current = approvals.get(input.approvalId);
+            if (current === undefined)
+                return;
+            try {
+                this.options.runtime.expireApproval(input.approvalId);
+            }
+            catch (error) {
+                if (error instanceof Error && error.message === 'APPROVAL_NOT_EXPIRED') {
+                    const timer = setTimeout(expire, Math.max(1, input.expiresAt - Date.now()));
+                    timer.unref();
+                    approvals.set(input.approvalId, { ...current, timer });
+                    return;
+                }
+                approvals.delete(input.approvalId);
+                return;
+            }
+            this.options.emitRun(input.runId, 'approval.expired', { approvalId: input.approvalId });
+            this.decideCodexApproval(input.approvalId, 'REJECTED');
+        };
+        const timer = setTimeout(expire, Math.max(1, input.expiresAt - Date.now()));
+        timer.unref();
+        approvals.set(input.approvalId, { ...pending, timer });
+    }
     decideCodexApproval(approvalId, decision) {
         const codex = this.options.codex();
         const approval = codex.execution.approvals.get(approvalId);
         if (approval === undefined)
             return false;
+        clearTimeout(approval.timer);
         try {
             codex.respond(approval.requestId, { decision: decision === 'APPROVED' ? 'accept' : 'decline' }, approval.runId);
         }

package/dist/service/session-message-service.js

@@ -158,6 +158,7 @@ export class SessionMessageService {
                 ? input.__queueItemId
                 : randomUUID();
             const queueBeforeCreate = this.options.runtime.sessionQueue(session.id);
+            const queuePauseVersion = this.options.runtime.sessionQueuePauseVersion(session.id);
             const active = this.options.runtime.activeSessionRun(session.id);
             if (internalSchedule && (active !== undefined || queueBeforeCreate.itemIds.length > 0))
                 throw new Error('SCHEDULE_SESSION_BUSY');
@@ -309,6 +310,8 @@ export class SessionMessageService {
                             },
                             submissionId,
                             intent,
+                            externalInput: userMessage,
+                            ...(queuePauseVersion === undefined ? {} : { queuePauseVersion }),
                             queueBefore: queueBeforeCreate,
                             ...(steerTarget === undefined ? {} : { steerTarget }),
                             ...(replaceCurrentRun === undefined ? {} : { activeRunId: replaceCurrentRun.id })

package/dist/service/session-recent-activity.js

@@ -78,7 +78,33 @@ function activity(runtime, sessionId) {
 }
 export function marctlSessionProgress(runtime, sessionId) {
     const { latestActivity: _latest, ...progress } = activity(runtime, sessionId);
-    return progress;
+    return { ...progress, ...pendingApprovals(runtime, sessionId) };
+}
+/** Summarizes current approval facts without exposing tool input or native payloads. */
+function pendingApprovals(runtime, sessionId) {
+    const run = runtime.activeSessionRun(sessionId);
+    const executionId = run && runtime.currentExecutionId(run.id);
+    const approvals = run && !isTerminalRunStatus(run.status)
+        ? runtime
+            .listApprovals(run.id)
+            .filter((approval) => approval.status === 'PENDING' &&
+            (approval.runId === run.id || approval.runId === executionId))
+        : [];
+    return {
+        pendingApprovals: approvals.slice(0, 20).map((approval) => {
+            const payload = isPlainRecord(approval.payload) ? approval.payload : {};
+            const name = clip(typeof payload.toolName === 'string' ? payload.toolName : 'Approval', 128);
+            const summary = clip(typeof payload.reason === 'string' ? payload.reason : 'Approval required', 100);
+            return {
+                runId: run.id,
+                approvalId: approval.id,
+                name: name.text,
+                summary: summary.text,
+                truncated: name.truncated || summary.truncated
+            };
+        }),
+        pendingApprovalsTruncated: approvals.length > 20
+    };
 }
 function identity(session) {
     return {
@@ -104,7 +130,8 @@ export function marctlSessionDetail(runtime, session, queuedCount) {
         effort: session.effort,
         queuedCount,
         latestMessage,
-        recentTools
+        recentTools,
+        ...pendingApprovals(runtime, session.id)
     };
 }
 function time(item) {

package/dist/service/workbench-event-projection.js

@@ -78,7 +78,13 @@ export function projectWorkbenchPayload(queries, category, payload) {
             payload = {
                 sessionId: turn.sessionId,
                 runId: turn.runId,
-                ...(['assistant_message', 'tool_call', 'command_execution', 'file_change'].includes(item.kind) &&
+                ...([
+                    'assistant_message',
+                    'tool_call',
+                    'command_execution',
+                    'file_change',
+                    'approval_request'
+                ].includes(item.kind) &&
                     (rawPayload?.append === undefined || item.status !== 'IN_PROGRESS')
                     ? { progress: queries.progress(turn.sessionId) }
                     : {}),

package/dist/service/workspace-file-manager-service.js

@@ -0,0 +1,49 @@
+import { spawn } from 'node:child_process';
+import { dirname } from 'node:path';
+import { resolveWorkspaceFileManagerTarget } from '../workspace.js';
+export function fileManagerInvocation(platform, target) {
+    if (platform === 'win32')
+        return {
+            command: 'explorer.exe',
+            args: target.kind === 'FILE' ? ['/select,', target.path] : [target.path]
+        };
+    if (platform === 'darwin')
+        return { command: 'open', args: target.kind === 'FILE' ? ['-R', target.path] : [target.path] };
+    if (platform === 'linux')
+        return {
+            command: 'xdg-open',
+            args: [target.kind === 'FILE' ? dirname(target.path) : target.path]
+        };
+    throw new Error('FILE_MANAGER_UNAVAILABLE');
+}
+export async function revealWorkspaceFileInFileManager(workspaceRoot, requestedPath, options = {}) {
+    const target = await resolveWorkspaceFileManagerTarget(workspaceRoot, requestedPath);
+    const platform = options.platform ?? process.platform;
+    const invocation = fileManagerInvocation(platform, target);
+    const spawnProcess = options.spawnProcess ?? spawn;
+    let child;
+    try {
+        child = spawnProcess(invocation.command, invocation.args, {
+            detached: true,
+            stdio: 'ignore',
+            windowsHide: true
+        });
+        await new Promise((resolve, reject) => {
+            child.once('error', reject);
+            if (platform === 'win32')
+                child.once('spawn', () => resolve());
+            else
+                child.once('exit', (code) => {
+                    if (code === 0)
+                        resolve();
+                    else
+                        reject(new Error('FILE_MANAGER_UNAVAILABLE'));
+                });
+        });
+    }
+    catch (error) {
+        throw new Error('FILE_MANAGER_UNAVAILABLE', { cause: error });
+    }
+    child.unref();
+    return { revealed: true };
+}

package/dist/service/workspace-file-service.js

@@ -2,6 +2,7 @@ import { basename, dirname, isAbsolute, relative, resolve, win32 } from 'node:pa
 import { lstat, realpath } from 'node:fs/promises';
 import { isComposerAttachmentResourcePath } from '@myagentroam/protocol';
 import { listWorkspaceFiles, mutateWorkspaceFile, normalizeFilePreviewPath, readAbsoluteFileContentRange, readWorkspaceFileContentRange, readAbsoluteTextFile, readWorkspaceTextFile, writeWorkspaceTextFile, WorkspaceFileIndex } from '../workspace.js';
+import { revealWorkspaceFileInFileManager } from './workspace-file-manager-service.js';
 const INDEX_CACHE_LIMIT = 32;
 const INDEX_CACHE_BYTE_LIMIT = 128 * 1024 * 1024;
 const INDEX_QUEUE_LIMIT = 16;
@@ -224,6 +225,11 @@ export class WorkspaceFileService {
             return result;
         });
     }
+    async reveal(workspace, input) {
+        if (typeof input.path !== 'string')
+            throw new Error('FILE_REVEAL_INVALID');
+        return revealWorkspaceFileInFileManager(workspace.path, input.path);
+    }
     async serializeMutation(workspaceId, operation) {
         const previous = this.mutationTails.get(workspaceId) ?? Promise.resolve();
         const result = previous.then(operation, operation);

package/dist/service/workspace-workbench-service.js

@@ -41,6 +41,10 @@ export class WorkspaceWorkbenchService {
             'workspace.file.direct.metadata': (data) => this.directFileMetadata(record(data)),
             'workspace.files.search': (data) => this.searchFiles(record(data)),
             'workspace.files.mutate': (data) => this.mutateFile(record(data)),
+            'workspace.files.reveal': (data) => {
+                const input = record(data);
+                return this.options.files.reveal(this.options.requireWorkspace(input.workspaceId), input);
+            },
             'workspace.content.search': (data) => this.searchContent(record(data)),
             'workspace.symbol.prepare': (data) => this.prepareSymbolIndex(record(data)),
             'workspace.symbol.definition': (data) => this.symbolDefinition(record(data)),

package/dist/workspace.js

@@ -1084,6 +1084,15 @@ async function resolveWorkspaceEntryMetadata(root, requestedPath) {
     const metadata = await lstat(candidate);
     return { path: candidate, metadata };
 }
+export async function resolveWorkspaceFileManagerTarget(workspaceRoot, requestedPath) {
+    const root = await resolveRegisteredWorkspaceRoot(workspaceRoot);
+    const entry = await resolveWorkspaceEntryMetadata(root, requestedPath);
+    if (entry.metadata.isDirectory())
+        return { path: entry.path, kind: 'DIRECTORY' };
+    if (entry.metadata.isFile())
+        return { path: entry.path, kind: 'FILE' };
+    throw new Error('FILE_NOT_REGULAR');
+}
 async function inspectWorkspaceIndexEntry(root, requestedPath, name, excludes) {
     try {
         const entry = await resolveWorkspaceEntryMetadata(root, requestedPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.11.23",
+  "version": "0.11.25",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -37,10 +37,10 @@
     "playwright": "1.62.1",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.11.23",
-    "@myagentroam/code-navigation": "0.11.0",
-    "@myagentroam/protocol": "0.11.23",
-    "@myagentroam/marctl": "0.11.0"
+    "@myagentroam/agent": "0.11.25",
+    "@myagentroam/protocol": "0.11.25",
+    "@myagentroam/marctl": "0.11.1",
+    "@myagentroam/code-navigation": "0.11.0"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"