@myagentroam/node 0.9.116 → 0.9.118

package/dist/native-session-history.js

@@ -5,7 +5,7 @@ import { basename, join, resolve } from 'node:path';
 import { forEachJsonlRecord, listJsonlFiles, mapConcurrent, readJsonlBackwardWindow, readJsonlFileAnchor, readJsonlWindow } from './native-jsonl-reader.js';
 import { nodeLog } from './operational.js';
 import { stripClaudePlanTag } from './runner-command-engine.js';
-import { stripMissionStartPrompt } from './service/mission-runtime.js';
+import { stripGoalStartPrompt } from './service/goal-runtime.js';
 import { parseCodexComposerImageMarkers } from './runner/codex/composer-image-markers.js';
 const DISCOVERY_READ_BYTES = 32 * 1024;
 const TRANSCRIPT_HEADER_READ_BYTES = 32 * 1024;
@@ -490,7 +490,7 @@ async function readTranscript(path, runner, byteLimit, page, targetLines = Numbe
         return undefined;
     const title = items.find((item) => item.kind === 'message' && item.role === 'USER')?.text;
     // Tagged Plan Mode instruction labels do not form a session title.
-    const strippedTitle = title === undefined ? undefined : stripClaudePlanTag(stripMissionStartPrompt(title));
+    const strippedTitle = title === undefined ? undefined : stripClaudePlanTag(stripGoalStartPrompt(title));
     return {
         runner,
         externalSessionId: id ?? basename(path, '.jsonl'),

package/dist/runner/abstract-runner.js

@@ -169,7 +169,7 @@ function resolvedMcpServers(raw, secrets) {
         const record = value;
         if (typeof record['serverName'] !== 'string' || record['enabled'] !== true)
             continue;
-        if (record['__marMission'] === true &&
+        if (record['__marGoal'] === true &&
             typeof record['command'] === 'string' &&
             Array.isArray(record['args']) &&
             record['args'].every((value) => typeof value === 'string') &&
@@ -183,8 +183,8 @@ function resolvedMcpServers(raw, secrets) {
                 command: record['command'],
                 args: record['args'],
                 environment: {
-                    MAR_MISSION_MCP_ENDPOINT: record['endpoint'],
-                    MAR_MISSION_MCP_TOKEN: secrets[record['secretName']]
+                    MAR_GOAL_MCP_ENDPOINT: record['endpoint'],
+                    MAR_GOAL_MCP_TOKEN: secrets[record['secretName']]
                 }
             });
             continue;

package/dist/runner/codex/conversation-parser.js

@@ -1,6 +1,6 @@
 import { parseCodexComposerImageMarkers } from './composer-image-markers.js';
 import { normalizeCodexTool } from './tool-normalizer.js';
-import { stripMissionStartPrompt } from '../../service/mission-runtime.js';
+import { stripGoalStartPrompt } from '../../service/goal-runtime.js';
 const MAX_COMPOSER_ATTACHMENT_BYTES = 5 * 1024 * 1024;
 const MAX_COMPOSER_ATTACHMENTS_BYTES = 10 * 1024 * 1024;
 const MAX_ASSISTANT_MESSAGE_CHARACTERS = 64 * 1024;
@@ -355,7 +355,7 @@ export function codexOfficialItem(session, nativeTurnId, value, turnSequence, it
         completedAt
     };
     if (value.type === 'userMessage') {
-        const text = stripMissionStartPrompt(codexContentText(value.content));
+        const text = stripGoalStartPrompt(codexContentText(value.content));
         return text.length === 0
             ? undefined
             : {

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

@@ -158,8 +158,8 @@ export class CodexManagedRunController {
         }
         if (notification.requestId !== undefined &&
             notification.method === 'mcpServer/elicitation/request' &&
-            activeRun.missionMcp === true &&
-            params.serverName === 'myagentroam_mission' &&
+            activeRun.goalMcp === true &&
+            params.serverName === 'myagentroam_goal' &&
             isPlainRecord(params._meta) &&
             params._meta.codex_approval_kind === 'mcp_tool_call') {
             this.runner.respond(notification.requestId, {
@@ -431,7 +431,7 @@ export class CodexManagedRunController {
                         sessionId,
                         threadId,
                         cwd,
-                        missionMcp: hasMissionMcp(payload.mcpServers)
+                        goalMcp: hasGoalMcp(payload.mcpServers)
                     });
                     turnResult = await this.runner.startTurn(threadId, input, cwd, turnConfiguration, materializedAttachments);
                     break;
@@ -457,7 +457,7 @@ export class CodexManagedRunController {
                 threadId,
                 turnId,
                 cwd,
-                missionMcp: hasMissionMcp(payload.mcpServers)
+                goalMcp: hasGoalMcp(payload.mcpServers)
             });
             this.runner.execution.managedTurns.set(turnId, { sessionId: publicSessionId, runId });
             if (this.host.runStatus(runId) === 'CANCELLING') {
@@ -489,6 +489,6 @@ export class CodexManagedRunController {
         });
     }
 }
-function hasMissionMcp(value) {
-    return isPlainRecord(value) && isPlainRecord(value.myagentroam_mission);
+function hasGoalMcp(value) {
+    return isPlainRecord(value) && isPlainRecord(value.myagentroam_goal);
 }

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

@@ -1,5 +1,5 @@
 import { MarAgentConversationNormalizer } from './conversation-normalizer.js';
-import { publicMissionHistoryText } from '../../service/mission-runtime.js';
+import { publicGoalHistoryText } from '../../service/goal-runtime.js';
 export function projectMarAgentHistory(session, entries, options = {}) {
     const turns = new Map();
     const normalizer = new MarAgentConversationNormalizer();
@@ -47,7 +47,7 @@ export function projectMarAgentHistory(session, entries, options = {}) {
             const registeredImages = images === undefined ? [] : (options.registerInputImages?.(entry) ?? []);
             replace(turn, historyItem(session, turn, id, 'user_message', 'COMPLETED', {
                 clientMessageId: entry.clientMessageId ?? null,
-                text: publicMissionHistoryText(entry.text),
+                text: publicGoalHistoryText(entry.text),
                 contexts: [],
                 delivery: 'ACCEPTED',
                 ...(images?.length

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

@@ -130,12 +130,12 @@ export class MarAgentRunner extends AbstractRunner {
                     reasonCode: null
                 },
                 {
-                    id: 'mission',
+                    id: 'goal',
                     runner: 'mar-agent',
-                    label: '/mission',
-                    stateLabel: 'Mission',
-                    description: 'Enter persistent Mission mode.',
-                    inputHint: '/mission',
+                    label: '/goal',
+                    stateLabel: 'Goal',
+                    description: 'Enter persistent Goal mode.',
+                    inputHint: '/goal',
                     source: 'MAR_RUNTIME',
                     interaction: 'TOGGLE',
                     available: true,

package/dist/runner/opencode/conversation-parser.js

@@ -1,5 +1,5 @@
 import { boundedConversationItemId, compactRunnerText } from '../codex/conversation-parser.js';
-import { stripMissionStartPrompt } from '../../service/mission-runtime.js';
+import { stripGoalStartPrompt } from '../../service/goal-runtime.js';
 import { normalizeOpenCodeTool } from './tool-normalizer.js';
 export function openCodeConversationPage(session, messages, input, managedTurn) {
     const records = messages.flatMap((value) => {
@@ -49,9 +49,9 @@ function openCodeTurn(session, user, userParts, assistants, sequence, managed) {
     const localUser = managed?.items.find((item) => item.kind === 'user_message');
     if (localUser !== undefined)
         items.push({ ...localUser, turnId: managed.id });
-    else if (stripMissionStartPrompt(userText).length > 0)
+    else if (stripGoalStartPrompt(userText).length > 0)
         items.push(item(session, nativeTurnId, `user-${nativeTurnId}`, 'user_message', 'COMPLETED', {
-            text: compactRunnerText(stripMissionStartPrompt(userText), 20_000),
+            text: compactRunnerText(stripGoalStartPrompt(userText), 20_000),
             attachments: []
         }, startedAt, startedAt, sequence));
     for (const part of compactionParts) {

package/dist/runner-command-engine.js

@@ -39,7 +39,7 @@ export function parseCommandInvocation(definition, input) {
 export class CommandStateStore {
     states = new Map();
     list(sessionId) {
-        return [...(this.states.get(sessionId)?.values() ?? [])].filter((state) => state.active || state.commandId === 'mission');
+        return [...(this.states.get(sessionId)?.values() ?? [])].filter((state) => state.active || state.commandId === 'goal');
     }
     set(sessionId, state) {
         const values = this.states.get(sessionId) ?? new Map();

package/dist/runner-profiles.js

@@ -1,7 +1,7 @@
 const COMMON_COMMAND_DESCRIPTIONS = {
     compact: 'Compact the current session context.',
     plan: 'Toggle collaborative Plan Mode.',
-    mission: 'Enter persistent Mission mode.'
+    goal: 'Enter persistent Goal mode.'
 };
 const CLAUDE_MODEL_ENVIRONMENT = {
     opus: 'ANTHROPIC_DEFAULT_OPUS_MODEL',
@@ -298,13 +298,13 @@ function validModelName(value) {
         : undefined;
 }
 function withCapabilities(profile, available) {
-    const mission = {
-        id: 'mission',
+    const goal = {
+        id: 'goal',
         runner: profile.runner,
-        label: '/mission',
-        stateLabel: 'Mission',
-        description: COMMON_COMMAND_DESCRIPTIONS.mission,
-        inputHint: '/mission',
+        label: '/goal',
+        stateLabel: 'Goal',
+        description: COMMON_COMMAND_DESCRIPTIONS.goal,
+        inputHint: '/goal',
         source: 'MAR_RUNTIME',
         interaction: 'TOGGLE',
         available,
@@ -314,7 +314,7 @@ function withCapabilities(profile, available) {
         ...profile,
         commands: [
             ...profile.commands.map((command) => available ? command : { ...command, available: false, reasonCode: 'RUNNER_UNAVAILABLE' }),
-            mission
+            goal
         ],
         capabilities: available
             ? ['history.read', 'events.live', 'turn.start', 'turn.queue', 'turn.interrupt']

package/dist/runtime-state.js

@@ -1041,7 +1041,7 @@ export class NodeRuntimeState {
         const clientMessageId = isRecord(payload) && typeof payload.clientMessageId === 'string'
             ? payload.clientMessageId
             : undefined;
-        const userMessage = clientMessageId?.startsWith('mission:')
+        const userMessage = clientMessageId?.startsWith('goal:')
             ? ''
             : (this.recentUserMessages.get(run.id) ?? this.currentRunMessageText(run.id));
         this.onRunChanged?.(run, session, userMessage.length === 0 ? undefined : userMessage);

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

@@ -242,7 +242,7 @@ export class ContinuousRunCoordinator {
             const item = this.options.runtime.getQueueItem(itemId);
             if (item === undefined)
                 return;
-            if (!this.missionCurrent(pending)) {
+            if (!this.goalCurrent(pending)) {
                 this.deleteQueueItem(item.id);
                 this.schedule(sessionId);
                 return;
@@ -262,8 +262,8 @@ export class ContinuousRunCoordinator {
             this.options.emitConversation(turn);
         }
         else if (executionId === undefined && pending !== undefined) {
-            if (!this.missionCurrent(pending)) {
-                this.rejectStaleMission(active.id);
+            if (!this.goalCurrent(pending)) {
+                this.rejectStaleGoal(active.id);
                 return;
             }
             const execution = this.options.runtime.createExecution(active.id);
@@ -277,18 +277,18 @@ export class ContinuousRunCoordinator {
             return;
         if (this.dispatchedExecutions.has(executionId))
             return;
-        if (!this.missionCurrent(pending)) {
-            this.rejectStaleMission(executionId);
+        if (!this.goalCurrent(pending)) {
+            this.rejectStaleGoal(executionId);
             return;
         }
         this.dispatchedExecutions.add(executionId);
         try {
-            const missionMcp = pending.mission === undefined
+            const goalMcp = pending.goal === undefined
                 ? undefined
-                : await this.options.missionMcp?.(pending);
-            if (!this.missionCurrent(pending)) {
+                : await this.options.goalMcp?.(pending);
+            if (!this.goalCurrent(pending)) {
                 this.dispatchedExecutions.delete(executionId);
-                this.rejectStaleMission(executionId);
+                this.rejectStaleGoal(executionId);
                 return;
             }
             this.options.control('run.start', {
@@ -311,7 +311,7 @@ export class ContinuousRunCoordinator {
                 collaborationMode: pending.collaborationMode,
                 ...(pending.serviceTier === undefined ? {} : { serviceTier: pending.serviceTier }),
                 secretEnvironment: pending.secretEnvironment,
-                ...(missionMcp === undefined ? {} : { mcpSecretEnvironment: missionMcp.secrets }),
+                ...(goalMcp === undefined ? {} : { mcpSecretEnvironment: goalMcp.secrets }),
                 ...(pending.personalInstructions === undefined
                     ? {}
                     : { personalInstructions: pending.personalInstructions }),
@@ -323,7 +323,7 @@ export class ContinuousRunCoordinator {
                 ...(pending.computerUse === undefined ? {} : { computerUse: pending.computerUse }),
                 mcpInstallations: [
                     ...this.options.mcps(pending.workspaceId),
-                    ...(missionMcp === undefined ? [] : [missionMcp.installation])
+                    ...(goalMcp === undefined ? [] : [goalMcp.installation])
                 ]
             });
         }
@@ -369,12 +369,11 @@ export class ContinuousRunCoordinator {
         if (lease !== undefined)
             this.environmentLeases.set(nextId, lease);
     }
-    removeMissionQueue(sessionId, preservedMission) {
+    removeGoalQueue(sessionId, preservedGoal) {
         for (const [id, pending] of this.preparedInputs) {
-            if (pending.sessionId !== sessionId || pending.mission === undefined)
+            if (pending.sessionId !== sessionId || pending.goal === undefined)
                 continue;
-            if (pending.mission.id === preservedMission?.id &&
-                pending.mission.revision === preservedMission.revision)
+            if (pending.goal.id === preservedGoal?.id && pending.goal.revision === preservedGoal.revision)
                 continue;
             const item = this.options.runtime.getQueueItem(id);
             if (item !== undefined)
@@ -414,7 +413,7 @@ export class ContinuousRunCoordinator {
         const item = this.options.runtime.getQueueItem(itemId);
         if (item === undefined)
             throw new Error('QUEUE_ITEM_INVALID');
-        if (!this.missionCurrent(pending)) {
+        if (!this.goalCurrent(pending)) {
             this.deleteQueueItem(item.id);
             this.startIdleQueue(sessionId);
             return;
@@ -434,13 +433,13 @@ export class ContinuousRunCoordinator {
             throw new Error('QUEUE_INPUT_LOST');
         return item;
     }
-    missionCurrent(pending) {
-        return (pending.mission === undefined ||
-            this.options.missionCurrent?.(pending) !== false);
+    goalCurrent(pending) {
+        return (pending.goal === undefined ||
+            this.options.goalCurrent?.(pending) !== false);
     }
-    rejectStaleMission(runId) {
+    rejectStaleGoal(runId) {
         this.remove(runId);
-        this.options.emitRun(runId, 'run.completed', { code: 'MISSION_SUBMISSION_STALE' }, 'INTERRUPTED');
+        this.options.emitRun(runId, 'run.completed', { code: 'GOAL_SUBMISSION_STALE' }, 'INTERRUPTED');
     }
     isMessageRun(run) {
         return this.options.runtime.findMessageRun(run.sessionId, run.clientMessageId)?.id === run.id;

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

@@ -5,16 +5,16 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { unlink } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
-export class MissionMcpServer {
-    missions;
+export class GoalMcpServer {
+    goals;
     changed;
     capabilities = new Map();
     endpoint = process.platform === 'win32'
-        ? `\\\\.\\pipe\\mar-mission-${process.pid}-${randomUUID()}`
-        : join(tmpdir(), `mar-mission-${process.pid}-${randomUUID()}.sock`);
+        ? `\\\\.\\pipe\\mar-goal-${process.pid}-${randomUUID()}`
+        : join(tmpdir(), `mar-goal-${process.pid}-${randomUUID()}.sock`);
     listening;
-    constructor(missions, changed) {
-        this.missions = missions;
+    constructor(goals, changed) {
+        this.goals = goals;
         this.changed = changed;
     }
     listen() {
@@ -28,15 +28,15 @@ export class MissionMcpServer {
     async installation(capability) {
         await this.listen();
         const token = randomBytes(32).toString('base64url');
-        const secretName = `MAR_MISSION_MCP_${randomBytes(16).toString('hex').toUpperCase()}`;
+        const secretName = `MAR_GOAL_MCP_${randomBytes(16).toString('hex').toUpperCase()}`;
         this.capabilities.set(token, capability);
         return {
             installation: {
-                __marMission: true,
-                serverName: 'myagentroam_mission',
+                __marGoal: true,
+                serverName: 'myagentroam_goal',
                 enabled: true,
                 command: process.execPath,
-                args: missionMcpStdioArgs(),
+                args: goalMcpStdioArgs(),
                 endpoint: this.endpoint,
                 secretName
             },
@@ -81,44 +81,44 @@ export class MissionMcpServer {
             const request = JSON.parse(body);
             const capability = typeof request.token === 'string' ? this.capabilities.get(request.token) : undefined;
             if (capability === undefined)
-                throw new Error('MISSION_CAPABILITY_INVALID');
+                throw new Error('GOAL_CAPABILITY_INVALID');
             const current = this.current(capability);
-            if (request.tool === 'mar_get_mission') {
+            if (request.tool === 'mar_get_goal') {
                 socket.end(`${JSON.stringify({ result: current })}\n`);
                 return;
             }
-            if (request.tool !== 'mar_update_mission')
-                throw new Error('MISSION_TOOL_INVALID');
+            if (request.tool !== 'mar_update_goal')
+                throw new Error('GOAL_TOOL_INVALID');
             const status = request.arguments !== null &&
                 typeof request.arguments === 'object' &&
                 'status' in request.arguments
                 ? request.arguments.status
                 : undefined;
             if (status !== 'completed' && status !== 'blocked')
-                throw new Error('MISSION_STATUS_INVALID');
-            const mission = this.missions.update(capability.sessionId, capability.missionId, capability.revision, status);
+                throw new Error('GOAL_STATUS_INVALID');
+            const goal = this.goals.update(capability.sessionId, capability.goalId, capability.revision, status);
             this.changed(capability.sessionId);
-            socket.end(`${JSON.stringify({ result: mission })}\n`);
+            socket.end(`${JSON.stringify({ result: goal })}\n`);
         }
         catch (error) {
-            socket.end(`${JSON.stringify({ error: error instanceof Error ? error.message : 'MISSION_IPC_FAILED' })}\n`);
+            socket.end(`${JSON.stringify({ error: error instanceof Error ? error.message : 'GOAL_IPC_FAILED' })}\n`);
         }
     }
     current(capability) {
-        const mission = this.missions.get(capability.sessionId);
-        if (mission === undefined ||
-            mission.id !== capability.missionId ||
-            mission.revision !== capability.revision)
-            throw new Error('MISSION_CAPABILITY_STALE');
-        return mission;
+        const goal = this.goals.get(capability.sessionId);
+        if (goal === undefined ||
+            goal.id !== capability.goalId ||
+            goal.revision !== capability.revision)
+            throw new Error('GOAL_CAPABILITY_STALE');
+        return goal;
     }
 }
-function missionMcpStdioArgs() {
-    const javascript = fileURLToPath(new URL('./mission-mcp-stdio.js', import.meta.url));
+function goalMcpStdioArgs() {
+    const javascript = fileURLToPath(new URL('./goal-mcp-stdio.js', import.meta.url));
     if (existsSync(javascript))
         return [javascript];
-    const typescript = fileURLToPath(new URL('./mission-mcp-stdio.ts', import.meta.url));
+    const typescript = fileURLToPath(new URL('./goal-mcp-stdio.ts', import.meta.url));
     if (!existsSync(typescript))
-        throw new Error('MISSION_MCP_STDIO_ENTRY_UNAVAILABLE');
+        throw new Error('GOAL_MCP_STDIO_ENTRY_UNAVAILABLE');
     return ['--import', import.meta.resolve('tsx'), typescript];
 }

package/dist/service/{mission-mcp-stdio.js → goal-mcp-stdio.js}

@@ -2,16 +2,16 @@ import { connect } from 'node:net';
 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_MISSION_MCP_ENDPOINT'];
-const token = process.env['MAR_MISSION_MCP_TOKEN'];
+const endpoint = process.env['MAR_GOAL_MCP_ENDPOINT'];
+const token = process.env['MAR_GOAL_MCP_TOKEN'];
 if (endpoint === undefined || token === undefined)
-    throw new Error('MISSION_CAPABILITY_INVALID');
-const server = new McpServer({ name: 'myagentroam_mission', version: '1.0.0' });
-server.registerTool('mar_get_mission', { description: 'Get the authoritative current Mission, status, and objective.' }, async () => result(await request('mar_get_mission', {})));
-server.registerTool('mar_update_mission', {
-    description: 'Explicitly mark the current Mission completed or blocked.',
+    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', {
+    description: 'Explicitly mark the current Goal completed or blocked.',
     inputSchema: { status: z.enum(['completed', 'blocked']) }
-}, async ({ status }) => result(await request('mar_update_mission', { status })));
+}, async ({ status }) => result(await request('mar_update_goal', { status })));
 await server.connect(new StdioServerTransport());
 function request(tool, args) {
     return new Promise((resolve, reject) => {