@myagentroam/node 0.10.40 → 0.10.41

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

@@ -1,3 +1,4 @@
+import { NODE_MCP } from '../../mcp/naming.js';
 import { nodeExecutionEnvironment } from '../../node-execution-environment.js';
 import { extractId } from '../../util/runner-native-session-parsers.js';
 import { parseSecretEnvironment } from '../../util/secret-environment.js';
@@ -204,8 +205,8 @@ export class CodexManagedRunController {
         }
         if (notification.requestId !== undefined &&
             notification.method === 'mcpServer/elicitation/request' &&
-            ((activeRun.goalMcp === true && params.serverName === 'myagentroam_goal') ||
-                (activeRun.scheduleMcp === true && params.serverName === 'mar_schedule')) &&
+            ((activeRun.goalMcp === true && params.serverName === NODE_MCP.goal.name) ||
+                (activeRun.scheduleMcp === true && params.serverName === NODE_MCP.schedule.name)) &&
             isPlainRecord(params._meta) &&
             params._meta.codex_approval_kind === 'mcp_tool_call') {
             this.runner.respond(notification.requestId, {
@@ -559,11 +560,9 @@ export class CodexManagedRunController {
         const { runId, sessionId, input, cwd } = payload;
         let attachments;
         let secretEnvironment;
-        let mcpSecretEnvironment;
         try {
             attachments = this.host.parseAttachments(payload.attachments);
             secretEnvironment = parseSecretEnvironment(payload.secretEnvironment);
-            mcpSecretEnvironment = parseSecretEnvironment(payload.mcpSecretEnvironment);
         }
         catch (error) {
             this.emitError(runId, error, 'CODEX_RUN_FAILED');
@@ -615,9 +614,8 @@ export class CodexManagedRunController {
                 : {}),
             mcpServers: this.runner.mcpConfiguration(payload.mcpInstallations, {
                 ...secretEnvironment,
-                ...mcpSecretEnvironment,
                 MAR_USERNAME: secretEnvironment['MAR_USERNAME'] ?? ''
-            })
+            }, payload.executionMcpServers)
         }, attachments);
     }
     async run(payload, attachments) {
@@ -733,10 +731,10 @@ export class CodexManagedRunController {
     }
 }
 function hasGoalMcp(value) {
-    return isPlainRecord(value) && isPlainRecord(value.myagentroam_goal);
+    return isPlainRecord(value) && isPlainRecord(value[NODE_MCP.goal.name]);
 }
 function hasScheduleMcp(value) {
-    return isPlainRecord(value) && isPlainRecord(value.mar_schedule);
+    return isPlainRecord(value) && isPlainRecord(value[NODE_MCP.schedule.name]);
 }
 function codexOutputTokens(value) {
     if (!isPlainRecord(value) ||

package/dist/runner/codex-runner.js

@@ -215,8 +215,8 @@ export class CodexRunner extends AbstractRunner {
     serviceTier() {
         return this.fastEnabled ? 'fast' : undefined;
     }
-    mcpConfiguration(raw, secrets) {
-        const servers = super.mcpConfiguration(raw, secrets);
+    mcpConfiguration(raw, secrets, executionServers = []) {
+        const servers = super.mcpConfiguration(raw, secrets, executionServers);
         return Object.fromEntries(servers.map((server) => [
             server.name,
             server.transport === 'STDIO'

package/dist/runner/mar-agent/computer-use-skill.js

@@ -1,13 +1,16 @@
+import { NODE_COMPUTER_TOOL_NAME } from '../../mcp/naming.js';
 export const computerUseHostSkill = {
     name: 'computer-use',
-    description: 'Use when the user asks to operate or verify a real desktop GUI through mcp__computer__exec. Load before the first desktop action.',
-    requiredTools: ['mcp__computer__exec'],
+    description: 'Use when the user asks to operate or verify a real desktop GUI through ' +
+        NODE_COMPUTER_TOOL_NAME +
+        '. Load before the first desktop action.',
+    requiredTools: [NODE_COMPUTER_TOOL_NAME],
     load: async () => computerUseSkill()
 };
 export function computerUseSkill() {
     return `## Operating the desktop
 
-Use \`mcp__computer__exec\` only for user-authorized interaction with applications on the current desktop, or when the requested result can only be verified through the real GUI. Prefer ordinary workspace and shell tools for file and code work that does not require the GUI.
+Use \`${NODE_COMPUTER_TOOL_NAME}\` only for user-authorized interaction with applications on the current desktop, or when the requested result can only be verified through the real GUI. Prefer ordinary workspace and shell tools for file and code work that does not require the GUI.
 
 ### Observe before acting
 - Start with one observation-only call using empty \`code\`. Do not repeat observation while the returned state is still current and the next steps do not depend on new visual information.

package/dist/runner/mar-agent/computer-use.js

@@ -1,3 +1,4 @@
+import { NODE_COMPUTER_TOOL_NAME } from '../../mcp/naming.js';
 import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { access, mkdtemp, rm, writeFile } from 'node:fs/promises';
@@ -7,7 +8,7 @@ import { createInterface } from 'node:readline';
 import { terminateProcessTree } from '../../process-tree.js';
 import { ComputerUseControlIndicator } from './computer-use-indicator.js';
 import { PYTHON_PROBE_SOURCE } from './computer-use-probe.js';
-const TOOL_NAME = 'mcp__computer__exec';
+const TOOL_NAME = NODE_COMPUTER_TOOL_NAME;
 const DEFAULT_TIMEOUT_MS = 30_000;
 const MAX_TIMEOUT_MS = 120_000;
 const MAX_CODE_BYTES = 1024 * 1024;

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

@@ -1,3 +1,4 @@
+import { NODE_MCP } from '../../mcp/naming.js';
 import { computerUseHostSkill } from './computer-use-skill.js';
 import { marctlExecutionEnvironment, marctlHostSkill } from './marctl-skill.js';
 import { compactRuntimeConfigurations, marAgentCompactExtensionSource, updateMarAgentCompactState } from './compact-extensions.js';
@@ -185,12 +186,10 @@ export class MarAgentManagedRunController {
         let secretEnvironment;
         try {
             secretEnvironment = parseSecretEnvironment(payload.secretEnvironment);
-            const mcpSecretEnvironment = parseSecretEnvironment(payload.mcpSecretEnvironment);
             mcpServers = this.#resolveMcpServers(payload.mcpInstallations, {
                 ...secretEnvironment,
-                ...mcpSecretEnvironment,
                 MAR_USERNAME: secretEnvironment['MAR_USERNAME'] ?? ''
-            });
+            }, payload.executionMcpServers);
             images = parseRunnerImageAttachments(payload.attachments);
         }
         catch {
@@ -350,7 +349,7 @@ export class MarAgentManagedRunController {
             controller.signal.throwIfAborted();
             const userTools = executionMcpLease?.pool.definitions() ?? [];
             const nodeTools = computerUseBinding?.tools ?? [];
-            if (userTools.some((tool) => tool.name.startsWith('mcp__computer__')))
+            if (userTools.some((tool) => tool.name.startsWith('mcp__mar_computer__')))
                 throw new Error('MAR_AGENT_MCP_RESERVED_NAMESPACE');
             if (new Set([...userTools, ...nodeTools].map((tool) => tool.name)).size !==
                 userTools.length + nodeTools.length)
@@ -391,8 +390,8 @@ export class MarAgentManagedRunController {
                     };
                     const computer = nodeTools.map((definition) => ({
                         definition,
-                        serverId: 'computer',
-                        rawName: definition.name,
+                        serverId: NODE_MCP.computer.name,
+                        rawName: NODE_MCP.computer.tools.exec,
                         sourceIdentity: `node:${input.runId}:computer`,
                         definitionRevision: createHash('sha256')
                             .update(JSON.stringify(definition))
@@ -404,7 +403,9 @@ export class MarAgentManagedRunController {
                         revision: `${external.revision}:${input.runId}`,
                         servers: [
                             ...external.servers,
-                            ...(computer.length ? [{ id: 'computer', name: 'Computer' }] : [])
+                            ...(computer.length
+                                ? [{ id: NODE_MCP.computer.name, name: NODE_MCP.computer.name }]
+                                : [])
                         ],
                         tools: [...external.tools, ...computer]
                     };
@@ -753,10 +754,8 @@ export class MarAgentManagedRunController {
             throw error;
         }
     }
-    #resolveMcpServers(installations, environment) {
-        const servers = this.runner.mcpConfiguration(installations, environment);
-        if (servers.some((server) => server.name === 'computer'))
-            throw new Error('MAR_AGENT_MCP_RESERVED_NAMESPACE');
+    #resolveMcpServers(installations, environment, executionServers = []) {
+        const servers = this.runner.mcpConfiguration(installations, environment, executionServers);
         return servers;
     }
     #runtimeInUse(runtime) {

package/dist/runner/mar-agent/mcp-client-pool.js

@@ -1,3 +1,4 @@
+import { mcpNameAlias, NODE_MCP_CLIENT_INFO } from '../../mcp/naming.js';
 import { createHash, randomUUID } from 'node:crypto';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { getDefaultEnvironment, StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
@@ -327,7 +328,7 @@ export class MarAgentMcpClientPool {
             if (bytes > MCP_CATALOG_LIMITS.maximumBytes)
                 throw new Error('MAR_AGENT_MCP_CATALOG_LIMIT');
             for (const tool of listed.tools) {
-                const name = `mcp__${safeName(state.server.name)}__${safeName(tool.name)}`;
+                const name = `mcp__${mcpNameAlias(state.server.name)}__${mcpNameAlias(tool.name)}`;
                 if (tools.has(name))
                     throw new Error('MAR_AGENT_MCP_TOOL_NAME_CONFLICT');
                 const definition = {
@@ -371,7 +372,7 @@ export class MarAgentMcpClientPool {
         throw new Error('MAR_AGENT_MCP_CATALOG_LIMIT');
     }
     async #connect(server, cwd, options) {
-        const client = new Client({ name: 'maragent', version: '1.0.0' });
+        const client = new Client(NODE_MCP_CLIENT_INFO);
         this.#clients.push(client);
         let state;
         let initialDirty = false;
@@ -469,9 +470,6 @@ function mcpConfigurationFingerprint(servers, cwd, authorizationScope) {
     }))
         .digest('hex');
 }
-function safeName(value) {
-    return value.replace(/[^a-zA-Z0-9_-]/gu, '_').slice(0, 64);
-}
 function requireMcpOwner(owner) {
     if (owner === undefined)
         throw new Error('MAR_AGENT_MCP_SANDBOX_OWNER_REQUIRED');

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

@@ -110,7 +110,6 @@ export class OpenCodeManagedRunController {
             this.host.active.has(payload.runId))
             return;
         let environment;
-        let mcpSecretEnvironment;
         let mcp;
         let attachments;
         try {
@@ -118,12 +117,10 @@ export class OpenCodeManagedRunController {
                 ...parseSecretEnvironment(payload.secretEnvironment),
                 MAR_CTL_CONTEXT_REQUIRED: '1'
             }, { PATH: process.env['PATH'], Path: process.env['Path'] });
-            mcpSecretEnvironment = parseSecretEnvironment(payload.mcpSecretEnvironment);
             mcp = this.runner.mcpConfiguration(payload.mcpInstallations, {
                 ...environment,
-                ...mcpSecretEnvironment,
                 MAR_USERNAME: environment['MAR_USERNAME'] ?? ''
-            });
+            }, payload.executionMcpServers);
             attachments = this.host.parseAttachments(payload.attachments);
         }
         catch (error) {

package/dist/runner/opencode-runner.js

@@ -168,8 +168,8 @@ export class OpenCodeRunner extends AbstractRunner {
         }, delayMs);
         this.profileRefreshTimer.unref();
     }
-    mcpConfiguration(raw, secrets) {
-        const servers = super.mcpConfiguration(raw, secrets);
+    mcpConfiguration(raw, secrets, executionServers = []) {
+        const servers = super.mcpConfiguration(raw, secrets, executionServers);
         return Object.fromEntries(servers.map((server) => [
             server.name,
             server.transport === 'STDIO'

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

@@ -381,13 +381,14 @@ export class ContinuousRunCoordinator {
             return;
         }
         this.dispatchedExecutions.add(executionId);
+        let dispatched = false;
         try {
             // Capabilities belong to this Execution, never the Run or a claimed QueueItem.
             const executionInput = { ...pending, runId: executionId };
             const goalMcp = pending.goal === undefined ? undefined : await this.options.goalMcp?.(executionInput);
-            const scheduledMcp = await this.options.scheduledMcp?.(executionInput);
-            const mailMcp = await this.options.mailMcp?.(executionInput);
-            if (this.suspended || this.options.stopped())
+            const scheduleMcp = await this.options.scheduleMcp?.(executionInput);
+            const notificationMcp = await this.options.notificationMcp?.(executionInput);
+            if (this.suspended || this.options.stopped() || !this.dispatchedExecutions.has(executionId))
                 return;
             if (!this.goalCurrent(pending)) {
                 this.dispatchedExecutions.delete(executionId);
@@ -423,15 +424,6 @@ export class ContinuousRunCoordinator {
                     MAR_CTL_RUN_ID: active.id,
                     MAR_CTL_RUNNER: pending.runner
                 },
-                ...(goalMcp === undefined && scheduledMcp === undefined && mailMcp === undefined
-                    ? {}
-                    : {
-                        mcpSecretEnvironment: {
-                            ...goalMcp?.secrets,
-                            ...scheduledMcp?.secrets,
-                            ...mailMcp?.secrets
-                        }
-                    }),
                 ...(personalInstructions === undefined ? {} : { personalInstructions }),
                 ...(pending.marAgentModel === undefined ? {} : { marAgentModel: pending.marAgentModel }),
                 ...(pending.marAgentModels === undefined ? {} : { marAgentModels: pending.marAgentModels }),
@@ -442,17 +434,18 @@ export class ContinuousRunCoordinator {
                     ? {}
                     : { marAgentRuntimeScopeId: pending.marAgentRuntimeScopeId }),
                 ...(pending.computerUse === undefined ? {} : { computerUse: pending.computerUse }),
-                mcpInstallations: [
-                    ...this.options.mcps(pending.workspaceId),
-                    ...(goalMcp === undefined ? [] : [goalMcp.installation]),
-                    ...(scheduledMcp === undefined ? [] : [scheduledMcp.installation]),
-                    ...(mailMcp === undefined ? [] : [mailMcp.installation])
-                ]
+                mcpInstallations: this.options.mcps(pending.workspaceId),
+                executionMcpServers: [goalMcp, scheduleMcp, notificationMcp].filter((server) => server !== undefined)
             });
+            dispatched = true;
         }
         catch (error) {
             this.options.emitRun(executionId, 'run.rejected', { code: safeErrorCode(error, 'RUN_START_FAILED') }, 'FAILED');
         }
+        finally {
+            if (!dispatched)
+                this.options.revokeExecutionMcps?.(executionId);
+        }
     }
     executionStarted(executionId) {
         if (this.startedExecutions.has(executionId))

package/dist/service/{goal-mcp-server.js → goal-mcp-bridge.js}

@@ -1,3 +1,4 @@
+import { NODE_MCP } from '../mcp/naming.js';
 import { randomBytes, randomUUID } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { createServer } from 'node:net';
@@ -5,7 +6,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { unlink } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
-export class GoalMcpServer {
+export class GoalMcpBridge {
     goals;
     changed;
     capabilities = new Map();
@@ -26,22 +27,26 @@ export class GoalMcpServer {
         });
         return this.listening;
     }
-    async installation(capability) {
+    async prepare(capability) {
         await this.listen();
+        const args = goalMcpStdioArgs();
         const token = randomBytes(32).toString('base64url');
-        const secretName = `MAR_GOAL_MCP_${randomBytes(16).toString('hex').toUpperCase()}`;
         this.capabilities.set(token, capability);
         return {
-            installation: {
-                __marGoal: true,
-                serverName: 'myagentroam_goal',
-                enabled: true,
-                command: process.execPath,
-                args: goalMcpStdioArgs(),
-                endpoint: this.endpoint,
-                secretName
+            name: NODE_MCP.goal.name,
+            origin: 'BUILTIN',
+            lifecycle: 'EXECUTION',
+            transport: 'STDIO',
+            command: process.execPath,
+            args,
+            environment: {
+                MAR_GOAL_MCP_ENDPOINT: this.endpoint,
+                MAR_GOAL_MCP_TOKEN: token
             },
-            secrets: { [secretName]: token }
+            allowedToolCallers: {
+                [NODE_MCP.goal.tools.get]: ['direct', 'programmatic'],
+                [NODE_MCP.goal.tools.update]: ['direct', 'programmatic']
+            }
         };
     }
     async close() {
@@ -89,11 +94,11 @@ export class GoalMcpServer {
             if (capability === undefined)
                 throw new Error('GOAL_CAPABILITY_INVALID');
             const current = this.current(capability);
-            if (request.tool === 'mar_get_goal') {
+            if (request.tool === NODE_MCP.goal.tools.get) {
                 socket.end(`${JSON.stringify({ result: current })}\n`);
                 return;
             }
-            if (request.tool !== 'mar_update_goal')
+            if (request.tool !== NODE_MCP.goal.tools.update)
                 throw new Error('GOAL_TOOL_INVALID');
             const status = request.arguments !== null &&
                 typeof request.arguments === 'object' &&

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

@@ -1,3 +1,4 @@
+import { NODE_MCP, NODE_MCP_VERSION } from '../mcp/naming.js';
 import { connect } from 'node:net';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
@@ -6,12 +7,12 @@ const endpoint = process.env['MAR_GOAL_MCP_ENDPOINT'];
 const token = process.env['MAR_GOAL_MCP_TOKEN'];
 if (endpoint === undefined || token === undefined)
     throw new Error('GOAL_CAPABILITY_INVALID');
-const server = new McpServer({ name: 'myagentroam_goal', version: '1.0.0' });
-server.registerTool('mar_get_goal', { description: 'Get the authoritative current Goal, status, and objective.' }, async () => result(await request('mar_get_goal', {})));
-server.registerTool('mar_update_goal', {
+const server = new McpServer({ name: NODE_MCP.goal.name, version: NODE_MCP_VERSION });
+server.registerTool(NODE_MCP.goal.tools.get, { description: 'Get the authoritative current Goal, status, and objective.' }, async () => result(await request(NODE_MCP.goal.tools.get, {})));
+server.registerTool(NODE_MCP.goal.tools.update, {
     description: 'Explicitly mark the current Goal completed or blocked.',
     inputSchema: { status: z.enum(['completed', 'blocked']) }
-}, async ({ status }) => result(await request('mar_update_goal', { status })));
+}, async ({ status }) => result(await request(NODE_MCP.goal.tools.update, { status })));
 await server.connect(new StdioServerTransport());
 function request(tool, args) {
     return new Promise((resolve, reject) => {

package/dist/service/goal-runtime.js

@@ -1,3 +1,4 @@
+import { NODE_MCP } from '../mcp/naming.js';
 import { randomUUID } from 'node:crypto';
 import { parseComposerTags, serializeComposerTag } from '@myagentroam/protocol';
 export function goalUnrestrictedAccess(runner, currentAccess) {
@@ -9,47 +10,25 @@ export function goalUnrestrictedAccess(runner, currentAccess) {
         return 'bypass';
     return 'auto';
 }
-const START_OPEN = '<mar_goal_start>';
-const START_CLOSE = '</mar_goal_start>';
-const CONTINUE_OPEN = '<mar_goal_continue>';
-const CONTINUE_CLOSE = '</mar_goal_continue>';
-function goalPromptTags(text) {
-    if (text.startsWith(START_OPEN))
-        return { open: START_OPEN, close: START_CLOSE, continuation: false };
-    if (text.startsWith(CONTINUE_OPEN))
-        return { open: CONTINUE_OPEN, close: CONTINUE_CLOSE, continuation: true };
-    return undefined;
-}
 export function publicGoalStartText(objective) {
     return serializeComposerTag('mar_goal_start', { objective: objective.trim() });
 }
 export function stripGoalStartPrompt(text) {
-    const tags = goalPromptTags(text);
-    if (tags === undefined)
-        return text;
-    const close = text.lastIndexOf(tags.close);
-    return close === -1 ? '' : text.slice(close + tags.close.length).trimStart();
+    const first = parseComposerTags(text)[0];
+    return first?.kind === 'mar_goal_start' || first?.kind === 'mar_goal_continue'
+        ? text.slice(first.raw.length).trimStart()
+        : text;
 }
 export function publicGoalHistoryText(text) {
-    if (parseComposerTags(text)[0]?.kind === 'mar_restart')
+    const first = parseComposerTags(text)[0];
+    if (first?.kind === 'mar_restart')
         return serializeComposerTag('mar_restart', {});
-    const tags = goalPromptTags(text);
-    if (tags === undefined)
-        return text;
-    const safe = parseComposerTags(text)[0];
-    if (safe?.kind === 'mar_goal_start' || safe?.kind === 'mar_goal_continue')
+    if (first?.kind !== 'mar_goal_start' && first?.kind !== 'mar_goal_continue')
         return text;
-    const stripped = stripGoalStartPrompt(text);
-    if (tags.continuation)
-        return [serializeComposerTag('mar_goal_continue', {}), stripped].filter(Boolean).join('\n');
-    const close = text.lastIndexOf(tags.close);
-    const prompt = close === -1 ? text : text.slice(0, close);
-    const objectiveStart = prompt.indexOf('\nOriginal objective:\n');
-    const objectiveEnd = prompt.lastIndexOf('\n\nContinue executing this Goal across turns:');
-    const objective = objectiveStart === -1 || objectiveEnd === -1
-        ? ''
-        : prompt.slice(objectiveStart + '\nOriginal objective:\n'.length, objectiveEnd);
-    return [publicGoalStartText(objective), stripped].filter(Boolean).join('\n');
+    const marker = first.kind === 'mar_goal_start'
+        ? serializeComposerTag('mar_goal_start', { objective: first.payload.objective })
+        : serializeComposerTag('mar_goal_continue', {});
+    return [marker, stripGoalStartPrompt(text)].filter(Boolean).join('\n');
 }
 export class GoalRuntime {
     changed;
@@ -237,9 +216,15 @@ export class GoalRuntime {
         if (goal?.status !== 'active')
             throw new Error('GOAL_NOT_ACTIVE');
         const heading = kind === 'start' ? 'A Goal has started or changed.' : 'Continue the active Goal.';
-        const open = kind === 'start' ? START_OPEN : CONTINUE_OPEN;
-        const close = kind === 'start' ? START_CLOSE : CONTINUE_CLOSE;
-        return `${open}\n${heading}\n\nOriginal objective:\n${goal.objective}\n\nContinue executing this Goal across turns:\n- This Goal is owned by the Node's myagentroam_goal MCP server. Prefer myagentroam_goal.mar_update_goal to complete it. In Codex, a runner-native Goal created during this Goal may also complete it when Codex reports that native Goal complete; native Goal state from another task or turn does not count. Do not claim completion based only on a final message or an unrelated Goal.\n- Work on the objective now. If it is incomplete, use tools to finish a coherent unit or obtain decisive evidence; do not stop at an acknowledgement, status, plan, or promise.\n- Preserve the original scope. Before completion, review the full objective and verify it with real evidence, then call mar_update_goal with status=completed when available.\n- Adapt and retry after individual failures. Request blocked only after the same blocker persists for three turns and the required additional retry.\n- Use mar_get_goal only when you need to reread the authoritative objective or status.\n- After mar_update_goal confirms completed or finally blocked, summarize the completed work, verification evidence, remaining issues, and the tool-reported elapsedWallMs converted from milliseconds into a concise readable duration in your final user-facing response. If Codex instead confirms completion with its native Goal, summarize the work without claiming a MAR elapsedWallMs value. Name whether the Goal completed or is finally blocked. MAR elapsedWallMs includes waiting and retries through the status update, not tool execution time or the final response. If blocked returns active for the required retry, continue work instead of claiming a final summary.\n${close}${goal.inputTags ? `\n${goal.inputTags}` : ''}`;
+        const instruction = `${heading}
+
+Continue executing this Goal across turns:
+- This Goal is owned by the Node's ${NODE_MCP.goal.name} MCP server. Prefer ${NODE_MCP.goal.name}.${NODE_MCP.goal.tools.update} to complete it. In Codex, a runner-native Goal created during this Goal may also complete it when Codex reports that native Goal complete; native Goal state from another task or turn does not count. Do not claim completion based only on a final message or an unrelated Goal.\n- Work on the objective now. If it is incomplete, use tools to finish a coherent unit or obtain decisive evidence; do not stop at an acknowledgement, status, plan, or promise.\n- Preserve the original scope. Before completion, review the full objective and verify it with real evidence, then call ${NODE_MCP.goal.tools.update} with status=completed when available.\n- Adapt and retry after individual failures. Request blocked only after the same blocker persists for three turns and the required additional retry.\n- Use ${NODE_MCP.goal.tools.get} only when you need to reread the authoritative objective or status.\n- After ${NODE_MCP.goal.tools.update} confirms completed or finally blocked, summarize the completed work, verification evidence, remaining issues, and the tool-reported elapsedWallMs converted from milliseconds into a concise readable duration in your final user-facing response. If Codex instead confirms completion with its native Goal, summarize the work without claiming a MAR elapsedWallMs value. Name whether the Goal completed or is finally blocked. MAR elapsedWallMs includes waiting and retries through the status update, not tool execution time or the final response. If blocked returns active for the required retry, continue work instead of claiming a final summary.`;
+        const marker = serializeComposerTag(kind === 'start' ? 'mar_goal_start' : 'mar_goal_continue', {
+            objective: goal.objective,
+            instruction
+        });
+        return [marker, goal.inputTags].filter(Boolean).join('\n');
     }
     requireCurrent(sessionId, goalId, revision) {
         const current = this.goals.get(sessionId);

package/dist/service/hosted-conversation-node-service.js

@@ -1,3 +1,4 @@
+import { assertMcpServerNames } from '../mcp/naming.js';
 import { modelUsageGrantSchema, steerComposerMessage } from '@myagentroam/protocol';
 import { createHash, randomUUID } from 'node:crypto';
 import { constants } from 'node:fs';
@@ -1891,6 +1892,7 @@ function resolveMcpServers(version, environment) {
         }
         return resolved;
     };
+    assertMcpServerNames(version.mcpServers.map((server) => ({ name: server.serverName })));
     return version.mcpServers.flatMap((server) => {
         if (server.runtime.transport === 'HTTP') {
             if (version.draft.networkMode !== 'UNRESTRICTED')

package/dist/service/mcp-installation-verifier.js

@@ -1,10 +1,11 @@
+import { NODE_MCP_CLIENT_INFO } from '../mcp/naming.js';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { getDefaultEnvironment, StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 const INSTALL_TIMEOUT_MS = 90_000;
 export class McpInstallationVerifier {
     async verify(input) {
-        const client = new Client({ name: 'myagentroam-node-installer', version: '0.9.1' });
+        const client = new Client(NODE_MCP_CLIENT_INFO);
         try {
             await withTimeout((async () => {
                 if (input.entry.runtime.transport === 'STDIO') {

package/dist/service/mcp-node-operation-service.js

@@ -1,3 +1,4 @@
+import { assertMcpServerNames, NODE_MCP } from '../mcp/naming.js';
 import { mcpCatalogEntrySchema, mcpInstallationInputSchema, mcpTargetInspectionSchema } from '@myagentroam/protocol';
 import { homedir } from 'node:os';
 import { McpInstallationVerifier } from './mcp-installation-verifier.js';
@@ -43,7 +44,7 @@ export class McpNodeOperationService {
             targetKind,
             installations,
             ...(targetKind === 'WORKSPACE'
-                ? { executionBuiltIns: ['mar_schedule', 'mar_notification'] }
+                ? { executionBuiltIns: [NODE_MCP.schedule.name, NODE_MCP.notification.name] }
                 : {})
         });
     }
@@ -51,6 +52,7 @@ export class McpNodeOperationService {
         if (!isRecord(raw))
             throw new Error('MCP_INSTALL_INPUT_INVALID');
         const entry = mcpCatalogEntrySchema.parse(raw['entry']);
+        assertMcpServerNames([{ name: entry.serverName }]);
         const input = mcpInstallationInputSchema.parse({
             catalogEntryId: entry.id,
             enabled: raw['enabled'] ?? true,

package/dist/service/{mail-notification-mcp-server.js → notification-mcp-bridge.js}

@@ -1,3 +1,4 @@
+import { NODE_MCP } from '../mcp/naming.js';
 import { randomBytes, randomUUID } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { unlink } from 'node:fs/promises';
@@ -6,38 +7,45 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { notificationInputSchema, notificationChannelsRequestSchema, mailNotificationRequestSchema } from '@myagentroam/protocol';
-export class MailNotificationMcpServer {
+export class NotificationMcpBridge {
     resolve;
     send;
     channels;
     capabilities = new Map();
     sockets = new Set();
     endpoint = process.platform === 'win32'
-        ? `\\\\.\\pipe\\mar-mail-${process.pid}-${randomUUID()}`
-        : join(tmpdir(), `mar-mail-${process.pid}-${randomUUID()}.sock`);
+        ? `\\\\.\\pipe\\mar-notification-${process.pid}-${randomUUID()}`
+        : join(tmpdir(), `mar-notification-${process.pid}-${randomUUID()}.sock`);
     listening;
     constructor(resolve, send, channels) {
         this.resolve = resolve;
         this.send = send;
         this.channels = channels;
     }
-    async installation(capability) {
+    async prepare(capability) {
         await this.listen();
+        const args = notificationMcpStdioArgs();
         const token = randomBytes(32).toString('base64url');
-        const secretName = `MAR_MAIL_MCP_${randomBytes(16).toString('hex').toUpperCase()}`;
+        const notificationChannels = this.channels?.supported() === true;
         this.capabilities.set(token, capability);
         return {
-            installation: {
-                __marMail: true,
-                notificationChannels: this.channels?.supported() === true,
-                serverName: 'mar_notification',
-                enabled: true,
-                command: process.execPath,
-                args: mailMcpStdioArgs(),
-                endpoint: this.endpoint,
-                secretName
+            name: NODE_MCP.notification.name,
+            origin: 'BUILTIN',
+            lifecycle: 'EXECUTION',
+            transport: 'STDIO',
+            command: process.execPath,
+            args,
+            environment: {
+                MAR_NOTIFICATION_MCP_ENDPOINT: this.endpoint,
+                MAR_NOTIFICATION_MCP_TOKEN: token,
+                MAR_NOTIFICATION_MCP_CHANNELS: notificationChannels ? '1' : '0'
             },
-            secrets: { [secretName]: token }
+            allowedToolCallers: {
+                [NODE_MCP.notification.tools.email]: ['direct', 'programmatic'],
+                ...(notificationChannels
+                    ? { [NODE_MCP.notification.tools.send]: ['direct', 'programmatic'] }
+                    : {})
+            }
         };
     }
     revoke(executionId) {
@@ -97,7 +105,7 @@ export class MailNotificationMcpServer {
             const current = this.resolve(capability);
             if (current === undefined)
                 throw new Error('MAIL_CAPABILITY_STALE');
-            if (request['tool'] === 'mar_send_notification') {
+            if (request['tool'] === NODE_MCP.notification.tools.send) {
                 if (this.channels?.supported() !== true)
                     throw new Error('NOTIFICATION_UNSUPPORTED');
                 const args = request['arguments'];
@@ -123,7 +131,7 @@ export class MailNotificationMcpServer {
                 socket.end(`${JSON.stringify({ result })}\n`);
                 return;
             }
-            if (request['tool'] !== 'mar_send_email_notification')
+            if (request['tool'] !== NODE_MCP.notification.tools.email)
                 throw new Error('MAIL_TOOL_INVALID');
             const args = request['arguments'];
             if (args === null || typeof args !== 'object' || Array.isArray(args))
@@ -157,7 +165,7 @@ export class MailNotificationMcpServer {
         }
     }
 }
-export function resolveMailNotificationCapability(runtime, capability) {
+export function resolveNotificationCapability(runtime, capability) {
     const run = runtime.getRun(capability.executionId);
     const session = runtime.getAgentSession(capability.sessionId);
     if (run === undefined ||
@@ -171,12 +179,12 @@ export function resolveMailNotificationCapability(runtime, capability) {
         return undefined;
     return { ...capability, sessionId: session.id };
 }
-function mailMcpStdioArgs() {
-    const javascript = fileURLToPath(new URL('./mail-notification-mcp-stdio.js', import.meta.url));
+function notificationMcpStdioArgs() {
+    const javascript = fileURLToPath(new URL('./notification-mcp-stdio.js', import.meta.url));
     if (existsSync(javascript))
         return [javascript];
-    const typescript = fileURLToPath(new URL('./mail-notification-mcp-stdio.ts', import.meta.url));
+    const typescript = fileURLToPath(new URL('./notification-mcp-stdio.ts', import.meta.url));
     if (!existsSync(typescript))
-        throw new Error('MAIL_MCP_STDIO_ENTRY_UNAVAILABLE');
+        throw new Error('NOTIFICATION_MCP_STDIO_ENTRY_UNAVAILABLE');
     return ['--import', import.meta.resolve('tsx'), typescript];
 }