@myagentroam/node 0.1.4 → 0.1.7

package/README.md

@@ -3,7 +3,7 @@
 MyAgentRoam Node runtime CLI for Linux and Windows.
 
 For third-party deployment, registration, Runner prerequisites, and automatic startup, see the
-public **Node deployment and connection guide** at `/docs/help/node-deployment.html` in your MyAgentRoam
+public **Node deployment and connection guide** at `/docs/deployment/node-installation` in your MyAgentRoam
 Server Web Console. The same guide is also linked from **Settings → Node registration**.
 
 ## Requirements
@@ -31,4 +31,12 @@ npm install --global @myagentroam/node@latest
 mar-node run --config /path/to/mar-node.json
 ```
 
+Managed deployments should run the stable supervisor entrypoint instead:
+
+```bash
+mar-node supervise --config /path/to/mar-node.json
+```
+
+The supervisor only installs an exact version requested by an authenticated Server operation. It never follows the npm `latest` tag automatically.
+
 The package contains only the executable and its runtime dependencies. It never includes Node configuration, credentials, SQLite data, workspaces, or Runner credentials.

package/dist/capabilities.d.ts

@@ -3,8 +3,10 @@ export declare function unavailableCapabilities(): NodeCapabilities;
 export declare function detectCapabilities(commands?: {
     readonly codex?: string;
     readonly claudeCode?: string;
+    readonly openCode?: string;
 }): NodeCapabilities;
 export declare function detectCapabilitiesAsync(commands?: {
     readonly codex?: string;
     readonly claudeCode?: string;
+    readonly openCode?: string;
 }): Promise<NodeCapabilities>;

package/dist/capabilities.js

@@ -2,6 +2,7 @@ import { release, version } from 'node:os';
 import nodePackage from '../package.json' with { type: 'json' };
 import { probeClaudeCode, probeClaudeCodeAsync } from './claude-agent-sdk.js';
 import { probeCodex, probeCodexAsync } from './codex-app-server.js';
+import { probeOpenCode, probeOpenCodeAsync } from './opencode-runtime.js';
 const nodeAppVersion = typeof nodePackage.version === 'string' ? nodePackage.version : 'unknown';
 function reportedPlatform() {
     return process.platform === 'win32' ? 'windows' : 'linux';
@@ -20,7 +21,8 @@ export function unavailableCapabilities() {
             osVersion: version()
         },
         codex: { available: false },
-        claudeCode: { available: false }
+        claudeCode: { available: false },
+        openCode: { available: false }
     };
 }
 export function detectCapabilities(commands = {}) {
@@ -29,6 +31,7 @@ export function detectCapabilities(commands = {}) {
     }
     const codex = probeCodex(commands.codex);
     const claudeCode = probeClaudeCode(commands.claudeCode);
+    const openCode = probeOpenCode(commands.openCode);
     return {
         platform: reportedPlatform(),
         architecture: process.arch,
@@ -45,6 +48,10 @@ export function detectCapabilities(commands = {}) {
         claudeCode: {
             available: claudeCode.available && claudeCode.compatible,
             ...(claudeCode.version === undefined ? {} : { version: claudeCode.version })
+        },
+        openCode: {
+            available: openCode.available && openCode.compatible,
+            ...(openCode.version === undefined ? {} : { version: openCode.version })
         }
     };
 }
@@ -52,9 +59,10 @@ export async function detectCapabilitiesAsync(commands = {}) {
     if (process.platform !== 'win32' && process.platform !== 'linux') {
         throw new Error('NODE_PLATFORM_UNSUPPORTED');
     }
-    const [codex, claudeCode] = await Promise.all([
+    const [codex, claudeCode, openCode] = await Promise.all([
         probeCodexAsync(commands.codex),
-        probeClaudeCodeAsync(commands.claudeCode)
+        probeClaudeCodeAsync(commands.claudeCode),
+        probeOpenCodeAsync(commands.openCode)
     ]);
     return {
         platform: reportedPlatform(),
@@ -72,7 +80,10 @@ export async function detectCapabilitiesAsync(commands = {}) {
         claudeCode: {
             available: claudeCode.available && claudeCode.compatible,
             ...(claudeCode.version === undefined ? {} : { version: claudeCode.version })
+        },
+        openCode: {
+            available: openCode.available && openCode.compatible,
+            ...(openCode.version === undefined ? {} : { version: openCode.version })
         }
     };
 }
-//# sourceMappingURL=capabilities.js.map

package/dist/claude-agent-sdk.d.ts

@@ -1,4 +1,4 @@
-import { type CanUseTool, type Options, type PermissionResult, type Query, type SDKMessage, type SDKSessionInfo, type SDKUserMessage, type SessionMessage } from '@anthropic-ai/claude-agent-sdk';
+import { forkSession, type CanUseTool, type Options, type PermissionResult, type Query, type SDKMessage, type SDKSessionInfo, type SDKUserMessage, type SessionMessage } from '@anthropic-ai/claude-agent-sdk';
 export interface ClaudeCodeProbe {
     readonly available: boolean;
     readonly compatible: boolean;
@@ -53,6 +53,7 @@ export interface ClaudeSdkBindings {
     readonly getSessionMessages: (sessionId: string, options: {
         readonly dir?: string;
     }) => Promise<SessionMessage[]>;
+    readonly forkSession?: typeof forkSession;
 }
 /**
  * Adapter for the supported Agent SDK APIs only. It neither parses nor writes
@@ -70,6 +71,7 @@ export declare class ClaudeAgentSdkAdapter {
     private startWithPrompt;
     listSessions(cwd: string): Promise<SDKSessionInfo[]>;
     readSession(sessionId: string, cwd: string): Promise<SessionMessage[]>;
+    forkSession(sessionId: string, cwd: string, upToMessageId: string, title: string): Promise<string>;
     sessionInfo(sessionId: string, cwd: string): Promise<SDKSessionInfo | undefined>;
     /**
      * The SDK publishes the authoritative, session-specific command list in its

package/dist/claude-agent-sdk.js

@@ -1,5 +1,5 @@
 import { spawnSync } from 'node:child_process';
-import { createSdkMcpServer, getSessionInfo, getSessionMessages, listSessions, query } from '@anthropic-ai/claude-agent-sdk';
+import { createSdkMcpServer, forkSession, getSessionInfo, getSessionMessages, listSessions, query } from '@anthropic-ai/claude-agent-sdk';
 import { tool } from '@anthropic-ai/claude-agent-sdk';
 import { z } from 'zod';
 import { minimalRunnerEnvironment, platformCliInvocation, runRunnerProbe } from './operational.js';
@@ -90,6 +90,14 @@ export class ClaudeAgentSdkAdapter {
     readSession(sessionId, cwd) {
         return this.sdk.getSessionMessages(sessionId, { dir: cwd });
     }
+    async forkSession(sessionId, cwd, upToMessageId, title) {
+        const result = await (this.sdk.forkSession ?? forkSession)(sessionId, {
+            dir: cwd,
+            upToMessageId,
+            title
+        });
+        return result.sessionId;
+    }
     sessionInfo(sessionId, cwd) {
         return this.sdk.getSessionInfo(sessionId, { dir: cwd });
     }
@@ -304,4 +312,3 @@ export async function probeClaudeCodeAsync(command = 'claude') {
 export function denyPermission(message = 'USER_DECISION_REJECTED') {
     return { behavior: 'deny', message };
 }
-//# sourceMappingURL=claude-agent-sdk.js.map

package/dist/claude-channel.js

@@ -42,4 +42,3 @@ export class ClaudeChannelGate {
         return this.deliveries.get(messageId);
     }
 }
-//# sourceMappingURL=claude-channel.js.map

package/dist/codex-app-server.d.ts

@@ -85,6 +85,7 @@ export declare class CodexAppServerClient {
     listThreads(): Promise<unknown>;
     listCollaborationModes(): Promise<unknown>;
     readThread(threadId: string, includeTurns?: boolean): Promise<unknown>;
+    forkThread(threadId: string, cwd: string, lastTurnId: string, configuration?: CodexRunConfiguration): Promise<unknown>;
     setThreadName(threadId: string, name: string): Promise<unknown>;
     resumeThread(threadId: string, cwd: string, configuration?: CodexRunConfiguration): Promise<unknown>;
     startTurn(threadId: string, text: string, cwd: string, configuration?: CodexRunConfiguration, attachments?: readonly Extract<CodexComposerInput, {

package/dist/codex-app-server.js

@@ -173,6 +173,14 @@ export class CodexAppServerClient {
     readThread(threadId, includeTurns = true) {
         return this.request('thread/read', { threadId, includeTurns });
     }
+    forkThread(threadId, cwd, lastTurnId, configuration = {}) {
+        return this.request('thread/fork', {
+            threadId,
+            lastTurnId,
+            cwd,
+            ...codexThreadConfiguration(cwd, configuration)
+        });
+    }
     setThreadName(threadId, name) {
         return this.request('thread/name/set', { threadId, name });
     }
@@ -390,4 +398,3 @@ function connectUnix(socketPath, timeoutMs) {
         attempt();
     });
 }
-//# sourceMappingURL=codex-app-server.js.map

package/dist/config.d.ts

@@ -7,6 +7,9 @@ export interface NodeConfig {
     readonly nodeId?: string;
     readonly credential?: string;
     readonly registrationToken?: string;
+    readonly upgrade?: {
+        readonly registryUrl?: string;
+    };
 }
 export declare function nodeConfigPath(): string;
 export declare function loadNodeConfig(path?: string): Promise<NodeConfig>;

package/dist/config.js

@@ -21,6 +21,14 @@ export async function loadNodeConfig(path = nodeConfigPath()) {
     const credential = optionalString('credential');
     const registrationToken = optionalString('registrationToken');
     const databasePath = optionalString('databasePath');
+    const upgradeInput = input['upgrade'];
+    if (upgradeInput !== undefined &&
+        (upgradeInput === null ||
+            typeof upgradeInput !== 'object' ||
+            Array.isArray(upgradeInput) ||
+            ('registryUrl' in upgradeInput &&
+                typeof upgradeInput['registryUrl'] !== 'string')))
+        throw new Error('NODE_CONFIG_INVALID');
     const allowedRoots = Array.isArray(input['allowedRoots'])
         ? input['allowedRoots']
         : defaultAllowedRoots();
@@ -30,7 +38,16 @@ export async function loadNodeConfig(path = nodeConfigPath()) {
         ...(nodeId === undefined ? {} : { nodeId }),
         ...(credential === undefined ? {} : { credential }),
         ...(registrationToken === undefined ? {} : { registrationToken }),
-        ...(databasePath === undefined ? {} : { databasePath })
+        ...(databasePath === undefined ? {} : { databasePath }),
+        ...(upgradeInput === undefined
+            ? {}
+            : {
+                upgrade: {
+                    ...(upgradeInput['registryUrl'] === undefined
+                        ? {}
+                        : { registryUrl: upgradeInput['registryUrl'] })
+                }
+            })
     };
 }
 /** Uses the Node service account's scope when no Workspace roots are configured. */
@@ -48,4 +65,3 @@ export async function saveNodeConfig(config, path = nodeConfigPath()) {
         await chmod(path, 0o600);
     }
 }
-//# sourceMappingURL=config.js.map

package/dist/connector/node-connector-options.d.ts

@@ -6,6 +6,7 @@ import type { NodeDatabase } from '../database.js';
 import type { FakeRunner, FakeRunnerStep } from '../fake-runner.js';
 import type { RunnerUsageReader } from '../runner-usage.js';
 import type { TerminalManager } from '../terminal.js';
+import type { OpenCodeServerClient } from '../opencode-server.js';
 export interface NodeConnectorOptions {
     readonly configPath?: string;
     readonly config?: NodeConfig;
@@ -16,8 +17,10 @@ export interface NodeConnectorOptions {
     readonly fakeScript?: (input: unknown, runId: string) => readonly FakeRunnerStep[];
     readonly codexClient?: CodexAppServerClient;
     readonly claudeClient?: ClaudeAgentSdkAdapter;
+    readonly openCodeClient?: OpenCodeServerClient;
     readonly database?: NodeDatabase;
     readonly claudeApprovalTimeoutMs?: number;
     readonly terminalManager?: TerminalManager;
     readonly runnerUsageReader?: RunnerUsageReader;
+    readonly upgradeReady?: () => void;
 }

package/dist/connector/node-connector-options.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=node-connector-options.js.map

package/dist/connector/node-operation-router.js

@@ -20,4 +20,3 @@ export class NodeOperationRouter {
         return Promise.resolve(handler(data));
     }
 }
-//# sourceMappingURL=node-operation-router.js.map

package/dist/connector.d.ts

@@ -41,6 +41,8 @@ export declare class NodeConnector {
     private readonly codexClient;
     private readonly codexRunController;
     private readonly claudeClient;
+    private readonly openCodeClient;
+    private readonly openCodeRunController;
     private readonly claudeRunController;
     private readonly runners;
     private readonly sessionContextService;
@@ -55,6 +57,7 @@ export declare class NodeConnector {
     private readonly commandStates;
     private readonly runnerUsageReader;
     private readonly terminalManager;
+    private readonly upgradeCoordinator;
     private readonly workspaceState;
     private readonly workspaceWatchService;
     private readonly workspaceSessionService;

package/dist/connector.js

@@ -1,3 +1,4 @@
+import { dirname, resolve } from 'node:path';
 import { createEnvelope } from '@myagentroam/protocol';
 import { loadNodeConfig, nodeDatabasePath } from './config.js';
 import { NodeMetrics, nodeLog } from './operational.js';
@@ -14,6 +15,8 @@ import { CodexRunner } from './runner/codex-runner.js';
 import { CodexManagedRunController } from './runner/codex/managed-run-controller.js';
 import { FakeTestRunner } from './runner/fake-test-runner.js';
 import { RunnerRegistry } from './runner/runner-registry.js';
+import { OpenCodeRunner } from './runner/opencode-runner.js';
+import { OpenCodeManagedRunController } from './runner/opencode/managed-run-controller.js';
 import { NodeOperationRouter } from './connector/node-operation-router.js';
 import { RunnerService } from './service/runner-service.js';
 import { TerminalService } from './service/terminal-service.js';
@@ -58,6 +61,7 @@ import { FakeManagedRunService } from './service/fake-managed-run-service.js';
 import { RunnerChannelMessageService } from './service/runner-channel-message-service.js';
 import { ManagedRunnerSessionService } from './service/managed-runner-session-service.js';
 import { NodeConnectionLifecycleService } from './service/node-connection-lifecycle-service.js';
+import { NodeUpgradeCoordinator, nodeUpgradeRequestPath } from './service/node-upgrade-coordinator.js';
 const HEARTBEAT_MS = 15_000;
 const CAPABILITY_REFRESH_MS = 60_000;
 const RETRY_MIN_MS = 500;
@@ -66,6 +70,18 @@ const CLAUDE_APPROVAL_TIMEOUT_MS = 10 * 60_000;
 export function nextReconnectDelay(attempt) {
     return Math.min(RETRY_MAX_MS, RETRY_MIN_MS * 2 ** Math.min(Math.max(attempt, 0), 16));
 }
+function upgradeMetadata(metadata, status) {
+    const next = { ...(metadata ?? {}) };
+    if (process.env['MAR_NODE_SUPERVISED'] === '1')
+        next.supervisedUpgrade = true;
+    else
+        delete next.supervisedUpgrade;
+    if (status.state === 'IDLE')
+        delete next.upgrade;
+    else
+        next.upgrade = status;
+    return next;
+}
 export class NodeConnector {
     controlChannel;
     controlMessages;
@@ -110,6 +126,8 @@ export class NodeConnector {
     codexClient;
     codexRunController;
     claudeClient;
+    openCodeClient;
+    openCodeRunController;
     claudeRunController;
     runners;
     sessionContextService;
@@ -124,6 +142,7 @@ export class NodeConnector {
     commandStates = new CommandStateStore();
     runnerUsageReader;
     terminalManager;
+    upgradeCoordinator;
     workspaceState = new WorkspaceDomainState();
     workspaceWatchService = new WorkspaceWatchService(this.workspaceState, (workspaceId) => this.workspaceSessionService.ensureWatch(workspaceId), (workspaceId) => this.workspaceSessionService.stopWatch(workspaceId));
     workspaceSessionService = new WorkspaceSessionService(this.workspaceState, {
@@ -156,7 +175,10 @@ export class NodeConnector {
         cleanupAttachments: (runId) => this.runAttachmentService.cleanup(runId),
         expireImages: (runId) => this.runAttachmentService.expire(runId),
         scheduleContextRefresh: (sessionId) => this.sessionContextService.schedule(sessionId),
-        dispatchQueue: (sessionId) => this.workspaceQueueWorkbenchService.dispatch(sessionId),
+        dispatchQueue: async (sessionId) => {
+            if (!this.upgradeCoordinator.pending())
+                await this.workspaceQueueWorkbenchService.dispatch(sessionId);
+        },
         removeQueuedStart: (runId) => this.workspaceQueueWorkbenchService.remove(runId)
     });
     nativeSessionWatchService = new NativeSessionWatchService({
@@ -175,7 +197,33 @@ export class NodeConnector {
         this.claudeApprovalTimeoutMs = options.claudeApprovalTimeoutMs ?? CLAUDE_APPROVAL_TIMEOUT_MS;
         this.capabilitiesProvided = options.capabilities !== undefined;
         this.capabilities = options.capabilities ?? unavailableCapabilities();
-        this.capabilityDetector = options.capabilityDetector ?? detectCapabilitiesAsync;
+        this.upgradeCoordinator = new NodeUpgradeCoordinator(() => {
+            if (this.config === undefined)
+                throw new Error('NODE_CONFIG_UNAVAILABLE');
+            return nodeUpgradeRequestPath(nodeDatabasePath(this.config, this.configPath));
+        }, () => this.runState.active.size, (status) => {
+            this.capabilities = {
+                ...this.capabilities,
+                metadata: upgradeMetadata(this.capabilities.metadata, status)
+            };
+            this.controlChannel?.send('capabilities', this.capabilities);
+        }, options.upgradeReady ??
+            (() => {
+                this.stop();
+                setImmediate(() => process.exit(75));
+            }));
+        this.capabilities = {
+            ...this.capabilities,
+            metadata: upgradeMetadata(this.capabilities.metadata, this.upgradeCoordinator.snapshot())
+        };
+        const detect = options.capabilityDetector ?? detectCapabilitiesAsync;
+        this.capabilityDetector = async () => {
+            const capabilities = await detect();
+            return {
+                ...capabilities,
+                metadata: upgradeMetadata(capabilities.metadata, this.upgradeCoordinator.snapshot())
+            };
+        };
         this.reconnect = options.reconnect ?? true;
         this.fakeRunner =
             options.fakeRunner === undefined ? undefined : new FakeTestRunner(options.fakeRunner);
@@ -205,6 +253,7 @@ export class NodeConnector {
             emitItem: (runId, item) => this.runEventBridge.emitRun(runId, 'conversation.item', item),
             appendImages: (runId, images) => this.runAttachmentService.append(runId, images.filter(isRunnerImageAttachment)),
             captureSnapshot: (runId, cwd) => this.workspaceCoordinator.captureRunSnapshot(runId, cwd),
+            syncTitle: (sessionId, nativeSessionId, cwd) => this.managedRunnerSessions.refreshTitle(sessionId, nativeSessionId, cwd),
             commandState: (sessionId, commandId) => this.commandStates.get(sessionId, commandId),
             setCommandState: (sessionId, state) => this.commandStates.set(sessionId, state),
             clearCommandState: (sessionId, commandId) => this.commandStates.clear(sessionId, commandId),
@@ -217,6 +266,28 @@ export class NodeConnector {
         });
         this.codexClient.onNotification((notification) => this.codexRunController.handleNotification(notification));
         this.claudeClient = new ClaudeCodeRunner(options.claudeClient);
+        this.openCodeClient = new OpenCodeRunner(options.openCodeClient);
+        this.openCodeRunController = new OpenCodeManagedRunController(this.openCodeClient, {
+            intercepted: () => this.fakeRunner !== undefined,
+            active: this.runState.active,
+            parseAttachments: parseRunnerImageAttachments,
+            emit: (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status),
+            emitItem: (runId, item) => this.runEventBridge.emitRun(runId, 'conversation.item', item),
+            adopt: (input) => this.runtime.adoptRun(input),
+            promote: (sessionId, nativeSessionId) => this.sessionIdentityService.promote(sessionId, nativeSessionId),
+            rememberNative: (nativeSessionId, sessionId) => this.managedRunnerSessions.remember(nativeSessionId, sessionId),
+            send: (type, payload) => this.send(type, payload),
+            captureSnapshot: (runId, cwd) => this.workspaceCoordinator.captureRunSnapshot(runId, cwd),
+            createApproval: (input) => this.runtime.createApproval(input),
+            expireApproval: (approvalId) => {
+                this.runtime.expireApproval(approvalId);
+            },
+            publishApproval: (input) => this.runEventBridge.publishApproval(input),
+            commandState: (sessionId, commandId) => this.commandStates.get(sessionId, commandId),
+            setCommandState: (sessionId, state) => this.commandStates.set(sessionId, state),
+            clearCommandState: (sessionId, commandId) => this.commandStates.clear(sessionId, commandId),
+            commandStates: (sessionId) => this.commandStates.list(sessionId)
+        }, this.claudeApprovalTimeoutMs);
         this.claudeRunController = new ClaudeManagedRunController(this.claudeClient, {
             intercepted: () => this.fakeRunner !== undefined,
             active: this.runState.active,
@@ -244,9 +315,12 @@ export class NodeConnector {
         this.runners = new RunnerRegistry([
             this.codexClient,
             this.claudeClient,
+            this.openCodeClient,
             ...(this.fakeRunner === undefined ? [] : [this.fakeRunner])
         ]);
-        this.managedRunnerSessions = new ManagedRunnerSessionService(this.runtime, this.runners);
+        this.managedRunnerSessions = new ManagedRunnerSessionService(this.runtime, this.runners, (session) => this.emitWorkbenchEvent('session', {
+            session: this.sessionPresentationService.present(session)
+        }));
         this.runnerInteractionService = new RunnerInteractionService({
             runtime: this.runtime,
             state: this.runState,
@@ -278,6 +352,7 @@ export class NodeConnector {
             nodeId: () => this.config?.nodeId ?? 'recorded-session',
             runtime: this.runtime,
             runners: this.runners,
+            capabilities: () => this.capabilities,
             state: this.sessionState,
             commands: this.commandStates,
             present: (session) => this.sessionPresentationService.present(session)
@@ -419,6 +494,7 @@ export class NodeConnector {
             },
             nodeId: () => this.config?.nodeId ?? 'recorded-session',
             runtime: this.runtime,
+            runners: this.runners,
             projection: this.nativeSessionProjectionService,
             resume: this.externalSessionResumeService,
             cachedNative: () => [...this.sessionState.directNative.values()],
@@ -428,7 +504,11 @@ export class NodeConnector {
             nativeIds: (session) => this.nativeSessionProjectionService.nativeIds(session),
             forget: (session, nativeIds) => this.nativeSessionProjectionService.forget(session, nativeIds),
             refreshActivity: (session) => this.conversationHistoryService.refreshExternalActivity(session),
-            externalActivity: (sessionId) => this.sessionState.externalActivity.get(sessionId)
+            externalActivity: (sessionId) => this.sessionState.externalActivity.get(sessionId),
+            history: (session, input) => this.conversationHistoryService.read(session, input),
+            emitSession: (session) => this.emitWorkbenchEvent('session', {
+                session: this.sessionPresentationService.present(session)
+            })
         });
         this.codexClient.bindControl({
             start: (envelope) => this.codexRunController.start(envelope),
@@ -446,12 +526,21 @@ export class NodeConnector {
             cancel: (runId, intent) => this.runnerInteractionService.cancelClaudeRun(runId, intent),
             decideApproval: (input) => this.runnerInteractionService.decideClaudeApproval(input.approvalId, input.decision)
         });
+        this.openCodeClient.bindControl({
+            start: (envelope) => this.openCodeRunController.start(envelope),
+            cancel: (runId, intent) => this.openCodeRunController.cancel(runId, intent),
+            decideApproval: (input) => this.openCodeRunController.decideApproval(input),
+            respondUserInput: (runId, requestId, answers) => this.openCodeRunController.respondUserInput(runId, requestId, answers)
+        });
         this.codexClient.bindCommandControl({
             execute: (session, command, input, context) => this.codexRunController.executeCommand(session, command, input, context)
         });
         this.claudeClient.bindCommandControl({
             execute: (session, command, input, context) => this.claudeRunController.executeCommand(session, command, input, context)
         });
+        this.openCodeClient.bindCommandControl({
+            execute: (session, command, _input, context) => this.openCodeRunController.executeCommand(session, command, context)
+        });
         const fakeRuns = this.fakeRunner === undefined || this.fakeScript === undefined
             ? undefined
             : new FakeManagedRunService({
@@ -500,8 +589,12 @@ export class NodeConnector {
             },
             onReconnectScheduled: () => this.metrics.reconnectScheduled(),
             onMessage: (raw) => this.handleMessage(raw),
-            onClose: (code) => {
+            onClose: (code, reason) => {
                 this.terminalChannel.disconnect();
+                if (code === 4000 && reason === 'NODE_CONNECTION_REPLACED')
+                    nodeLog('node.connection.replaced', {
+                        message: '当前 Node 已被同一身份的新实例接管，请检查是否启动了重复实例。'
+                    });
                 if (code === 4003 || code === 1001)
                     void this.terminalManager.shutdown();
             }
@@ -548,6 +641,7 @@ export class NodeConnector {
             queues: this.workspaceQueueWorkbenchService,
             codex: this.codexClient,
             claude: this.claudeClient,
+            openCode: this.openCodeClient,
             send: (type, payload, replyTo) => this.send(type, payload, replyTo)
         });
         this.connectionLifecycle = new NodeConnectionLifecycleService({
@@ -558,7 +652,10 @@ export class NodeConnector {
             detectCapabilities: this.capabilityDetector,
             capabilitiesProvided: this.capabilitiesProvided,
             stopped: () => this.stopped,
-            setCapabilities: (capabilities) => (this.capabilities = capabilities),
+            setCapabilities: (capabilities) => (this.capabilities = {
+                ...capabilities,
+                metadata: upgradeMetadata(capabilities.metadata, this.upgradeCoordinator.snapshot())
+            }),
             control: this.controlChannel,
             terminal: this.terminalChannel,
             events: this.workbenchEventService,
@@ -618,6 +715,8 @@ export class NodeConnector {
                 workspaceLeases: this.runtime.activeWorkspaceLeaseCount()
             }
         }));
+        this.operationRouter.register('node.upgrade.request', (data) => this.upgradeCoordinator.request(data));
+        this.operationRouter.register('node.upgrade.cancel', () => this.upgradeCoordinator.cancel());
         this.operationRouter.register('node.workbench.capabilities', async () => ({
             manifest: await this.workbenchManifestService.read()
         }));
@@ -625,6 +724,7 @@ export class NodeConnector {
     async start() {
         this.stopped = false;
         this.config ??= await loadNodeConfig(this.configPath);
+        await this.upgradeCoordinator.loadResult(resolve(dirname(nodeDatabasePath(this.config, this.configPath)), 'upgrade-result.json'));
         await assertLocalSqlitePath(nodeDatabasePath(this.config, this.configPath));
         this.database ??= new NodeDatabase(nodeDatabasePath(this.config, this.configPath), () => this.config?.nodeId ?? 'unregistered');
         this.database.closeRunningTerminalSessions();
@@ -633,6 +733,7 @@ export class NodeConnector {
     }
     stop() {
         this.stopped = true;
+        this.upgradeCoordinator.stop();
         this.connectionLifecycle.stop();
         for (const approval of this.claudeClient.execution.approvals.values()) {
             clearTimeout(approval.timer);
@@ -681,6 +782,8 @@ export class NodeConnector {
     async executeNodeOperation(operation, data) {
         if (this.database === undefined)
             throw new Error('NODE_DATABASE_UNAVAILABLE');
+        if (this.upgradeCoordinator.blocks(operation))
+            throw new Error('NODE_UPGRADE_PENDING');
         nodeLog('node.operation', { nodeId: this.config?.nodeId, operation });
         return this.operationRouter.execute(operation, data);
     }
@@ -691,4 +794,3 @@ export class NodeConnector {
         this.controlChannel.sendEnvelope(envelope);
     }
 }
-//# sourceMappingURL=connector.js.map

package/dist/control-outbound-scheduler.js

@@ -119,4 +119,3 @@ export class ControlOutboundScheduler {
         this.maximumNormalDepth = 0;
     }
 }
-//# sourceMappingURL=control-outbound-scheduler.js.map

package/dist/database.d.ts

@@ -106,6 +106,10 @@ export interface NodeConversationTurn {
     readonly model: string | null;
     readonly effort: string | null;
     readonly access: string | null;
+    readonly rewind?: {
+        readonly before: string | null;
+        readonly after: string;
+    };
     readonly items: readonly NodeConversationItem[];
     readonly startedAt: number | null;
     readonly completedAt: number | null;

package/dist/database.js

@@ -4,8 +4,9 @@ import { dirname } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
 import { runnerDefaultConfigurationSchema } from '@myagentroam/protocol';
 import { assertNodeSchema, NODE_SCHEMA_V1 } from './migrations/v001.js';
-import { assertNodeSchemaV2, migrateNodeSchemaV2, NODE_SCHEMA_VERSION_V2 } from './migrations/v002.js';
-const NODE_SCHEMA_VERSION = NODE_SCHEMA_VERSION_V2;
+import { assertNodeSchemaV2, migrateNodeSchemaV2 } from './migrations/v002.js';
+import { assertNodeSchemaV3, migrateNodeSchemaV3, NODE_SCHEMA_VERSION_V3 } from './migrations/v003.js';
+const NODE_SCHEMA_VERSION = NODE_SCHEMA_VERSION_V3;
 export class NodeDatabase {
     now;
     activeWorkspaceLeaseCount() {
@@ -1025,6 +1026,8 @@ function migrate(database) {
                 .prepare('INSERT INTO node_schema_migrations (version, applied_at) VALUES (?, ?), (?, ?)')
                 .run(1, Date.now(), 2, Date.now());
             database.exec('COMMIT');
+            migrateNodeSchemaV3(database);
+            assertNodeSchemaV3(database);
             return;
         }
         catch (error) {
@@ -1061,6 +1064,8 @@ function migrate(database) {
         }
         migrateNodeSchemaV2(database);
         assertNodeSchemaV2(database);
+        migrateNodeSchemaV3(database);
+        assertNodeSchemaV3(database);
         return;
     }
     if (current === 0) {
@@ -1082,12 +1087,12 @@ function migrate(database) {
         .get();
     if (numberValue(afterBaseline, 'version') === 1)
         migrateNodeSchemaV2(database);
-    if (NODE_SCHEMA_VERSION === 2) {
-        assertNodeSchemaV2(database);
-    }
-    else {
-        assertNodeSchema(database);
-    }
+    const afterV2 = database
+        .prepare('SELECT MAX(version) AS version FROM node_schema_migrations')
+        .get();
+    if (numberValue(afterV2, 'version') === 2)
+        migrateNodeSchemaV3(database);
+    assertNodeSchemaV3(database);
 }
 function sessionMetadata(row) {
     const raw = JSON.parse(stringValue(row, 'metadata'));
@@ -1130,6 +1135,7 @@ function initializeEphemeralRuntimeTables(database) {
         if (match === null || !runtimeTables.has(match[1] ?? ''))
             continue;
         database.exec(statement
+            .replaceAll("runner IN ('codex', 'claude-code')", "runner IN ('codex', 'claude-code', 'opencode')")
             .replace(/^CREATE TABLE IF NOT EXISTS/, 'CREATE TEMP TABLE IF NOT EXISTS')
             .replace('CREATE TEMP TABLE IF NOT EXISTS agent_sessions', 'CREATE TEMP TABLE IF NOT EXISTS legacy_agent_sessions')
             .replaceAll('REFERENCES agent_sessions', 'REFERENCES legacy_agent_sessions')
@@ -1389,4 +1395,3 @@ function transitionAllowed(current, next) {
         (current === 'CANCELLING' &&
             (next === 'CANCELLED' || next === 'FAILED' || next === 'INTERRUPTED')));
 }
-//# sourceMappingURL=database.js.map

package/dist/event-buffer.js

@@ -26,4 +26,3 @@ export class ReliableWorkbenchEventBuffer {
         return this.pending.size;
     }
 }
-//# sourceMappingURL=event-buffer.js.map

package/dist/fake-runner.js

@@ -127,4 +127,3 @@ export class FakeRunner {
             resolve(undefined);
     }
 }
-//# sourceMappingURL=fake-runner.js.map

package/dist/health.js

@@ -1,4 +1,3 @@
 export function getNodeHealth() {
     return { status: 'ok', platform: process.platform };
 }
-//# sourceMappingURL=health.js.map