@myagentroam/node 0.13.15 → 0.13.16

package/dist/application/execution-lifecycle.js

@@ -5,20 +5,16 @@ export class ExecutionLifecycle {
     continuous;
     goal;
     usage;
-    goalMcp;
-    scheduleMcp;
-    notificationMcp;
+    runtime;
     events;
     upgrade;
-    constructor(databaseAvailable, scheduled, continuous, goal, usage, goalMcp, scheduleMcp, notificationMcp, events, upgrade) {
+    constructor(databaseAvailable, scheduled, continuous, goal, usage, runtime, events, upgrade) {
         this.databaseAvailable = databaseAvailable;
         this.scheduled = scheduled;
         this.continuous = continuous;
         this.goal = goal;
         this.usage = usage;
-        this.goalMcp = goalMcp;
-        this.scheduleMcp = scheduleMcp;
-        this.notificationMcp = notificationMcp;
+        this.runtime = runtime;
         this.events = events;
         this.upgrade = upgrade;
     }
@@ -28,9 +24,7 @@ export class ExecutionLifecycle {
         this.continuous.runTerminated(run.sessionId);
     }
     revokeMcps(executionId) {
-        this.goalMcp.revoke(executionId);
-        this.scheduleMcp.revoke(executionId);
-        this.notificationMcp.revoke(executionId);
+        this.runtime.revokeExecutionMcps(executionId);
     }
     release(executionId) {
         this.usage.release(executionId);

package/dist/connector.js

@@ -296,7 +296,7 @@ export class NodeConnector {
     commandStates = new CommandStateStore();
     goalRuntime = new GoalRuntime(() => undefined);
     sessionScheduleService;
-    goalMcpBridge = new GoalMcpBridge(this.goalRuntime, (sessionId) => this.goalCoordinator.changed(sessionId));
+    goalMcpBridge = new GoalMcpBridge(this.goalRuntime, (sessionId) => this.goalCoordinator.changed(sessionId), (capability) => this.runtime.resolveMcpExecution(capability)?.sessionId);
     scheduleMcpBridge = new ScheduleMcpBridge(() => {
         if (this.database === undefined)
             throw new Error('NODE_DATABASE_UNAVAILABLE');
@@ -308,11 +308,12 @@ export class NodeConnector {
                 session: this.sessionPresentationService.present(session)
             });
         this.scheduledSessions.changed();
-    }, (sessionId, proposalId) => this.scheduledSessions.proposalCreated(sessionId, proposalId), (input) => {
+    }, (sessionId, proposalId) => this.scheduledSessions.proposalCreated(sessionId, proposalId), (capability) => this.runtime.resolveMcpExecution({ ...capability, userId: capability.actorUserId })
+        ?.sessionId, (input) => {
         if (this.sessionScheduleService === undefined)
             throw new Error('SCHEDULE_SERVICE_UNAVAILABLE');
         return this.sessionScheduleService.createFromMcp(input);
-    }, (sessionId) => this.runtime.getAgentSession(sessionId)?.externalSessionId ?? sessionId);
+    });
     notificationMcpBridge = new NotificationMcpBridge((capability) => resolveNotificationCapability(this.runtime, capability), (request) => this.mailNotificationControl.request(request), {
         supported: () => this.mailNotificationControl.supportsChannels(),
         send: (request) => this.mailNotificationControl.notification(request)
@@ -889,7 +890,6 @@ export class NodeConnector {
             migrateAttachments: (previousId, nextId) => this.runAttachmentService.migrateSession(previousId, nextId),
             migrateGoal: (previousId, nextId) => {
                 this.goalCoordinator.migrateSession(previousId, nextId);
-                this.goalMcpBridge.migrateSession(previousId, nextId);
             },
             migrateQueue: (previousId, nextId) => this.continuousRunCoordinator.migrateSession(previousId, nextId),
             migrateRunnerState: (previousId, nextId) => {
@@ -1272,7 +1272,6 @@ export class NodeConnector {
                 this.mailNotificationControl.disconnected();
                 this.marctlExecutionCredentials.disconnected();
                 this.upgradeCredentials.disconnect();
-                this.notificationMcpBridge.revokeAll();
                 this.terminalChannel.disconnect();
                 if (code === 4000 && reason === 'NODE_CONNECTION_REPLACED')
                     nodeLog('node.connection.replaced', {
@@ -1488,7 +1487,7 @@ export class NodeConnector {
                 {}),
             emitNotification: (payload) => this.emitWorkbenchEvent('conversation', payload)
         });
-        this.executionLifecycle = new ExecutionLifecycle(() => this.database !== undefined, this.scheduledSessions, this.continuousRunCoordinator, this.goalCoordinator, this.modelUsage, this.goalMcpBridge, this.scheduleMcpBridge, this.notificationMcpBridge, this.runEventBridge, this.upgradeCoordinator);
+        this.executionLifecycle = new ExecutionLifecycle(() => this.database !== undefined, this.scheduledSessions, this.continuousRunCoordinator, this.goalCoordinator, this.modelUsage, this.runtime, this.runEventBridge, this.upgradeCoordinator);
         // Register public operations only after domain workflows are connected.
         this.runnerService = new RunnerService(requireDatabase, () => this.capabilities, this.runners, this.runnerUsageReader);
         this.workbenchManifestService = new WorkbenchManifestService({

package/dist/marctl/package.json

@@ -1 +1 @@
-{"type":"module","version":"0.13.15"}
+{"type":"module","version":"0.13.16"}

package/dist/mcp/capability-token.js

@@ -0,0 +1,38 @@
+import { createHmac, randomBytes, timingSafeEqual } from 'node:crypto';
+/** Signs process-local MCP claims; authorization and revocation belong to the Execution owner. */
+export class McpCapabilityToken {
+    purpose;
+    schema;
+    key;
+    constructor(purpose, schema, key = randomBytes(32)) {
+        this.purpose = purpose;
+        this.schema = schema;
+        this.key = key;
+    }
+    sign(claims) {
+        const body = `v1.${Buffer.from(JSON.stringify(claims)).toString('base64url')}`;
+        return `${body}.${this.signature(body).toString('base64url')}`;
+    }
+    verify(token) {
+        if (typeof token !== 'string' || token.length > 8192)
+            return undefined;
+        const match = /^(v1\.[A-Za-z0-9_-]+)\.([A-Za-z0-9_-]{43})$/u.exec(token);
+        if (match === null)
+            return undefined;
+        const expected = this.signature(match[1]);
+        const received = Buffer.from(match[2], 'base64url');
+        if (expected.length !== received.length || !timingSafeEqual(expected, received))
+            return undefined;
+        try {
+            const value = JSON.parse(Buffer.from(match[1].slice(3), 'base64url').toString('utf8'));
+            const parsed = this.schema.safeParse(value);
+            return parsed.success ? parsed.data : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    signature(body) {
+        return createHmac('sha256', this.key).update(`${this.purpose}\0${body}`).digest();
+    }
+}

package/dist/remote-desktop/windows-remote-desktop-runtime.js

@@ -78,7 +78,7 @@ async function queryScreens(signal) {
     });
     return JSON.parse(stdout);
 }
-/** Owns the current interactive Windows GUI layout and one shared UltraVNC backend. */
+/** Owns serialized Windows GUI layout discovery and one shared UltraVNC backend. */
 export class WindowsRemoteDesktopRuntime {
     options;
     #pool;
@@ -87,6 +87,7 @@ export class WindowsRemoteDesktopRuntime {
     #signature = '';
     #revision = 0;
     #disposed = false;
+    #refreshTail = Promise.resolve();
     constructor(options) {
         this.options = options;
         this.#pool = new TigerVncBackendPool((signal, onUnexpectedExit) => UltraVncManagedProcess.start({ binaryPath: options.binaryPath, onUnexpectedExit }, signal), () => options.fence('DESKTOP_BACKEND_CLOSED'));
@@ -96,7 +97,12 @@ export class WindowsRemoteDesktopRuntime {
         await runtime.refresh(signal);
         return runtime;
     }
-    async refresh(signal) {
+    refresh(signal) {
+        const result = this.#refreshTail.then(() => this.#refresh(signal));
+        this.#refreshTail = result.catch(() => { });
+        return result;
+    }
+    async #refresh(signal) {
         const screens = (await queryScreens(signal)).sort((left, right) => left.name.localeCompare(right.name));
         const signature = JSON.stringify(screens.map((screen) => [
             screen.name,

package/dist/runtime-state.js

@@ -711,6 +711,30 @@ export class NodeRuntimeState {
         const canonical = this.executions.get(id)?.runId ?? id;
         return this.runs.get(canonical);
     }
+    /** Resolves signed MCP scope against live execution ownership, never a token registry. */
+    resolveMcpExecution(scope) {
+        const execution = this.executions.get(scope.executionId);
+        const run = execution === undefined ? undefined : this.runs.get(execution.runId);
+        const session = this.getAgentSession(scope.sessionId);
+        if (execution === undefined ||
+            execution.mcpRevoked === true ||
+            terminalExecution(execution.status) ||
+            this.isExecutionInterruptRequested(execution.id) ||
+            run === undefined ||
+            (run.status !== 'STARTING' && run.status !== 'RUNNING') ||
+            this.currentExecutionId(run.id) !== execution.id ||
+            session === undefined ||
+            session.id !== run.sessionId ||
+            (scope.workspaceId !== undefined && scope.workspaceId !== run.workspaceId) ||
+            (scope.userId !== undefined && scope.userId !== run.initiatedByUserId))
+            return undefined;
+        return run;
+    }
+    revokeExecutionMcps(executionId) {
+        const execution = this.executions.get(executionId);
+        if (execution !== undefined)
+            this.executions.set(executionId, { ...execution, mcpRevoked: true });
+    }
     /** Only the current execution may replace an active Run's ephemeral metrics. */
     updateRunPerformance(id, performance) {
         const run = this.getRun(id);

package/dist/service/goal-mcp-bridge.js

@@ -1,23 +1,34 @@
 import { NODE_MCP } from '../mcp/naming.js';
-import { randomBytes, randomUUID } from 'node:crypto';
+import { McpCapabilityToken } from '../mcp/capability-token.js';
+import { randomUUID } from 'node:crypto';
+import { z } from 'zod';
 import { existsSync } from 'node:fs';
 import { createServer } from 'node:net';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { unlink } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
+const capabilitySchema = z.object({
+    executionId: z.string(),
+    sessionId: z.string(),
+    goalId: z.string(),
+    revision: z.number().int().nonnegative()
+});
+/** Owns Goal IPC and revision validation, not Execution authorization or Session aliases. */
 export class GoalMcpBridge {
     goals;
     changed;
-    capabilities = new Map();
+    resolveExecution;
+    tokens = new McpCapabilityToken(NODE_MCP.goal.name, capabilitySchema);
     sockets = new Set();
     endpoint = process.platform === 'win32'
         ? `\\\\.\\pipe\\mar-goal-${process.pid}-${randomUUID()}`
         : join(tmpdir(), `mar-goal-${process.pid}-${randomUUID()}.sock`);
     listening;
-    constructor(goals, changed) {
+    constructor(goals, changed, resolveExecution) {
         this.goals = goals;
         this.changed = changed;
+        this.resolveExecution = resolveExecution;
     }
     listen() {
         this.listening ??= new Promise((resolve, reject) => {
@@ -30,8 +41,7 @@ export class GoalMcpBridge {
     async prepare(capability) {
         await this.listen();
         const args = goalMcpStdioArgs();
-        const token = randomBytes(32).toString('base64url');
-        this.capabilities.set(token, capability);
+        const token = this.tokens.sign(capability);
         return {
             name: NODE_MCP.goal.name,
             origin: 'BUILTIN',
@@ -53,7 +63,6 @@ export class GoalMcpBridge {
         if (this.listening === undefined)
             return;
         const server = await this.listening;
-        this.capabilities.clear();
         const closed = new Promise((resolve, reject) => server.close((error) => (error === undefined ? resolve() : reject(error))));
         for (const socket of this.sockets)
             socket.destroy();
@@ -61,18 +70,6 @@ export class GoalMcpBridge {
         if (process.platform !== 'win32')
             await unlink(this.endpoint).catch(() => undefined);
     }
-    revoke(executionId) {
-        for (const [token, capability] of this.capabilities)
-            if (capability.executionId === executionId)
-                this.capabilities.delete(token);
-    }
-    migrateSession(previousId, nextId) {
-        if (previousId === nextId)
-            return;
-        for (const [token, capability] of this.capabilities)
-            if (capability.sessionId === previousId)
-                this.capabilities.set(token, { ...capability, sessionId: nextId });
-    }
     handle(socket) {
         this.sockets.add(socket);
         socket.once('close', () => this.sockets.delete(socket));
@@ -90,9 +87,13 @@ export class GoalMcpBridge {
     async respond(socket, body) {
         try {
             const request = JSON.parse(body);
-            const capability = typeof request.token === 'string' ? this.capabilities.get(request.token) : undefined;
-            if (capability === undefined)
+            const claims = this.tokens.verify(request.token);
+            if (claims === undefined)
                 throw new Error('GOAL_CAPABILITY_INVALID');
+            const sessionId = this.resolveExecution(claims);
+            if (sessionId === undefined)
+                throw new Error('GOAL_CAPABILITY_STALE');
+            const capability = { ...claims, sessionId };
             const current = this.current(capability);
             if (request.tool === NODE_MCP.goal.tools.get) {
                 socket.end(`${JSON.stringify({ result: current })}\n`);

package/dist/service/notification-mcp-bridge.js

@@ -1,5 +1,7 @@
 import { NODE_MCP } from '../mcp/naming.js';
-import { randomBytes, randomUUID } from 'node:crypto';
+import { McpCapabilityToken } from '../mcp/capability-token.js';
+import { randomUUID } from 'node:crypto';
+import { z } from 'zod';
 import { existsSync } from 'node:fs';
 import { unlink } from 'node:fs/promises';
 import { createServer } from 'node:net';
@@ -8,11 +10,19 @@ import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { notificationInputSchema, notificationChannelsRequestSchema, mailNotificationRequestSchema } from '@myagentroam/protocol';
 import { sessionGroup } from '../session/session-presentation-service.js';
+const capabilitySchema = z.object({
+    executionId: z.string(),
+    sessionId: z.string(),
+    workspaceId: z.string(),
+    userId: z.number().int().positive(),
+    source: z.enum(['MANUAL', 'SCHEDULED'])
+});
+/** Owns notification IPC and signed scope; live authorization belongs to Runtime and Server. */
 export class NotificationMcpBridge {
     resolve;
     send;
     channels;
-    capabilities = new Map();
+    tokens = new McpCapabilityToken(NODE_MCP.notification.name, capabilitySchema);
     sockets = new Set();
     endpoint = process.platform === 'win32'
         ? `\\\\.\\pipe\\mar-notification-${process.pid}-${randomUUID()}`
@@ -26,9 +36,8 @@ export class NotificationMcpBridge {
     async prepare(capability) {
         await this.listen();
         const args = notificationMcpStdioArgs();
-        const token = randomBytes(32).toString('base64url');
+        const token = this.tokens.sign(capability);
         const notificationChannels = this.channels?.supported() === true;
-        this.capabilities.set(token, capability);
         return {
             name: NODE_MCP.notification.name,
             origin: 'BUILTIN',
@@ -49,19 +58,10 @@ export class NotificationMcpBridge {
             }
         };
     }
-    revoke(executionId) {
-        for (const [token, capability] of this.capabilities)
-            if (capability.executionId === executionId)
-                this.capabilities.delete(token);
-    }
-    revokeAll() {
-        this.capabilities.clear();
-    }
     async close() {
         if (this.listening === undefined)
             return;
         const server = await this.listening;
-        this.revokeAll();
         const closed = new Promise((resolve, reject) => server.close((error) => (error === undefined ? resolve() : reject(error))));
         for (const socket of this.sockets)
             socket.destroy();
@@ -100,7 +100,7 @@ export class NotificationMcpBridge {
     async respond(socket, body) {
         try {
             const request = JSON.parse(body);
-            const capability = typeof request['token'] === 'string' ? this.capabilities.get(request['token']) : undefined;
+            const capability = this.tokens.verify(request['token']);
             if (capability === undefined)
                 throw new Error('MAIL_CAPABILITY_INVALID');
             const current = this.resolve(capability);
@@ -171,15 +171,10 @@ export class NotificationMcpBridge {
     }
 }
 export function resolveNotificationCapability(runtime, capability) {
-    const run = runtime.getRun(capability.executionId);
+    const run = runtime.resolveMcpExecution(capability);
     const session = runtime.getAgentSession(capability.sessionId);
     if (run === undefined ||
         session === undefined ||
-        ['SUCCEEDED', 'FAILED', 'INTERRUPTED'].includes(run.status) ||
-        runtime.currentExecutionId(run.id) !== capability.executionId ||
-        run.sessionId !== session.id ||
-        run.workspaceId !== capability.workspaceId ||
-        run.initiatedByUserId !== capability.userId ||
         (run.source === 'SCHEDULED' ? 'SCHEDULED' : 'MANUAL') !== capability.source)
         return undefined;
     return { ...capability, sessionId: session.id, sessionGroup: sessionGroup(session) };

package/dist/service/schedule-mcp-bridge.js

@@ -1,35 +1,45 @@
 import { NODE_MCP } from '../mcp/naming.js';
-import { randomBytes, randomUUID } from 'node:crypto';
+import { McpCapabilityToken } from '../mcp/capability-token.js';
+import { randomUUID } from 'node:crypto';
+import { z } from 'zod';
 import { existsSync } from 'node:fs';
 import { unlink } from 'node:fs/promises';
 import { createServer } from 'node:net';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+const capabilitySchema = z.object({
+    executionId: z.string(),
+    sessionId: z.string(),
+    workspaceId: z.string().optional(),
+    taskId: z.string().optional(),
+    revision: z.number().int().nonnegative().optional(),
+    actorUserId: z.number().int().positive()
+});
+/** Owns task IPC, revision checks and private credential renewal after successful edits. */
 export class ScheduleMcpBridge {
     store;
     changed;
     proposed;
+    resolveExecution;
     create;
-    resolveSessionId;
-    #capabilities = new Map();
+    #tokens = new McpCapabilityToken(NODE_MCP.schedule.name, capabilitySchema);
     #sockets = new Set();
     #endpoint = process.platform === 'win32'
         ? `\\\\.\\pipe\\mar-schedule-${process.pid}-${randomUUID()}`
         : join(tmpdir(), `mar-schedule-${process.pid}-${randomUUID()}.sock`);
     #listening;
-    constructor(store, changed, proposed, create, resolveSessionId) {
+    constructor(store, changed, proposed, resolveExecution, create) {
         this.store = store;
         this.changed = changed;
         this.proposed = proposed;
+        this.resolveExecution = resolveExecution;
         this.create = create;
-        this.resolveSessionId = resolveSessionId;
     }
     async prepare(capability) {
         await this.#listen();
         const args = scheduleMcpStdioArgs();
-        const token = randomBytes(32).toString('base64url');
-        this.#capabilities.set(token, capability);
+        const token = this.#tokens.sign(capability);
         return {
             name: NODE_MCP.schedule.name,
             origin: 'BUILTIN',
@@ -48,16 +58,10 @@ export class ScheduleMcpBridge {
             }
         };
     }
-    revoke(executionId) {
-        for (const [token, capability] of this.#capabilities)
-            if (capability.executionId === executionId)
-                this.#capabilities.delete(token);
-    }
     async close() {
         if (this.#listening === undefined)
             return;
         const server = await this.#listening;
-        this.#capabilities.clear();
         const closed = new Promise((resolve, reject) => server.close((error) => (error === undefined ? resolve() : reject(error))));
         for (const socket of this.#sockets)
             socket.destroy();
@@ -91,19 +95,24 @@ export class ScheduleMcpBridge {
     async #respond(socket, body) {
         try {
             const request = JSON.parse(body);
-            const capability = typeof request.token === 'string' ? this.#capabilities.get(request.token) : undefined;
+            const capability = this.#tokens.verify(request.token);
             if (capability === undefined)
                 throw new Error('SCHEDULE_CAPABILITY_INVALID');
-            const sessionId = this.resolveSessionId?.(capability.sessionId) ?? capability.sessionId;
-            const task = this.store().get(sessionId);
-            if ((task === undefined && capability.taskId !== undefined) ||
-                (task !== undefined &&
-                    (task.id !== capability.taskId || task.revision !== capability.revision)))
+            const sessionId = this.resolveExecution(capability);
+            if (sessionId === undefined)
                 throw new Error('SCHEDULE_CAPABILITY_STALE');
+            const task = this.store().get(sessionId);
             if (request.tool === NODE_MCP.schedule.tools.get) {
+                // A create may commit before stdio receives the token that binds its task identity.
+                if (capability.taskId !== undefined && task?.id !== capability.taskId)
+                    throw new Error('SCHEDULE_CAPABILITY_STALE');
                 socket.end(`${JSON.stringify({ result: task ?? null })}\n`);
                 return;
             }
+            if ((task === undefined && capability.taskId !== undefined) ||
+                (task !== undefined &&
+                    (task.id !== capability.taskId || task.revision !== capability.revision)))
+                throw new Error('SCHEDULE_CAPABILITY_STALE');
             if (request.tool === NODE_MCP.schedule.tools.create) {
                 if (task !== undefined)
                     throw new Error('SCHEDULE_ALREADY_EXISTS');
@@ -114,19 +123,19 @@ export class ScheduleMcpBridge {
                     this.create === undefined)
                     throw new Error('SCHEDULE_INVALID');
                 const created = await this.create({
-                    sessionId: capability.sessionId,
+                    sessionId,
                     workspaceId: capability.workspaceId,
                     actorUserId: capability.actorUserId,
                     objective: args.objective,
                     cron: args.cron
                 });
-                this.#capabilities.set(request.token, {
+                const token = this.#tokens.sign({
                     ...capability,
                     sessionId: created.sessionId,
                     taskId: created.id,
                     revision: created.revision
                 });
-                socket.end(`${JSON.stringify({ result: created })}\n`);
+                socket.end(`${JSON.stringify({ result: created, token })}\n`);
                 return;
             }
             if (request.tool !== NODE_MCP.schedule.tools.update)
@@ -140,12 +149,12 @@ export class ScheduleMcpBridge {
                 socket.end(`${JSON.stringify({ result })}\n`);
             }
             else {
-                this.#capabilities.set(request.token, {
+                const token = this.#tokens.sign({
                     ...capability,
                     revision: result.revision
                 });
                 this.changed(task.sessionId);
-                socket.end(`${JSON.stringify({ result })}\n`);
+                socket.end(`${JSON.stringify({ result, token })}\n`);
             }
         }
         catch (error) {

package/dist/service/schedule-mcp-stdio.js

@@ -4,9 +4,11 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
 const endpoint = process.env['MAR_SCHEDULE_MCP_ENDPOINT'];
-const token = process.env['MAR_SCHEDULE_MCP_TOKEN'];
+let token = process.env['MAR_SCHEDULE_MCP_TOKEN'];
 if (endpoint === undefined || token === undefined)
     throw new Error('SCHEDULE_CAPABILITY_INVALID');
+// This client owns one rotating credential; consume renewals before dispatching later calls.
+let previousRequest = Promise.resolve();
 const server = new McpServer({ name: NODE_MCP.schedule.name, version: NODE_MCP_VERSION });
 const scopeNote = 'Scope is limited to the MAR scheduled task managed by Node for this conversation; ' +
     'it does not cover repository, CI, system cron, or other timers.';
@@ -15,7 +17,7 @@ const objectiveDescription = 'Task body for one scheduled run in this conversati
 server.registerTool(NODE_MCP.schedule.tools.get, {
     description: 'Read the MAR scheduled task bound to this MAR-managed Workspace conversation, or null if none exists. ' +
         scopeNote
-}, async () => result(await request(NODE_MCP.schedule.tools.get, {})));
+}, async (extra) => result(await request(NODE_MCP.schedule.tools.get, {}, extra.signal)));
 server.registerTool(NODE_MCP.schedule.tools.create, {
     description: 'Create the MAR scheduled task for this MAR-managed Workspace conversation. MAR runs it in this conversation for each admitted trigger using the connected Node time zone. ' +
         scopeNote,
@@ -27,7 +29,7 @@ server.registerTool(NODE_MCP.schedule.tools.create, {
             .max(64)
             .describe('Five-field cron expression interpreted in the connected MAR Node time zone. It defines the schedule separately from the per-run task body.')
     }
-}, async (args) => result(await request(NODE_MCP.schedule.tools.create, args)));
+}, async (args, extra) => result(await request(NODE_MCP.schedule.tools.create, args, extra.signal)));
 server.registerTool(NODE_MCP.schedule.tools.update, {
     description: 'Update the MAR scheduled task for this MAR-managed Workspace conversation. MAR runs the saved objective in this conversation for each admitted trigger using the connected Node time zone. ' +
         scopeNote,
@@ -40,14 +42,24 @@ server.registerTool(NODE_MCP.schedule.tools.update, {
             .describe('Replacement five-field cron expression in the connected MAR Node time zone.')
             .optional()
     }
-}, async (args) => result(await request(NODE_MCP.schedule.tools.update, args)));
+}, async (args, extra) => result(await request(NODE_MCP.schedule.tools.update, args, extra.signal)));
 await server.connect(new StdioServerTransport());
-function request(tool, args) {
+function request(tool, args, signal) {
+    const operation = previousRequest.then(() => exchange(tool, args, signal));
+    previousRequest = operation.catch(() => undefined);
+    return operation;
+}
+function exchange(tool, args, signal) {
+    if (signal.aborted)
+        return Promise.reject(new Error('SCHEDULE_CALL_CANCELLED: The schedule call was cancelled before dispatch.'));
     return new Promise((resolve, reject) => {
         const socket = connect(endpoint);
+        const abort = () => socket.destroy(new Error('SCHEDULE_DELIVERY_UNCERTAIN: The schedule call was cancelled after dispatch; its result is uncertain.'));
+        signal.addEventListener('abort', abort, { once: true });
+        socket.once('close', () => signal.removeEventListener('abort', abort));
         let body = '';
         socket.setEncoding('utf8');
-        socket.once('connect', () => socket.end(`${JSON.stringify({ token, tool, arguments: args })}\n`));
+        socket.once('connect', () => socket.write(`${JSON.stringify({ token, tool, arguments: args })}\n`));
         socket.on('data', (chunk) => (body += chunk));
         socket.once('error', reject);
         socket.once('end', () => {
@@ -55,11 +67,16 @@ function request(tool, args) {
                 const payload = JSON.parse(body);
                 if (payload.error !== undefined)
                     reject(new Error(payload.error));
-                else
+                else {
+                    // Credential renewal stays inside IPC; model-visible results never contain tokens.
+                    if (typeof payload.token === 'string')
+                        token = payload.token;
                     resolve(payload.result);
+                }
             }
-            catch (error) {
-                reject(error);
+            catch {
+                // JSON diagnostics may include a partially received private renewal credential.
+                reject(new Error('SCHEDULE_IPC_RESPONSE_INVALID: The schedule service returned an invalid response.'));
             }
         });
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.13.15",
+  "version": "0.13.16",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/myagentroam/mar.git",
@@ -49,14 +49,14 @@
     "turndown-plugin-gfm": "^1.0.2",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.13.15",
-    "@myagentroam/protocol": "0.13.15"
+    "@myagentroam/protocol": "0.13.16",
+    "@myagentroam/agent": "0.13.16"
   },
   "devDependencies": {
     "@types/turndown": "^5.0.6",
     "@types/ws": "^8.18.1",
-    "@myagentroam/marctl": "0.13.15",
-    "@myagentroam/code-navigation": "0.11.1"
+    "@myagentroam/code-navigation": "0.11.1",
+    "@myagentroam/marctl": "0.13.16"
   },
   "exports": {
     "./config": {