@myagentroam/node 0.9.116 → 0.9.118

package/dist/connector.js

@@ -8,8 +8,8 @@ import { NodeDatabase } from './database.js';
 import { TerminalManager } from './terminal.js';
 import { NodeRuntimeState } from './runtime-state.js';
 import { CommandStateStore } from './runner-command-engine.js';
-import { missionUnrestrictedAccess, MissionRuntime } from './service/mission-runtime.js';
-import { MissionMcpServer } from './service/mission-mcp-server.js';
+import { goalUnrestrictedAccess, GoalRuntime } from './service/goal-runtime.js';
+import { GoalMcpServer } from './service/goal-mcp-server.js';
 import { RunnerUsageReader } from './runner-usage.js';
 import { ClaudeCodeRunner } from './runner/claude-code-runner.js';
 import { ClaudeManagedRunController } from './runner/claude/managed-run-controller.js';
@@ -247,22 +247,22 @@ export class NodeConnector {
     terminalService;
     workspaceService;
     commandStates = new CommandStateStore();
-    missionRuntime = new MissionRuntime(() => undefined);
-    missionRetryTimers = new Map();
-    missionContinuationPending = new Map();
-    missionSubmissionAttempts = new Map();
-    missionContinuationEpochs = new Map();
-    missionExecutionProgress = new Set();
-    missionMcpServer = new MissionMcpServer(this.missionRuntime, (sessionId) => {
-        const mission = this.missionRuntime.get(sessionId);
+    goalRuntime = new GoalRuntime(() => undefined);
+    goalRetryTimers = new Map();
+    goalContinuationPending = new Map();
+    goalSubmissionAttempts = new Map();
+    goalContinuationEpochs = new Map();
+    goalExecutionProgress = new Set();
+    goalMcpServer = new GoalMcpServer(this.goalRuntime, (sessionId) => {
+        const goal = this.goalRuntime.get(sessionId);
         const session = this.runtime.getAgentSession(sessionId);
-        if (mission === undefined || session === undefined)
+        if (goal === undefined || session === undefined)
             return;
-        if (mission.status !== 'active') {
-            this.retireMissionContinuation(sessionId);
-            this.continuousRunCoordinator.removeMissionQueue(sessionId);
+        if (goal.status !== 'active') {
+            this.retireGoalContinuation(sessionId);
+            this.continuousRunCoordinator.removeGoalQueue(sessionId);
         }
-        this.publishMissionState(session, mission);
+        this.publishGoalState(session, goal);
     });
     runnerUsageReader;
     terminalManager;
@@ -324,44 +324,44 @@ export class NodeConnector {
             await this.continuousRunCoordinator.dispatch(sessionId);
         },
         executionStarted: (executionId) => this.continuousRunCoordinator.executionStarted(executionId),
-        keepRunActive: (sessionId) => (this.missionRetryTimers.has(sessionId) || this.missionContinuationPending.has(sessionId)) &&
-            this.missionRuntime.get(sessionId)?.status === 'active',
+        keepRunActive: (sessionId) => (this.goalRetryTimers.has(sessionId) || this.goalContinuationPending.has(sessionId)) &&
+            this.goalRuntime.get(sessionId)?.status === 'active',
         executionTerminating: (executionId, status) => {
             this.gitOperationService.executionFinished(executionId);
             const pending = this.continuousRunCoordinator.pending(executionId);
-            if (pending?.mission === undefined)
+            if (pending?.goal === undefined)
                 return;
             const started = this.continuousRunCoordinator.hasExecutionStarted(executionId);
-            const progressed = this.missionExecutionProgress.delete(executionId);
-            if (!this.missionGenerationCurrent(pending.sessionId, pending.mission))
+            const progressed = this.goalExecutionProgress.delete(executionId);
+            if (!this.goalGenerationCurrent(pending.sessionId, pending.goal))
                 return;
-            const disposition = this.missionRuntime.recordExecutionResult(pending.sessionId, {
+            const disposition = this.goalRuntime.recordExecutionResult(pending.sessionId, {
                 failed: status === 'FAILED',
                 progressed: status !== 'SUCCEEDED' || progressed
             });
             if (disposition === 'blocked' || disposition === 'paused') {
                 if (disposition === 'blocked')
-                    this.retireMissionContinuation(pending.sessionId);
+                    this.retireGoalContinuation(pending.sessionId);
                 else
-                    this.invalidateMissionContinuation(pending.sessionId);
-                this.continuousRunCoordinator.removeMissionQueue(pending.sessionId);
-                const terminalMission = this.missionRuntime.get(pending.sessionId);
+                    this.invalidateGoalContinuation(pending.sessionId);
+                this.continuousRunCoordinator.removeGoalQueue(pending.sessionId);
+                const terminalGoal = this.goalRuntime.get(pending.sessionId);
                 const session = this.runtime.getAgentSession(pending.sessionId);
-                if (terminalMission !== undefined && session !== undefined)
-                    this.publishMissionState(session, terminalMission);
+                if (terminalGoal !== undefined && session !== undefined)
+                    this.publishGoalState(session, terminalGoal);
                 return;
             }
             if (status !== 'FAILED' || started)
                 return;
-            this.clearMissionRetry(pending.sessionId);
-            const continuationEpoch = this.missionContinuationEpochs.get(pending.sessionId) ?? 0;
+            this.clearGoalRetry(pending.sessionId);
+            const continuationEpoch = this.goalContinuationEpochs.get(pending.sessionId) ?? 0;
             const retry = {
                 sessionId: pending.sessionId,
                 timer: setTimeout(() => {
-                    this.missionRetryTimers.delete(retry.sessionId);
-                    void this.enqueueMissionContinuation({
+                    this.goalRetryTimers.delete(retry.sessionId);
+                    void this.enqueueGoalContinuation({
                         sessionId: retry.sessionId,
-                        mission: pending.mission,
+                        goal: pending.goal,
                         secretEnvironment: pending.secretEnvironment,
                         ...(pending.personalInstructions === undefined
                             ? {}
@@ -380,12 +380,12 @@ export class NodeConnector {
                     });
                 }, 15_000)
             };
-            this.missionRetryTimers.set(pending.sessionId, retry);
+            this.goalRetryTimers.set(pending.sessionId, retry);
             retry.timer.unref();
         },
         releaseExecution: (executionId) => {
-            this.missionExecutionProgress.delete(executionId);
-            this.missionMcpServer.revoke(executionId);
+            this.goalExecutionProgress.delete(executionId);
+            this.goalMcpServer.revoke(executionId);
             this.continuousRunCoordinator.remove(executionId);
         }
     });
@@ -669,7 +669,7 @@ export class NodeConnector {
                 (await this.runAttachmentService.readNative(runId, imageIndex)),
             respondUserInput: (runId, requestId, answers) => this.runnerInteractionService.respondUserInput(runId, requestId, answers),
             pauseQueue: (sessionId) => this.workspaceQueueWorkbenchService.pauseSessionQueue(sessionId),
-            runInterrupted: (sessionId) => this.clearMissionState(sessionId),
+            runInterrupted: (sessionId) => this.clearGoalState(sessionId),
             emitRun: (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status),
             control: (operation, payload) => this.controlMessages.handle(JSON.stringify(createEnvelope(operation, payload))),
             markInterrupted: (runId) => this.runState.interruptRequested.add(runId)
@@ -698,19 +698,18 @@ export class NodeConnector {
             markInterrupted: (runId) => this.runState.interruptRequested.add(runId),
             mcps: (workspaceId) => this.database?.effectiveMcpInstallations(workspaceId) ?? [],
             retainEnvironment: (environment) => this.gitExecution().retain(environment),
-            missionCurrent: (input) => input.mission === undefined ||
-                this.missionGenerationCurrent(input.sessionId, input.mission),
+            goalCurrent: (input) => input.goal === undefined || this.goalGenerationCurrent(input.sessionId, input.goal),
             afterExecutionStarted: async (input) => {
-                if (input.mission === undefined)
+                if (input.goal === undefined)
                     return;
-                if (!this.missionGenerationCurrent(input.sessionId, input.mission))
+                if (!this.goalGenerationCurrent(input.sessionId, input.goal))
                     return;
-                const updated = this.missionRuntime.recordTurn(input.sessionId);
+                const updated = this.goalRuntime.recordTurn(input.sessionId);
                 const session = this.runtime.getAgentSession(input.sessionId);
                 const run = this.runtime.getRun(input.runId);
-                await this.enqueueMissionContinuation({
+                await this.enqueueGoalContinuation({
                     sessionId: input.sessionId,
-                    mission: { id: input.mission.id, revision: input.mission.revision },
+                    goal: { id: input.goal.id, revision: input.goal.revision },
                     ...(run?.initiatedByUserId === undefined
                         ? {}
                         : { initiatedByUserId: run.initiatedByUserId }),
@@ -725,33 +724,33 @@ export class NodeConnector {
                         : { marAgentRuntimeScopeId: input.marAgentRuntimeScopeId })
                 });
                 if (updated !== undefined && session !== undefined)
-                    this.publishMissionState(session, updated);
+                    this.publishGoalState(session, updated);
             },
             afterExecutionStartFailed: (input, error) => {
-                nodeLog('mission.execution-start.failed', {
+                nodeLog('goal.execution-start.failed', {
                     sessionId: input.sessionId,
                     runId: input.runId,
-                    missionId: input.mission?.id,
-                    revision: input.mission?.revision,
-                    code: safeErrorCode(error, 'MISSION_EXECUTION_START_FAILED')
+                    goalId: input.goal?.id,
+                    revision: input.goal?.revision,
+                    code: safeErrorCode(error, 'GOAL_EXECUTION_START_FAILED')
                 });
             },
-            missionMcp: async (input) => {
-                if (input.mission === undefined)
-                    throw new Error('MISSION_NOT_ACTIVE');
-                const resolved = await this.missionMcpServer.installation({
+            goalMcp: async (input) => {
+                if (input.goal === undefined)
+                    throw new Error('GOAL_NOT_ACTIVE');
+                const resolved = await this.goalMcpServer.installation({
                     executionId: input.runId,
                     sessionId: input.sessionId,
-                    missionId: input.mission.id,
-                    revision: input.mission.revision
+                    goalId: input.goal.id,
+                    revision: input.goal.revision
                 });
                 return {
                     installation: {
                         targetKind: 'WORKSPACE',
                         targetId: input.workspaceId,
-                        catalogEntryId: 'mar-internal-mission',
-                        serverName: 'myagentroam_mission',
-                        displayName: 'Mission',
+                        catalogEntryId: 'mar-internal-goal',
+                        serverName: 'myagentroam_goal',
+                        displayName: 'Goal',
                         version: '1.0.0',
                         enabled: true,
                         runtime: { transport: 'HTTP', url: 'https://127.0.0.1.invalid/mcp', headers: {} },
@@ -784,35 +783,35 @@ export class NodeConnector {
                 });
             },
             migrateCommands: (previousId, nextId) => this.commandStates.promoteSessionIdentity(previousId, nextId),
-            migrateMission: (previousId, nextId) => {
-                this.missionRuntime.migrateSession(previousId, nextId);
-                this.missionMcpServer.migrateSession(previousId, nextId);
-                const retry = this.missionRetryTimers.get(previousId);
+            migrateGoal: (previousId, nextId) => {
+                this.goalRuntime.migrateSession(previousId, nextId);
+                this.goalMcpServer.migrateSession(previousId, nextId);
+                const retry = this.goalRetryTimers.get(previousId);
                 if (retry !== undefined) {
-                    this.missionRetryTimers.delete(previousId);
+                    this.goalRetryTimers.delete(previousId);
                     retry.sessionId = nextId;
-                    this.missionRetryTimers.set(nextId, retry);
+                    this.goalRetryTimers.set(nextId, retry);
                 }
-                const pendingContinuation = this.missionContinuationPending.get(previousId);
+                const pendingContinuation = this.goalContinuationPending.get(previousId);
                 if (pendingContinuation !== undefined) {
-                    this.missionContinuationPending.delete(previousId);
+                    this.goalContinuationPending.delete(previousId);
                     pendingContinuation.sessionId = nextId;
-                    this.missionContinuationPending.set(nextId, pendingContinuation);
+                    this.goalContinuationPending.set(nextId, pendingContinuation);
                 }
-                const submissionAttempts = this.missionSubmissionAttempts.get(previousId);
+                const submissionAttempts = this.goalSubmissionAttempts.get(previousId);
                 if (submissionAttempts !== undefined) {
-                    this.missionSubmissionAttempts.delete(previousId);
-                    const currentAttempts = this.missionSubmissionAttempts.get(nextId) ?? new Set();
+                    this.goalSubmissionAttempts.delete(previousId);
+                    const currentAttempts = this.goalSubmissionAttempts.get(nextId) ?? new Set();
                     for (const attempt of submissionAttempts) {
                         attempt.sessionId = nextId;
                         currentAttempts.add(attempt);
                     }
-                    this.missionSubmissionAttempts.set(nextId, currentAttempts);
+                    this.goalSubmissionAttempts.set(nextId, currentAttempts);
                 }
-                const continuationEpoch = this.missionContinuationEpochs.get(previousId);
+                const continuationEpoch = this.goalContinuationEpochs.get(previousId);
                 if (continuationEpoch !== undefined) {
-                    this.missionContinuationEpochs.delete(previousId);
-                    this.missionContinuationEpochs.set(nextId, continuationEpoch);
+                    this.goalContinuationEpochs.delete(previousId);
+                    this.goalContinuationEpochs.set(nextId, continuationEpoch);
                 }
             },
             migrateQueue: (previousId, nextId) => this.continuousRunCoordinator.migrateSession(previousId, nextId),
@@ -868,48 +867,48 @@ export class NodeConnector {
             emitSession: (session) => this.emitSessionWorkbenchEvent({
                 session: this.sessionPresentationService.present(session)
             }),
-            beginMission: (session) => {
-                const existing = this.commandStates.get(session.id, 'mission');
+            beginGoal: (session) => {
+                const existing = this.commandStates.get(session.id, 'goal');
                 if (existing?.active === true)
                     return {
                         session: this.sessionPresentationService.present(session),
-                        missionAlreadyActive: true
+                        goalAlreadyActive: true
                     };
                 if (existing !== undefined) {
-                    this.missionRuntime.clear(session.id);
-                    this.commandStates.clear(session.id, 'mission');
+                    this.goalRuntime.clear(session.id);
+                    this.commandStates.clear(session.id, 'goal');
                 }
-                const prepared = this.prepareMissionSession(session);
+                const prepared = this.prepareGoalSession(session);
                 this.continuousRunCoordinator.removePendingQueue(session.id);
-                this.commandStates.set(session.id, this.pendingMissionCommandState());
+                this.commandStates.set(session.id, this.pendingGoalCommandState());
                 this.emitWorkbenchEvent('session', {
                     session: this.sessionPresentationService.present(prepared.session)
                 });
                 return {
                     session: this.sessionPresentationService.present(prepared.session),
-                    missionAccessChanged: prepared.changed
+                    goalAccessChanged: prepared.changed
                 };
             },
-            mission: async ({ session, objective, initiatedByUserId, secretEnvironment, personalInstructions, marAgentModel, marAgentModels, marAgentRuntimeScopeId }) => {
-                this.invalidateMissionContinuation(session.id);
-                const prepared = this.prepareMissionSession(session);
-                const missionSession = prepared.session;
+            goal: async ({ session, objective, initiatedByUserId, secretEnvironment, personalInstructions, marAgentModel, marAgentModels, marAgentRuntimeScopeId }) => {
+                this.invalidateGoalContinuation(session.id);
+                const prepared = this.prepareGoalSession(session);
+                const goalSession = prepared.session;
                 const activeRun = this.runtime.activeSessionRun(session.id);
                 const replacing = activeRun !== undefined && this.runtime.currentExecutionId(activeRun.id) !== undefined;
-                this.continuousRunCoordinator.removeMissionQueue(session.id);
-                const mission = this.missionRuntime.start(session.id, objective);
-                this.publishMissionState(missionSession, mission);
-                const attempt = this.beginMissionSubmission(session.id);
-                const missionRef = { id: mission.id, revision: mission.revision, epoch: attempt.epoch };
+                this.continuousRunCoordinator.removeGoalQueue(session.id);
+                const goal = this.goalRuntime.start(session.id, objective);
+                this.publishGoalState(goalSession, goal);
+                const attempt = this.beginGoalSubmission(session.id);
+                const goalRef = { id: goal.id, revision: goal.revision, epoch: attempt.epoch };
                 let result;
                 try {
-                    result = await this.sessionMessageService.submitMission({
+                    result = await this.sessionMessageService.submitGoal({
                         sessionId: attempt.sessionId,
                         kind: 'start',
-                        content: this.missionRuntime.prompt(attempt.sessionId, 'start'),
-                        objective: mission.objective,
+                        content: this.goalRuntime.prompt(attempt.sessionId, 'start'),
+                        objective: goal.objective,
                         deliveryIntent: replacing ? 'REPLACE_CURRENT' : 'SEND',
-                        mission: missionRef,
+                        goal: goalRef,
                         ...(initiatedByUserId === undefined ? {} : { initiatedByUserId }),
                         secretEnvironment,
                         ...(personalInstructions === undefined ? {} : { personalInstructions }),
@@ -917,22 +916,22 @@ export class NodeConnector {
                         ...(marAgentModels === undefined ? {} : { marAgentModels }),
                         ...(marAgentRuntimeScopeId === undefined ? {} : { marAgentRuntimeScopeId })
                     });
-                    if (!this.missionGenerationCurrent(attempt.sessionId, missionRef)) {
-                        this.removeStaleMissionSubmission(attempt.sessionId, result);
-                        throw new Error('MISSION_REVISION_STALE');
+                    if (!this.goalGenerationCurrent(attempt.sessionId, goalRef)) {
+                        this.removeStaleGoalSubmission(attempt.sessionId, result);
+                        throw new Error('GOAL_REVISION_STALE');
                     }
                 }
                 finally {
-                    this.finishMissionSubmissionAttempt(attempt);
+                    this.finishGoalSubmissionAttempt(attempt);
                 }
                 return {
                     ...(isPlainRecord(result) ? result : { result }),
-                    missionAccessChanged: prepared.changed
+                    goalAccessChanged: prepared.changed
                 };
             },
-            clearMission: (session) => {
-                this.clearMissionState(session.id);
-                this.finishIdleMissionRun(session.id, 'SUCCEEDED');
+            clearGoal: (session) => {
+                this.clearGoalState(session.id);
+                this.finishIdleGoalRun(session.id, 'SUCCEEDED');
                 return { session: this.sessionPresentationService.present(session), cleared: true };
             }
         });
@@ -952,46 +951,46 @@ export class NodeConnector {
                 const session = this.runtime.getAgentSession(sessionId);
                 return session?.channelToken ?? undefined;
             },
-            missionMessage: (session, content) => {
-                const state = this.commandStates.get(session.id, 'mission');
+            goalMessage: (session, content) => {
+                const state = this.commandStates.get(session.id, 'goal');
                 if (state?.active !== true)
                     return undefined;
-                const current = this.missionRuntime.get(session.id);
+                const current = this.goalRuntime.get(session.id);
                 if (current?.status === 'active') {
-                    this.invalidateMissionContinuation(session.id);
-                    const resumed = this.missionRuntime.resume(session.id);
+                    this.invalidateGoalContinuation(session.id);
+                    const resumed = this.goalRuntime.resume(session.id);
                     if (resumed !== current)
-                        this.publishMissionState(session, resumed);
+                        this.publishGoalState(session, resumed);
                     return {
                         runnerContent: content,
-                        mission: {
+                        goal: {
                             id: resumed.id,
                             revision: resumed.revision,
-                            epoch: this.missionContinuationEpochs.get(session.id) ?? 0
+                            epoch: this.goalContinuationEpochs.get(session.id) ?? 0
                         },
                         activated: false
                     };
                 }
-                this.invalidateMissionContinuation(session.id);
-                const mission = this.missionRuntime.start(session.id, content);
-                this.publishMissionState(session, mission);
+                this.invalidateGoalContinuation(session.id);
+                const goal = this.goalRuntime.start(session.id, content);
+                this.publishGoalState(session, goal);
                 return {
-                    runnerContent: this.missionRuntime.prompt(session.id, 'start'),
-                    mission: {
-                        id: mission.id,
-                        revision: mission.revision,
-                        epoch: this.missionContinuationEpochs.get(session.id) ?? 0
+                    runnerContent: this.goalRuntime.prompt(session.id, 'start'),
+                    goal: {
+                        id: goal.id,
+                        revision: goal.revision,
+                        epoch: this.goalContinuationEpochs.get(session.id) ?? 0
                     },
                     activated: true
                 };
             },
-            prepareMissionInsertion: (sessionId, submissionId, mission) => {
-                if (!this.missionGenerationCurrent(sessionId, mission))
+            prepareGoalInsertion: (sessionId, submissionId, goal) => {
+                if (!this.goalGenerationCurrent(sessionId, goal))
                     return false;
                 this.continuousRunCoordinator.removePendingQueue(sessionId, submissionId);
                 return true;
             },
-            missionPreparationFailed: (session, mission, activated) => this.handleMissionPreparationFailed(session, mission, activated)
+            goalPreparationFailed: (session, goal, activated) => this.handleGoalPreparationFailed(session, goal, activated)
         });
         this.sessionCatalogService = new SessionCatalogService({
             database: () => {
@@ -1523,48 +1522,48 @@ export class NodeConnector {
         };
         return this.directTransferService?.handleTerminal(command) ?? false;
     }
-    clearMissionRetry(sessionId) {
-        const retry = this.missionRetryTimers.get(sessionId);
+    clearGoalRetry(sessionId) {
+        const retry = this.goalRetryTimers.get(sessionId);
         if (retry !== undefined)
             clearTimeout(retry.timer);
-        this.missionRetryTimers.delete(sessionId);
-        this.missionContinuationPending.delete(sessionId);
+        this.goalRetryTimers.delete(sessionId);
+        this.goalContinuationPending.delete(sessionId);
     }
-    invalidateMissionContinuation(sessionId) {
-        this.missionContinuationEpochs.set(sessionId, (this.missionContinuationEpochs.get(sessionId) ?? 0) + 1);
-        this.clearMissionRetry(sessionId);
+    invalidateGoalContinuation(sessionId) {
+        this.goalContinuationEpochs.set(sessionId, (this.goalContinuationEpochs.get(sessionId) ?? 0) + 1);
+        this.clearGoalRetry(sessionId);
     }
-    retireMissionContinuation(sessionId) {
-        this.invalidateMissionContinuation(sessionId);
-        this.missionContinuationEpochs.delete(sessionId);
+    retireGoalContinuation(sessionId) {
+        this.invalidateGoalContinuation(sessionId);
+        this.goalContinuationEpochs.delete(sessionId);
     }
-    missionGenerationCurrent(sessionId, mission) {
-        const current = this.missionRuntime.get(sessionId);
-        return ((this.missionContinuationEpochs.get(sessionId) ?? 0) === mission.epoch &&
+    goalGenerationCurrent(sessionId, goal) {
+        const current = this.goalRuntime.get(sessionId);
+        return ((this.goalContinuationEpochs.get(sessionId) ?? 0) === goal.epoch &&
             current?.status === 'active' &&
             !current.continuationPaused &&
-            current.id === mission.id &&
-            current.revision === mission.revision);
+            current.id === goal.id &&
+            current.revision === goal.revision);
     }
-    beginMissionSubmission(sessionId, continuationEpoch = this.missionContinuationEpochs.get(sessionId) ?? 0) {
+    beginGoalSubmission(sessionId, continuationEpoch = this.goalContinuationEpochs.get(sessionId) ?? 0) {
         const attempt = { sessionId, epoch: continuationEpoch };
-        const attempts = this.missionSubmissionAttempts.get(sessionId) ?? new Set();
+        const attempts = this.goalSubmissionAttempts.get(sessionId) ?? new Set();
         attempts.add(attempt);
-        this.missionSubmissionAttempts.set(sessionId, attempts);
+        this.goalSubmissionAttempts.set(sessionId, attempts);
         return attempt;
     }
-    finishMissionSubmissionAttempt(attempt) {
-        const attempts = this.missionSubmissionAttempts.get(attempt.sessionId);
+    finishGoalSubmissionAttempt(attempt) {
+        const attempts = this.goalSubmissionAttempts.get(attempt.sessionId);
         attempts?.delete(attempt);
         if (attempts?.size === 0)
-            this.missionSubmissionAttempts.delete(attempt.sessionId);
+            this.goalSubmissionAttempts.delete(attempt.sessionId);
     }
-    finishMissionContinuationAttempt(attempt) {
-        if (this.missionContinuationPending.get(attempt.sessionId) === attempt)
-            this.missionContinuationPending.delete(attempt.sessionId);
-        this.finishMissionSubmissionAttempt(attempt);
+    finishGoalContinuationAttempt(attempt) {
+        if (this.goalContinuationPending.get(attempt.sessionId) === attempt)
+            this.goalContinuationPending.delete(attempt.sessionId);
+        this.finishGoalSubmissionAttempt(attempt);
     }
-    removeStaleMissionSubmission(sessionId, result) {
+    removeStaleGoalSubmission(sessionId, result) {
         if (!isPlainRecord(result))
             return;
         if (typeof result.queueItemId === 'string') {
@@ -1577,23 +1576,23 @@ export class NodeConnector {
             return;
         const run = this.runtime.getRun(result.run.id);
         if (run?.sessionId === sessionId && this.runtime.currentExecutionId(run.id) === undefined)
-            this.runEventBridge.emitRun(run.id, 'run.completed', { code: 'MISSION_SUBMISSION_STALE' }, 'INTERRUPTED');
+            this.runEventBridge.emitRun(run.id, 'run.completed', { code: 'GOAL_SUBMISSION_STALE' }, 'INTERRUPTED');
     }
-    async enqueueMissionContinuation(input) {
-        const attempt = this.beginMissionSubmission(input.sessionId, input.continuationEpoch);
-        const generation = { ...input.mission, epoch: attempt.epoch };
-        if (!this.missionGenerationCurrent(attempt.sessionId, generation)) {
-            this.finishMissionSubmissionAttempt(attempt);
+    async enqueueGoalContinuation(input) {
+        const attempt = this.beginGoalSubmission(input.sessionId, input.continuationEpoch);
+        const generation = { ...input.goal, epoch: attempt.epoch };
+        if (!this.goalGenerationCurrent(attempt.sessionId, generation)) {
+            this.finishGoalSubmissionAttempt(attempt);
             return;
         }
-        this.missionContinuationPending.set(input.sessionId, attempt);
+        this.goalContinuationPending.set(input.sessionId, attempt);
         try {
-            const result = await this.sessionMessageService.submitMission({
+            const result = await this.sessionMessageService.submitGoal({
                 sessionId: attempt.sessionId,
                 kind: 'continue',
-                content: this.missionRuntime.prompt(attempt.sessionId, 'continue'),
+                content: this.goalRuntime.prompt(attempt.sessionId, 'continue'),
                 deliveryIntent: input.deliveryIntent ?? 'QUEUE',
-                mission: generation,
+                goal: generation,
                 ...(input.initiatedByUserId === undefined
                     ? {}
                     : { initiatedByUserId: input.initiatedByUserId }),
@@ -1607,53 +1606,53 @@ export class NodeConnector {
                     ? {}
                     : { marAgentRuntimeScopeId: input.marAgentRuntimeScopeId })
             });
-            if (!this.missionGenerationCurrent(attempt.sessionId, generation)) {
-                this.removeStaleMissionSubmission(attempt.sessionId, result);
-                this.finishMissionContinuationAttempt(attempt);
+            if (!this.goalGenerationCurrent(attempt.sessionId, generation)) {
+                this.removeStaleGoalSubmission(attempt.sessionId, result);
+                this.finishGoalContinuationAttempt(attempt);
                 return;
             }
-            const retry = this.missionRetryTimers.get(attempt.sessionId);
+            const retry = this.goalRetryTimers.get(attempt.sessionId);
             if (retry !== undefined)
                 clearTimeout(retry.timer);
-            this.missionRetryTimers.delete(attempt.sessionId);
-            this.finishMissionContinuationAttempt(attempt);
+            this.goalRetryTimers.delete(attempt.sessionId);
+            this.finishGoalContinuationAttempt(attempt);
         }
         catch (error) {
             const failedAttempts = (input.failedAttempts ?? 0) + 1;
-            nodeLog('mission.continuation.enqueue.failed', {
+            nodeLog('goal.continuation.enqueue.failed', {
                 sessionId: attempt.sessionId,
-                missionId: input.mission.id,
-                revision: input.mission.revision,
+                goalId: input.goal.id,
+                revision: input.goal.revision,
                 attempt: failedAttempts,
-                code: safeErrorCode(error, 'MISSION_CONTINUATION_ENQUEUE_FAILED')
+                code: safeErrorCode(error, 'GOAL_CONTINUATION_ENQUEUE_FAILED')
             });
-            if (!this.missionGenerationCurrent(attempt.sessionId, generation)) {
-                this.finishMissionContinuationAttempt(attempt);
+            if (!this.goalGenerationCurrent(attempt.sessionId, generation)) {
+                this.finishGoalContinuationAttempt(attempt);
                 return;
             }
             const session = this.runtime.getAgentSession(attempt.sessionId);
             if (failedAttempts > 3 || session === undefined) {
-                this.clearMissionRetry(attempt.sessionId);
+                this.clearGoalRetry(attempt.sessionId);
                 if (failedAttempts > 3) {
-                    const blocked = this.missionRuntime.blockAfterRuntimeFailure(attempt.sessionId, input.mission.id, input.mission.revision);
-                    this.continuousRunCoordinator.removeMissionQueue(attempt.sessionId);
-                    this.missionContinuationEpochs.delete(attempt.sessionId);
-                    this.finishIdleMissionRun(attempt.sessionId, 'FAILED');
+                    const blocked = this.goalRuntime.blockAfterRuntimeFailure(attempt.sessionId, input.goal.id, input.goal.revision);
+                    this.continuousRunCoordinator.removeGoalQueue(attempt.sessionId);
+                    this.goalContinuationEpochs.delete(attempt.sessionId);
+                    this.finishIdleGoalRun(attempt.sessionId, 'FAILED');
                     if (session !== undefined)
-                        this.publishMissionState(session, blocked);
+                        this.publishGoalState(session, blocked);
                 }
                 return;
             }
-            this.finishMissionContinuationAttempt(attempt);
-            const previousRetry = this.missionRetryTimers.get(attempt.sessionId);
+            this.finishGoalContinuationAttempt(attempt);
+            const previousRetry = this.goalRetryTimers.get(attempt.sessionId);
             if (previousRetry !== undefined)
                 clearTimeout(previousRetry.timer);
             const retry = {
                 sessionId: attempt.sessionId,
                 timer: setTimeout(() => {
-                    if (!this.missionGenerationCurrent(retry.sessionId, generation))
+                    if (!this.goalGenerationCurrent(retry.sessionId, generation))
                         return;
-                    void this.enqueueMissionContinuation({
+                    void this.enqueueGoalContinuation({
                         ...input,
                         sessionId: retry.sessionId,
                         failedAttempts,
@@ -1661,33 +1660,33 @@ export class NodeConnector {
                     });
                 }, 15_000)
             };
-            this.missionRetryTimers.set(attempt.sessionId, retry);
+            this.goalRetryTimers.set(attempt.sessionId, retry);
             retry.timer.unref();
         }
     }
-    handleMissionPreparationFailed(session, mission, activated) {
-        if (!activated || !this.missionGenerationCurrent(session.id, mission))
+    handleGoalPreparationFailed(session, goal, activated) {
+        if (!activated || !this.goalGenerationCurrent(session.id, goal))
             return;
-        this.missionRuntime.clear(session.id);
-        this.finishIdleMissionRun(session.id, 'FAILED');
-        this.commandStates.set(session.id, this.pendingMissionCommandState());
+        this.goalRuntime.clear(session.id);
+        this.finishIdleGoalRun(session.id, 'FAILED');
+        this.commandStates.set(session.id, this.pendingGoalCommandState());
         this.emitWorkbenchEvent('session', {
             session: this.sessionPresentationService.present(session)
         });
     }
-    finishIdleMissionRun(sessionId, status) {
+    finishIdleGoalRun(sessionId, status) {
         const run = this.runtime.activeSessionRun(sessionId);
         if (run === undefined || this.runtime.currentExecutionId(run.id) !== undefined)
             return;
-        this.runEventBridge.emitRun(run.id, status === 'SUCCEEDED' ? 'run.completed' : 'run.failed', status === 'SUCCEEDED' ? {} : { code: 'MISSION_CONTINUATION_FAILED' }, status);
+        this.runEventBridge.emitRun(run.id, status === 'SUCCEEDED' ? 'run.completed' : 'run.failed', status === 'SUCCEEDED' ? {} : { code: 'GOAL_CONTINUATION_FAILED' }, status);
     }
-    clearMissionState(sessionId) {
-        this.retireMissionContinuation(sessionId);
-        const removed = this.missionRuntime.clear(sessionId);
-        this.continuousRunCoordinator.removeMissionQueue(sessionId);
-        const commandState = this.commandStates.get(sessionId, 'mission');
+    clearGoalState(sessionId) {
+        this.retireGoalContinuation(sessionId);
+        const removed = this.goalRuntime.clear(sessionId);
+        this.continuousRunCoordinator.removeGoalQueue(sessionId);
+        const commandState = this.commandStates.get(sessionId, 'goal');
         if (commandState !== undefined)
-            this.commandStates.clear(sessionId, 'mission');
+            this.commandStates.clear(sessionId, 'goal');
         if (!removed && commandState === undefined)
             return;
         const session = this.runtime.getAgentSession(sessionId);
@@ -1696,8 +1695,8 @@ export class NodeConnector {
                 session: this.sessionPresentationService.present(session)
             });
     }
-    prepareMissionSession(session) {
-        const access = missionUnrestrictedAccess(session.runner);
+    prepareGoalSession(session) {
+        const access = goalUnrestrictedAccess(session.runner);
         const requiresUpdate = session.access !== access;
         const changed = session.runner !== 'mar-agent' && requiresUpdate;
         const prepared = requiresUpdate
@@ -1717,14 +1716,14 @@ export class NodeConnector {
             });
         return { session: prepared, changed };
     }
-    pendingMissionCommandState() {
+    pendingGoalCommandState() {
         return {
-            commandId: 'mission',
+            commandId: 'goal',
             active: true,
-            label: 'Mission',
+            label: 'Goal',
             detail: null,
             closable: true,
-            closeInput: '/mission --clear'
+            closeInput: '/goal --clear'
         };
     }
     stop() {
@@ -1749,12 +1748,12 @@ export class NodeConnector {
         this.sessionLifecycleService.clear();
         this.continuousRunCoordinator.clear();
         this.gitOperationService.clear();
-        for (const retry of this.missionRetryTimers.values())
+        for (const retry of this.goalRetryTimers.values())
             clearTimeout(retry.timer);
-        this.missionRetryTimers.clear();
-        this.missionContinuationPending.clear();
-        this.missionSubmissionAttempts.clear();
-        this.missionContinuationEpochs.clear();
+        this.goalRetryTimers.clear();
+        this.goalContinuationPending.clear();
+        this.goalSubmissionAttempts.clear();
+        this.goalContinuationEpochs.clear();
         this.runEventService.clear();
         this.sessionContextService.dispose();
         for (const run of this.claudeClient.execution.runs.values())
@@ -1777,7 +1776,7 @@ export class NodeConnector {
         this.workspaceSessionService.clear();
         this.workspaceChangeService.clear();
         const runnerDrain = this.runners.stop();
-        void this.missionMcpServer.close();
+        void this.goalMcpServer.close();
         // close() transitions metadata before awaiting process-tree termination,
         // so the lifecycle is persisted before this synchronous shutdown returns.
         const terminalDrain = this.terminalManager.shutdown();
@@ -1805,9 +1804,9 @@ export class NodeConnector {
     handleMessage = (raw) => this.controlMessages.handle(raw);
     emitRunEvent = (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status);
     emitConversationItem = (runId, item) => {
-        if (this.continuousRunCoordinator.pending(runId)?.mission !== undefined &&
-            isMissionProgressItem(item))
-            this.missionExecutionProgress.add(runId);
+        if (this.continuousRunCoordinator.pending(runId)?.goal !== undefined &&
+            isGoalProgressItem(item))
+            this.goalExecutionProgress.add(runId);
         this.runEventBridge.emitConversationItem(runId, item);
     };
     emitConversationTurn = (turn) => {
@@ -1888,27 +1887,27 @@ export class NodeConnector {
         const result = await response.json();
         return { content: JSON.stringify(result), data: result };
     }
-    publishMissionState(session, mission) {
-        if (mission.status !== 'active') {
-            this.commandStates.clear(session.id, 'mission');
+    publishGoalState(session, goal) {
+        if (goal.status !== 'active') {
+            this.commandStates.clear(session.id, 'goal');
             this.emitWorkbenchEvent('session', {
                 session: this.sessionPresentationService.present(session)
             });
             return;
         }
         this.commandStates.set(session.id, {
-            commandId: 'mission',
-            active: mission.status === 'active',
-            label: 'Mission',
-            detail: mission.objective.slice(0, 500),
+            commandId: 'goal',
+            active: goal.status === 'active',
+            label: 'Goal',
+            detail: goal.objective.slice(0, 500),
             closable: true,
-            closeInput: '/mission',
-            mission: {
-                id: mission.id,
-                objective: mission.objective,
-                revision: mission.revision,
-                status: mission.status,
-                turns: mission.turns
+            closeInput: '/goal',
+            goal: {
+                id: goal.id,
+                objective: goal.objective,
+                revision: goal.revision,
+                status: goal.status,
+                turns: goal.turns
             }
         });
         this.emitWorkbenchEvent('session', {
@@ -1922,7 +1921,7 @@ export class NodeConnector {
         this.controlChannel.sendEnvelope(envelope);
     }
 }
-function isMissionProgressItem(item) {
+function isGoalProgressItem(item) {
     if (!isPlainRecord(item) || typeof item.kind !== 'string')
         return false;
     if (item.kind === 'command_execution' || item.kind === 'file_change')
@@ -1930,5 +1929,5 @@ function isMissionProgressItem(item) {
     if (item.kind !== 'tool_call' || !isPlainRecord(item.payload))
         return false;
     const toolName = item.payload.toolName;
-    return typeof toolName === 'string' && !toolName.endsWith('mar_get_mission');
+    return typeof toolName === 'string' && !toolName.endsWith('mar_get_goal');
 }