@myagentroam/node 0.9.115 → 0.9.117

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/opencode-runner.js

@@ -4,6 +4,7 @@ import { declaredRunnerProfiles } from '../runner-profiles.js';
 import { AbstractRunner } from './abstract-runner.js';
 import { isWithinWorkspace } from './codex/conversation-parser.js';
 import { createHash } from 'node:crypto';
+import { homedir } from 'node:os';
 import { openCodeConversationPage } from './opencode/conversation-parser.js';
 import { nodeLog } from '../operational.js';
 const PROFILE_ENTRY_TTL_MS = 30 * 60_000;
@@ -12,9 +13,8 @@ export class OpenCodeRunner extends AbstractRunner {
     clientFactory;
     name = 'opencode';
     discoveryScope = 'WORKSPACE_REQUIRED';
-    modelsByWorkspace = new Map();
-    contextLimitsByWorkspace = new Map();
-    profileTimersByWorkspace = new Map();
+    contextLimits = new Map();
+    contextLimitsExpiresAt = 0;
     profileCache = new Map();
     profileRefreshes = new Map();
     execution = new Map();
@@ -34,11 +34,11 @@ export class OpenCodeRunner extends AbstractRunner {
         }).find((profile) => profile.runner === this.name);
         return { ...base, models: [] };
     }
-    async refreshProfile(capabilities, workspace, environment = {}) {
-        if (capabilities.openCode?.available !== true || workspace === undefined) {
+    async refreshProfile(capabilities, _workspace, environment = {}) {
+        if (capabilities.openCode?.available !== true) {
             return this.profile(capabilities);
         }
-        const cacheKey = this.profileCacheKey(workspace.path, environment);
+        const cacheKey = this.environmentFingerprint(environment);
         const now = Date.now();
         for (const [key, entry] of this.profileCache)
             if (entry.expiresAt <= now)
@@ -46,46 +46,42 @@ export class OpenCodeRunner extends AbstractRunner {
         const cached = this.profileCache.get(cacheKey);
         if (cached !== undefined) {
             nodeLog('runner.opencode.profile.cache-hit', {
-                workspaceId: workspace.id,
                 models: cached.models.length,
                 remainingTtlMs: cached.expiresAt - now
             });
-            this.modelsByWorkspace.set(workspace.path, cached.models);
-            this.contextLimitsByWorkspace.set(workspace.path, cached.contextLimits);
-            this.scheduleProfileExpiry(workspace.path);
+            this.contextLimits = cached.contextLimits;
+            this.contextLimitsExpiresAt = cached.expiresAt;
             return { ...this.profile(capabilities), models: cached.models };
         }
         const current = this.profileRefreshes.get(cacheKey);
         if (current !== undefined) {
-            nodeLog('runner.opencode.profile.single-flight-joined', { workspaceId: workspace.id });
+            nodeLog('runner.opencode.profile.single-flight-joined', {});
             return current;
         }
-        const refresh = this.fetchProfile(capabilities, workspace, environment, cacheKey).finally(() => {
+        const refresh = this.fetchProfile(capabilities, environment, cacheKey).finally(() => {
             if (this.profileRefreshes.get(cacheKey) === refresh)
                 this.profileRefreshes.delete(cacheKey);
         });
         this.profileRefreshes.set(cacheKey, refresh);
         return refresh;
     }
-    async fetchProfile(capabilities, workspace, environment, cacheKey) {
+    async fetchProfile(capabilities, environment, cacheKey) {
         const client = this.managedClient(environment);
         const startedAt = performance.now();
         try {
-            const catalog = await client.providers(workspace.path);
+            const catalog = await client.providers(homedir());
             const models = openCodeProfileModels(catalog);
             const contextLimits = openCodeContextLimits(catalog);
-            this.modelsByWorkspace.set(workspace.path, models);
-            this.contextLimitsByWorkspace.set(workspace.path, contextLimits);
+            const expiresAt = Date.now() + PROFILE_ENTRY_TTL_MS;
+            this.contextLimits = contextLimits;
+            this.contextLimitsExpiresAt = expiresAt;
             this.profileCache.set(cacheKey, {
-                expiresAt: Date.now() + PROFILE_ENTRY_TTL_MS,
-                workspacePath: workspace.path,
-                environmentFingerprint: this.environmentFingerprint(environment),
+                expiresAt,
+                environmentFingerprint: cacheKey,
                 models,
                 contextLimits
             });
-            this.scheduleProfileExpiry(workspace.path);
             nodeLog('runner.opencode.profile.providers.completed', {
-                workspaceId: workspace.id,
                 models: models.length,
                 durationMs: Math.round(performance.now() - startedAt)
             });
@@ -93,7 +89,6 @@ export class OpenCodeRunner extends AbstractRunner {
         }
         catch {
             nodeLog('runner.opencode.profile.providers.failed', {
-                workspaceId: workspace.id,
                 durationMs: Math.round(performance.now() - startedAt)
             });
         }
@@ -102,11 +97,6 @@ export class OpenCodeRunner extends AbstractRunner {
         }
         return this.profile(capabilities);
     }
-    profileCacheKey(workspacePath, environment) {
-        return createHash('sha256')
-            .update(JSON.stringify({ workspacePath, environment: this.environmentFingerprint(environment) }))
-            .digest('hex');
-    }
     environmentFingerprint(environment) {
         const entries = Object.entries(environment).sort(([left], [right]) => left.localeCompare(right));
         return createHash('sha256').update(JSON.stringify(entries)).digest('hex');
@@ -125,18 +115,18 @@ export class OpenCodeRunner extends AbstractRunner {
             openCode: { available: true }
         });
     }
-    supportsConfiguration(configuration, workspace, environment = {}) {
+    supportsConfiguration(configuration, _workspace, environment = {}) {
         if (configuration.runner !== this.name)
             return false;
-        const models = this.cachedModels(workspace, environment);
+        const models = this.cachedModels(environment);
         const model = models.find((candidate) => candidate.id === configuration.model);
         return (model !== undefined &&
             (model.supportedEfforts.length === 0 ||
                 model.supportedEfforts.includes(configuration.effort)) &&
             this.profileForValidation().accessOptions.some((candidate) => candidate.id === configuration.access));
     }
-    defaultConfiguration(workspace, environment = {}) {
-        const model = this.cachedModels(workspace, environment)[0];
+    defaultConfiguration(_workspace, environment = {}) {
+        const model = this.cachedModels(environment)[0];
         return {
             runner: this.name,
             model: model?.id ?? '',
@@ -144,13 +134,11 @@ export class OpenCodeRunner extends AbstractRunner {
             access: 'default'
         };
     }
-    cachedModels(workspace, environment) {
+    cachedModels(environment) {
         const fingerprint = this.environmentFingerprint(environment);
         const now = Date.now();
         return [...this.profileCache.values()]
-            .filter((entry) => entry.expiresAt > now &&
-            entry.environmentFingerprint === fingerprint &&
-            (workspace === undefined || entry.workspacePath === workspace.path))
+            .filter((entry) => entry.expiresAt > now && entry.environmentFingerprint === fingerprint)
             .flatMap((entry) => entry.models);
     }
     mcpConfiguration(raw, secrets) {
@@ -306,24 +294,20 @@ export class OpenCodeRunner extends AbstractRunner {
         const cache = object(tokens?.cache);
         const usedTokens = positiveNumber(tokens?.input) + positiveNumber(cache?.read);
         const modelId = provider !== undefined && model !== undefined ? `${provider}/${model}` : session.model;
-        const limits = [...this.contextLimitsByWorkspace].find(([workspacePath]) => isWithinWorkspace(session.cwd, workspacePath))?.[1];
-        const maxTokens = modelId === null ? undefined : limits?.get(modelId);
-        return maxTokens === undefined || usedTokens <= 0
-            ? undefined
-            : { model: modelId, usedTokens, maxTokens };
+        if (modelId === null || usedTokens <= 0)
+            return undefined;
+        const maxTokens = Date.now() >= this.contextLimitsExpiresAt ? undefined : this.contextLimits.get(modelId);
+        return maxTokens === undefined ? undefined : { model: modelId, usedTokens, maxTokens };
     }
     async stop() {
         for (const execution of this.execution.values())
             execution.abort.abort();
         this.execution.clear();
         this.managedTurns.clear();
-        for (const timer of this.profileTimersByWorkspace.values())
-            clearTimeout(timer);
-        this.profileTimersByWorkspace.clear();
         this.profileCache.clear();
         this.profileRefreshes.clear();
-        this.modelsByWorkspace.clear();
-        this.contextLimitsByWorkspace.clear();
+        this.contextLimits = new Map();
+        this.contextLimitsExpiresAt = 0;
         const stopping = [
             this.client.stop(),
             ...[...this.environmentClients.values()].map(({ client }) => client.stop()),
@@ -333,22 +317,6 @@ export class OpenCodeRunner extends AbstractRunner {
         await Promise.allSettled(stopping);
         this.stoppingClients.clear();
     }
-    scheduleProfileExpiry(workspacePath) {
-        this.clearProfileTimer(workspacePath);
-        const timer = setTimeout(() => {
-            this.profileTimersByWorkspace.delete(workspacePath);
-            this.modelsByWorkspace.delete(workspacePath);
-            this.contextLimitsByWorkspace.delete(workspacePath);
-        }, PROFILE_ENTRY_TTL_MS);
-        timer.unref();
-        this.profileTimersByWorkspace.set(workspacePath, timer);
-    }
-    clearProfileTimer(workspacePath) {
-        const timer = this.profileTimersByWorkspace.get(workspacePath);
-        if (timer !== undefined)
-            clearTimeout(timer);
-        this.profileTimersByWorkspace.delete(workspacePath);
-    }
     managedClient(environment, isolationKey) {
         const entries = Object.entries(environment).sort(([left], [right]) => left.localeCompare(right));
         if (entries.length === 0 && isolationKey === undefined)

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];
 }