@jingyi0605/codingns 0.5.5 → 0.6.1

package/dist/server/modules/sessions/session-live-runtime-service.js

@@ -1,7 +1,7 @@
-import { existsSync, readdirSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { performance } from "node:perf_hooks";
-import { ClaudeRuntimeAdapter, CodexRuntimeAdapter, GeminiRuntimeAdapter, KimiRuntimeAdapter, OpenCodeRuntimeAdapter, ProviderRuntimeService } from "@codingns/session-sync-core";
+import { ClaudeRuntimeAdapter, CodexRuntimeAdapter, GeminiRuntimeAdapter, KimiRuntimeAdapter, LegnaRuntimeAdapter, OpenCodeRuntimeAdapter, ProviderRuntimeService } from "@codingns/session-sync-core";
 import { AppError, isAppError } from "../../shared/errors/app-error.js";
 import { createId } from "../../shared/utils/id.js";
 import { isPerfDebugEnabled, logPerformance } from "../../shared/utils/perf-log.js";
@@ -9,11 +9,14 @@ import { logPermissionDebug } from "../../shared/utils/permission-debug-log.js";
 import { nowIso } from "../../shared/utils/time.js";
 import { SessionActivityAuthorityService } from "./session-activity-authority-service.js";
 import { SessionPermissionRequestService } from "./session-permission-request-service.js";
-import { mapSessionProviderError } from "./session-provider-error-mapper.js";
+import { appendSessionProviderErrorContext, mapSessionProviderError } from "./session-provider-error-mapper.js";
 import { ClaudeRuntimeHelperAdapter } from "./claude-runtime-helper-client.js";
 import { CodexAppServerHelperClient } from "./codex-app-server-helper-client.js";
+const OPENCODE_ORDER_DEBUG_ENABLED = /^(1|true|yes)$/i.test(process.env.CODINGNS_OPENCODE_ORDER_DEBUG?.trim() ?? "");
 const RUNTIME_START_BINDING_WAIT_TIMEOUT_MS = 10_000;
 const START_BINDING_POLL_INTERVAL_MS = 50;
+const EXTERNAL_RUNTIME_INTERRUPT_SUPPRESSION_MS = 30_000;
+const EXTERNAL_RUNTIME_SNAPSHOT_MAX_AGE_MS = 90_000;
 export class SessionLiveRuntimeService {
     sessionHistoryService;
     sessionMessageAttachmentService;
@@ -25,12 +28,14 @@ export class SessionLiveRuntimeService {
     sessionIndexRepository;
     sessionStateRepository;
     sessionStatusSnapshotRepository;
+    sessionProviderConfigService;
     config;
     providerRuntimeService;
     sessionActivityAuthorityService;
     sessionPermissionRequestService;
     runtimeAdapterDisposables;
     externalRuntimeSnapshots = new Map();
+    externalRuntimeInterruptSuppressions = new Map();
     runtimeListeners = new Map();
     terminalStateListeners = new Set();
     deadRuntimeReconciliationSessions = new Set();
@@ -39,7 +44,7 @@ export class SessionLiveRuntimeService {
     queueDispatchSessions = new Set();
     queueRetryTimers = new Map();
     pendingSendDebugTracesBySessionId = new Map();
-    constructor(sessionHistoryService, sessionMessageAttachmentService, workspaceService, sessionChangedFileService, sessionBindingRepository, authUserRepository, sessionSendQueueRepository, sessionIndexRepository, sessionStateRepository, sessionStatusSnapshotRepository, config, sessionActivityAuthorityService = new SessionActivityAuthorityService()) {
+    constructor(sessionHistoryService, sessionMessageAttachmentService, workspaceService, sessionChangedFileService, sessionBindingRepository, authUserRepository, sessionSendQueueRepository, sessionIndexRepository, sessionStateRepository, sessionStatusSnapshotRepository, sessionProviderConfigService, config, sessionActivityAuthorityService = new SessionActivityAuthorityService()) {
         this.sessionHistoryService = sessionHistoryService;
         this.sessionMessageAttachmentService = sessionMessageAttachmentService;
         this.workspaceService = workspaceService;
@@ -50,6 +55,7 @@ export class SessionLiveRuntimeService {
         this.sessionIndexRepository = sessionIndexRepository;
         this.sessionStateRepository = sessionStateRepository;
         this.sessionStatusSnapshotRepository = sessionStatusSnapshotRepository;
+        this.sessionProviderConfigService = sessionProviderConfigService;
         this.config = config;
         this.sessionActivityAuthorityService = sessionActivityAuthorityService;
         this.sessionPermissionRequestService = new SessionPermissionRequestService(sessionHistoryService, sessionBindingRepository, authUserRepository, workspaceService, config, async (envelope) => {
@@ -76,7 +82,19 @@ export class SessionLiveRuntimeService {
         });
         try {
             const capabilities = this.sessionHistoryService.getProviderCapabilitiesSnapshot(input.provider);
-            this.ensurePendingSessionBinding(sessionId, workspace.id, input.provider);
+            const providerBinding = this.sessionProviderConfigService.prepareSessionBinding({
+                sessionId,
+                provider: input.provider,
+                providerConfigMode: input.providerConfigMode,
+                providerPresetId: input.providerPresetId ?? null
+            });
+            const providerLaunchContext = this.sessionProviderConfigService.resolveLaunchContext({
+                provider: input.provider,
+                providerConfigMode: providerBinding.providerConfigMode,
+                providerPresetId: providerBinding.providerPresetId,
+                runtimeHomeDir: providerBinding.runtimeHomeDir
+            });
+            this.ensurePendingSessionBinding(sessionId, workspace.id, input.provider, providerBinding);
             const persistedAttachments = this.persistMessageAttachments(sessionId, input.clientRequestId, input.runtimeOptions?.attachments ?? []);
             const providerPrompt = this.sessionMessageAttachmentService.buildProviderPrompt(input.provider, input.content, persistedAttachments.runtimeAttachments);
             const providerInstructionFilePath = resolveRuntimeInstructionFilePath(input.provider, workspace.path, input.runtimeOptions?.providerInstructionFilePath ?? null);
@@ -90,6 +108,8 @@ export class SessionLiveRuntimeService {
                 provider: input.provider,
                 providerSessionId: null,
                 rawStoreRef: null,
+                runtimeHomeDir: providerLaunchContext.runtimeHomeDir,
+                runtimeEnv: providerLaunchContext.runtimeEnv,
                 sequenceBase: 1,
                 options: {
                     content: input.content,
@@ -101,7 +121,12 @@ export class SessionLiveRuntimeService {
                     providerInstructionFilePath,
                     attachments: persistedAttachments.runtimeAttachments
                 }
-            }, "start");
+            }, "start", {
+                provider: input.provider,
+                providerConfigMode: providerBinding.providerConfigMode,
+                providerPresetId: providerBinding.providerPresetId,
+                runtimeHomeDir: providerBinding.runtimeHomeDir
+            });
             this.logSendDebugStep(debugTrace, "launch_runtime", launchRuntimeStartedAtMs, {
                 userId: input.userId
             });
@@ -200,6 +225,7 @@ export class SessionLiveRuntimeService {
     }
     async enqueueLiveMessage(input) {
         const session = await this.resolveQueueDispatchSession(input.sessionId, input.userId);
+        this.resolveEffectiveSessionProviderBinding(session, input);
         this.persistMessageAttachments(input.sessionId, input.clientRequestId, input.runtimeOptions?.attachments ?? []);
         const timestamp = nowIso();
         const queueItem = {
@@ -435,7 +461,7 @@ export class SessionLiveRuntimeService {
     async getSessionRuntime(sessionId, userId) {
         const runtimeSessionId = this.resolveRuntimeSessionId(sessionId);
         const runtimeSnapshot = this.getLiveRuntimeSnapshot(runtimeSessionId);
-        const externalRuntimeSnapshot = this.externalRuntimeSnapshots.get(runtimeSessionId) ?? null;
+        const externalRuntimeSnapshot = this.getFreshExternalRuntimeSnapshot(runtimeSessionId);
         const runtimeHasActiveRun = runtimeSnapshot ? isActiveRuntimeState(runtimeSnapshot.runningState) : false;
         const externalHasActiveRun = externalRuntimeSnapshot
             ? isActiveRuntimeState(externalRuntimeSnapshot.runningState)
@@ -485,7 +511,7 @@ export class SessionLiveRuntimeService {
                 runningState: resolution.runningState,
                 hasActiveRun: externalHasActiveRun,
                 canAttach: false,
-                canInterrupt: false,
+                canInterrupt: externalHasActiveRun,
                 inRunInputMode: capabilities.inRunInputMode,
                 activityResolutionSource: resolution.activityResolutionSource,
                 activityConfidence: resolution.activityConfidence,
@@ -528,32 +554,59 @@ export class SessionLiveRuntimeService {
         if (runtimeSnapshot) {
             return createRuntimeActivityObservation(runtimeSessionId, runtimeSnapshot);
         }
-        const externalRuntimeSnapshot = this.externalRuntimeSnapshots.get(runtimeSessionId) ?? null;
+        const externalRuntimeSnapshot = this.getFreshExternalRuntimeSnapshot(runtimeSessionId);
         if (externalRuntimeSnapshot) {
             return createExternalRuntimeActivityObservation(runtimeSessionId, externalRuntimeSnapshot);
         }
         return null;
     }
     async interruptSession(sessionId, userId) {
-        this.sessionHistoryService.getSession(sessionId, userId);
+        const session = this.sessionHistoryService.getSession(sessionId, userId);
         const runtimeSessionId = this.resolveRuntimeSessionId(sessionId);
         const runtime = this.getLiveRuntimeSnapshot(runtimeSessionId);
-        const externalRuntimeSnapshot = this.externalRuntimeSnapshots.get(runtimeSessionId) ?? null;
+        const externalRuntimeSnapshot = this.getFreshExternalRuntimeSnapshot(runtimeSessionId);
         if (!runtime || (runtime.runningState !== "running" && runtime.runningState !== "starting")) {
+            if (runtime && !isActiveRuntimeState(runtime.runningState)) {
+                await this.reconcileTerminalRuntimeSnapshot(sessionId, runtime);
+                return {
+                    sessionId,
+                    interrupted: true,
+                    detail: runtime.detail ?? "当前会话已结束，已自动同步状态"
+                };
+            }
             if (externalRuntimeSnapshot && isActiveRuntimeState(externalRuntimeSnapshot.runningState)) {
-                throw new AppError({
-                    statusCode: 409,
-                    errorCode: "CAPABILITY_NOT_SUPPORTED",
-                    detail: "当前 Claude 外部运行仍在进行，但现有链路不支持中断",
-                    field: "sessionId"
-                });
+                const refreshedSession = await Promise.resolve(this.sessionHistoryService.refreshRuntimeFallbackSession(sessionId, userId)).catch(() => null);
+                if (refreshedSession && !isPendingSessionRunningState(refreshedSession.runningState)) {
+                    await this.forceInterruptInactiveSession(sessionId);
+                    return {
+                        sessionId,
+                        interrupted: true,
+                        detail: "当前会话已停止，已自动同步状态"
+                    };
+                }
+                await this.forceInterruptExternalSession(sessionId);
+                return {
+                    sessionId,
+                    interrupted: true,
+                    detail: "Claude 外部运行当前无法直接中断，已强制清理本地运行状态"
+                };
             }
-            throw new AppError({
-                statusCode: 409,
-                errorCode: "SESSION_NOT_RUNNING",
-                detail: "当前会话不在运行中，无法中断",
-                field: "sessionId"
-            });
+            const refreshedSession = isPendingSessionRunningState(session.runningState)
+                ? await Promise.resolve(this.sessionHistoryService.refreshRuntimeFallbackSession(sessionId, userId)).catch(() => null)
+                : session;
+            if (refreshedSession && !isPendingSessionRunningState(refreshedSession.runningState)) {
+                return {
+                    sessionId,
+                    interrupted: true,
+                    detail: "当前会话已停止，已自动同步状态"
+                };
+            }
+            await this.forceInterruptInactiveSession(sessionId);
+            return {
+                sessionId,
+                interrupted: true,
+                detail: "当前会话已停止，已自动修正残留运行状态"
+            };
         }
         const interrupted = await this.providerRuntimeService.interrupt(runtimeSessionId).catch((error) => {
             if (error instanceof Error && error.message === "INTERRUPT_NOT_SUPPORTED") {
@@ -589,7 +642,7 @@ export class SessionLiveRuntimeService {
     subscribeRuntime(sessionId, onEnvelope) {
         const runtimeSessionId = this.resolveRuntimeSessionId(sessionId);
         const runtimeSnapshot = this.getLiveRuntimeSnapshot(runtimeSessionId);
-        const externalRuntimeSnapshot = this.externalRuntimeSnapshots.get(runtimeSessionId) ?? null;
+        const externalRuntimeSnapshot = this.getFreshExternalRuntimeSnapshot(runtimeSessionId);
         const initialActivityEnvelope = this.buildSessionActivityEnvelope(sessionId, runtimeSessionId);
         if (runtimeSnapshot) {
             void onEnvelope({
@@ -619,6 +672,16 @@ export class SessionLiveRuntimeService {
             if (!envelope) {
                 return;
             }
+            logOpenCodeOrderEnvelopeDebug("runtime.envelope.forward", {
+                sessionId,
+                runtimeSessionId,
+                provider: event.provider ?? null,
+                eventType: event.type ?? null,
+                envelopeType: envelope.type,
+                message: "message" in envelope && envelope.message
+                    ? summarizeOpenCodeOrderMessage(envelope.message)
+                    : null
+            });
             await onEnvelope(envelope);
         });
         const externalSubscription = this.subscribeExternalRuntime(runtimeSessionId, async (envelope) => {
@@ -767,13 +830,13 @@ export class SessionLiveRuntimeService {
                 sessionId
             };
         }
-        const externalRuntimeSnapshot = this.externalRuntimeSnapshots.get(runtimeSessionId) ?? null;
+        const externalRuntimeSnapshot = this.getFreshExternalRuntimeSnapshot(runtimeSessionId);
         if (externalRuntimeSnapshot) {
             const resolution = this.sessionActivityAuthorityService.observe(createExternalRuntimeActivityObservation(runtimeSessionId, externalRuntimeSnapshot));
             return {
                 ...this.mapResolutionToActivityEnvelope(resolution, {
                     hasActiveRun: isActiveRuntimeState(externalRuntimeSnapshot.runningState),
-                    canInterrupt: false
+                    canInterrupt: isActiveRuntimeState(externalRuntimeSnapshot.runningState)
                 }),
                 sessionId
             };
@@ -792,7 +855,7 @@ export class SessionLiveRuntimeService {
     }
     resolveRuntimeSessionId(sessionId) {
         if (this.providerRuntimeService.getSnapshot(sessionId)
-            || this.externalRuntimeSnapshots.has(sessionId)) {
+            || this.getFreshExternalRuntimeSnapshot(sessionId)) {
             return sessionId;
         }
         const listSnapshots = "listSnapshots" in this.providerRuntimeService
@@ -898,6 +961,12 @@ export class SessionLiveRuntimeService {
         };
     }
     async applyExternalRuntimeUpdate(input) {
+        if (input.runningState === "running" && this.shouldIgnoreInterruptedExternalRuntime(input.sessionId)) {
+            return;
+        }
+        if (input.runningState !== "running") {
+            this.clearExternalRuntimeInterruptSuppression(input.sessionId);
+        }
         const userIds = this.authUserRepository.listIds();
         if (userIds.length === 0) {
             return;
@@ -991,13 +1060,14 @@ export class SessionLiveRuntimeService {
             void this.dispatchNextQueuedMessage(input.sessionId);
         }
     }
-    async startRuntimeRun(request, userId, mode) {
+    async startRuntimeRun(request, userId, mode, providerBinding) {
         this.runtimeMessageSeenSessions.delete(request.sessionId);
         this.runtimeHistoryFallbackSentSessions.delete(request.sessionId);
+        this.clearExternalRuntimeInterruptSuppression(request.sessionId);
         if (request.provider === "claude-code") {
             this.clearExternalRuntimeSnapshot(request.sessionId);
         }
-        const handle = await this.launchRuntimeRun(request, mode);
+        const handle = await this.launchRuntimeRun(request, mode, providerBinding);
         const snapshot = handle.getSnapshot();
         const currentState = this.sessionStateRepository.findBySessionAndUser(request.sessionId, userId);
         this.attachRuntimePersistence(handle, request.sessionId, request.workspaceId, userId);
@@ -1029,9 +1099,43 @@ export class SessionLiveRuntimeService {
             const capabilities = await this.sessionHistoryService.getSessionCapabilities(input.sessionId);
             const workspace = this.workspaceService.getWorkspaceOrThrow(session.workspaceId);
             const runtimeMode = shouldStartNativeSessionOnFirstMessage(session);
+            const existingBinding = this.getSessionBindingOrThrow(session.sessionId);
+            const resolvedProviderBinding = this.resolveRequestedSessionProviderBinding(session, input, existingBinding);
+            const runtimeSessionId = this.resolveRuntimeSessionId(input.sessionId);
+            const activeRun = this.getLiveRuntimeSnapshot(runtimeSessionId);
+            const externalRuntimeSnapshot = this.getFreshExternalRuntimeSnapshot(runtimeSessionId);
+            const hasActiveRun = Boolean(activeRun && isActiveRuntimeState(activeRun.runningState));
+            if (hasActiveRun && activeRun?.provider === "claude-code") {
+                this.clearExternalRuntimeSnapshot(runtimeSessionId);
+            }
+            if (hasActiveRun
+                || (!activeRun &&
+                    session.provider === "claude-code" &&
+                    externalRuntimeSnapshot &&
+                    isActiveRuntimeState(externalRuntimeSnapshot.runningState))) {
+                this.assertProviderBindingStableDuringActiveRun(existingBinding, resolvedProviderBinding);
+            }
+            if (!activeRun &&
+                session.provider === "claude-code" &&
+                externalRuntimeSnapshot &&
+                isActiveRuntimeState(externalRuntimeSnapshot.runningState)) {
+                throw new AppError({
+                    statusCode: 409,
+                    errorCode: "SESSION_EXTERNAL_RUN_ACTIVE",
+                    detail: "当前 Claude 外部会话仍在运行，不能直接追加；请加入队列或等待当前轮结束",
+                    field: "sessionId"
+                });
+            }
+            const providerBinding = hasActiveRun
+                ? existingBinding
+                : this.persistResolvedSessionProviderBinding(existingBinding, resolvedProviderBinding);
+            const providerLaunchContext = this.sessionProviderConfigService.resolveLaunchContext(providerBinding);
             const syntheticForkRawStoreRef = runtimeMode === "start" && shouldResumeCodexSyntheticForkSession(session)
                 ? session.rawStoreRef
                 : null;
+            const runtimeRawStoreRef = runtimeMode === "start"
+                ? syntheticForkRawStoreRef
+                : await this.resolveCodexRuntimeRequestRawStoreRef(session, providerBinding);
             const nextUserSequence = runtimeMode === "start"
                 ? 1
                 : await this.resolveNextUserSequence(input.sessionId, session.messageCount);
@@ -1046,7 +1150,9 @@ export class SessionLiveRuntimeService {
                 workspacePath: workspace.path,
                 provider: session.provider,
                 providerSessionId: runtimeMode === "start" ? null : session.providerSessionId,
-                rawStoreRef: runtimeMode === "start" ? syntheticForkRawStoreRef : session.rawStoreRef,
+                rawStoreRef: runtimeRawStoreRef,
+                runtimeHomeDir: providerLaunchContext.runtimeHomeDir,
+                runtimeEnv: providerLaunchContext.runtimeEnv,
                 sequenceBase: nextUserSequence,
                 options: {
                     content: input.content,
@@ -1059,26 +1165,7 @@ export class SessionLiveRuntimeService {
                     attachments: resolvedAttachments.runtimeAttachments
                 }
             };
-            const runtimeSessionId = this.resolveRuntimeSessionId(input.sessionId);
-            const activeRun = this.getLiveRuntimeSnapshot(runtimeSessionId);
-            const externalRuntimeSnapshot = this.externalRuntimeSnapshots.get(runtimeSessionId);
-            if (activeRun &&
-                activeRun.provider === "claude-code" &&
-                isActiveRuntimeState(activeRun.runningState)) {
-                this.clearExternalRuntimeSnapshot(runtimeSessionId);
-            }
-            if (!activeRun &&
-                session.provider === "claude-code" &&
-                externalRuntimeSnapshot &&
-                isActiveRuntimeState(externalRuntimeSnapshot.runningState)) {
-                throw new AppError({
-                    statusCode: 409,
-                    errorCode: "SESSION_EXTERNAL_RUN_ACTIVE",
-                    detail: "当前 Claude 外部会话仍在运行，不能直接追加；请加入队列或等待当前轮结束",
-                    field: "sessionId"
-                });
-            }
-            if (activeRun && isActiveRuntimeState(activeRun.runningState)) {
+            if (hasActiveRun) {
                 const submitStartedAtMs = performance.now();
                 try {
                     await this.providerRuntimeService.submitToActiveRun(runtimeSessionId, runtimeRequest.options);
@@ -1088,13 +1175,23 @@ export class SessionLiveRuntimeService {
                     });
                 }
                 catch (error) {
-                    const mapped = mapSessionProviderError(error);
+                    const mapped = appendSessionProviderErrorContext(mapSessionProviderError(error), this.sessionProviderConfigService.describeBinding({
+                        provider: session.provider,
+                        providerConfigMode: providerBinding.providerConfigMode,
+                        providerPresetId: providerBinding.providerPresetId,
+                        runtimeHomeDir: providerBinding.runtimeHomeDir
+                    }));
                     // 运行时句柄还没来得及收尾时，steer 可能会撞上 provider 已终态。
                     // 这里直接失败只会把一条正常消息变成偶发 409，属于纯粹的坏味道。
                     if (mapped.errorCode === "SESSION_NOT_RUNNING") {
                         await this.providerRuntimeService.abandonRun(runtimeSessionId);
                         const restartRuntimeStartedAtMs = performance.now();
-                        await this.startRuntimeRun(runtimeRequest, input.userId, runtimeMode);
+                        await this.startRuntimeRun(runtimeRequest, input.userId, runtimeMode, {
+                            provider: session.provider,
+                            providerConfigMode: providerBinding.providerConfigMode,
+                            providerPresetId: providerBinding.providerPresetId,
+                            runtimeHomeDir: providerBinding.runtimeHomeDir
+                        });
                         this.logSendDebugStep(debugTrace, "restart_runtime_after_stale_active_run", restartRuntimeStartedAtMs, {
                             runtimeMode
                         });
@@ -1106,7 +1203,12 @@ export class SessionLiveRuntimeService {
             }
             else {
                 const startRuntimeStartedAtMs = performance.now();
-                await this.startRuntimeRun(runtimeRequest, input.userId, runtimeMode);
+                await this.startRuntimeRun(runtimeRequest, input.userId, runtimeMode, {
+                    provider: session.provider,
+                    providerConfigMode: providerBinding.providerConfigMode,
+                    providerPresetId: providerBinding.providerPresetId,
+                    runtimeHomeDir: providerBinding.runtimeHomeDir
+                });
                 this.logSendDebugStep(debugTrace, "start_runtime_run", startRuntimeStartedAtMs, {
                     runtimeMode
                 });
@@ -1156,7 +1258,7 @@ export class SessionLiveRuntimeService {
         this.queueDispatchSessions.add(sessionId);
         try {
             const runtimeSnapshot = this.getLiveRuntimeSnapshot(sessionId);
-            const externalRuntimeSnapshot = this.externalRuntimeSnapshots.get(sessionId);
+            const externalRuntimeSnapshot = this.getFreshExternalRuntimeSnapshot(sessionId);
             if ((runtimeSnapshot && isActiveRuntimeState(runtimeSnapshot.runningState))
                 || (externalRuntimeSnapshot && isActiveRuntimeState(externalRuntimeSnapshot.runningState))) {
                 return;
@@ -1222,7 +1324,7 @@ export class SessionLiveRuntimeService {
         if (runtimeSnapshot && isActiveRuntimeState(runtimeSnapshot.runningState)) {
             return true;
         }
-        const externalRuntimeSnapshot = this.externalRuntimeSnapshots.get(session.sessionId);
+        const externalRuntimeSnapshot = this.getFreshExternalRuntimeSnapshot(session.sessionId);
         if (externalRuntimeSnapshot && isActiveRuntimeState(externalRuntimeSnapshot.runningState)) {
             return true;
         }
@@ -1259,7 +1361,7 @@ export class SessionLiveRuntimeService {
             return session;
         }
         const runtimeSnapshot = this.getLiveRuntimeSnapshot(sessionId);
-        const externalRuntimeSnapshot = this.externalRuntimeSnapshots.get(sessionId);
+        const externalRuntimeSnapshot = this.getFreshExternalRuntimeSnapshot(sessionId);
         if ((runtimeSnapshot && isActiveRuntimeState(runtimeSnapshot.runningState))
             || (externalRuntimeSnapshot && isActiveRuntimeState(externalRuntimeSnapshot.runningState))) {
             return session;
@@ -1268,14 +1370,18 @@ export class SessionLiveRuntimeService {
             .then((refreshedSession) => refreshedSession ?? session)
             .catch(() => session);
     }
-    async launchRuntimeRun(request, mode) {
+    async launchRuntimeRun(request, mode, providerBinding) {
         try {
             return await (mode === "start"
                 ? this.providerRuntimeService.startSession(request)
                 : this.providerRuntimeService.continueSession(request));
         }
         catch (error) {
-            throw mapSessionProviderError(error);
+            const mapped = mapSessionProviderError(error);
+            if (!providerBinding) {
+                throw mapped;
+            }
+            throw appendSessionProviderErrorContext(mapped, this.sessionProviderConfigService.describeBinding(providerBinding));
         }
     }
     attachRuntimePersistence(handle, sessionId, workspaceId, userId) {
@@ -1353,8 +1459,109 @@ export class SessionLiveRuntimeService {
         });
         this.sessionActivityAuthorityService.observe(createRuntimeActivityObservation(input.sessionId, input.snapshot));
     }
-    ensurePendingSessionBinding(sessionId, workspaceId, provider) {
-        this.sessionHistoryService.persistSessionBinding(sessionId, workspaceId, this.buildBindingSnapshot(sessionId, provider, null, null));
+    ensurePendingSessionBinding(sessionId, workspaceId, provider, providerBinding) {
+        const snapshot = this.buildBindingSnapshot(sessionId, provider, null, null);
+        const timestamp = nowIso();
+        const existingBinding = this.sessionBindingRepository.findBySessionId(sessionId);
+        this.sessionBindingRepository.upsert({
+            sessionId,
+            workspaceId,
+            provider: snapshot.provider,
+            providerSessionId: snapshot.providerSessionId,
+            rawStoreRef: snapshot.rawStoreRef,
+            providerConfigMode: providerBinding?.providerConfigMode ?? existingBinding?.providerConfigMode ?? "global-default",
+            providerPresetId: providerBinding?.providerPresetId ?? existingBinding?.providerPresetId ?? null,
+            runtimeHomeDir: providerBinding?.runtimeHomeDir ?? existingBinding?.runtimeHomeDir ?? null,
+            createdAt: existingBinding?.createdAt ?? timestamp,
+            updatedAt: timestamp
+        });
+    }
+    resolveEffectiveSessionProviderBinding(session, input) {
+        const existingBinding = this.getSessionBindingOrThrow(session.sessionId);
+        const providerBinding = this.resolveRequestedSessionProviderBinding(session, input, existingBinding);
+        return this.persistResolvedSessionProviderBinding(existingBinding, providerBinding);
+    }
+    getSessionBindingOrThrow(sessionId) {
+        const existingBinding = this.sessionBindingRepository.findBySessionId(sessionId);
+        if (!existingBinding) {
+            throw new AppError({
+                statusCode: 404,
+                errorCode: "SESSION_NOT_FOUND",
+                detail: "session 不存在"
+            });
+        }
+        return existingBinding;
+    }
+    resolveRequestedSessionProviderBinding(session, input, existingBinding) {
+        return this.sessionProviderConfigService.resolveSessionBinding({
+            sessionId: session.sessionId,
+            provider: session.provider,
+            existingBinding,
+            providerConfigMode: input.providerConfigMode,
+            providerPresetId: input.providerPresetId ?? null
+        });
+    }
+    persistResolvedSessionProviderBinding(existingBinding, providerBinding) {
+        if (!this.hasSessionProviderBindingChanged(existingBinding, providerBinding)) {
+            return existingBinding;
+        }
+        const nextBinding = {
+            ...existingBinding,
+            providerConfigMode: providerBinding.providerConfigMode,
+            providerPresetId: providerBinding.providerPresetId,
+            runtimeHomeDir: providerBinding.runtimeHomeDir,
+            updatedAt: nowIso()
+        };
+        this.sessionBindingRepository.upsert(nextBinding);
+        return nextBinding;
+    }
+    assertProviderBindingStableDuringActiveRun(existingBinding, requestedBinding) {
+        if (!this.hasSessionProviderBindingChanged(existingBinding, requestedBinding)) {
+            return;
+        }
+        throw new AppError({
+            statusCode: 409,
+            errorCode: "SESSION_PROVIDER_CONFIG_CHANGE_REQUIRES_NEW_RUN",
+            detail: "当前会话仍在执行，不能中途切换模型配置文件；请等本轮结束后再发起新一轮",
+            field: "sessionId"
+        });
+    }
+    hasSessionProviderBindingChanged(currentBinding, nextBinding) {
+        return (currentBinding.providerConfigMode !== nextBinding.providerConfigMode
+            || normalizeOptionalBindingValue(currentBinding.providerPresetId)
+                !== normalizeOptionalBindingValue(nextBinding.providerPresetId)
+            || normalizeOptionalBindingValue(currentBinding.runtimeHomeDir)
+                !== normalizeOptionalBindingValue(nextBinding.runtimeHomeDir));
+    }
+    async resolveCodexRuntimeRequestRawStoreRef(session, providerBinding) {
+        if (session.provider !== "codex") {
+            return session.rawStoreRef;
+        }
+        const currentRawStoreRef = session.rawStoreRef?.trim() || null;
+        if (currentRawStoreRef && existsSync(currentRawStoreRef)) {
+            return currentRawStoreRef;
+        }
+        const messages = await Promise.resolve(this.sessionHistoryService.readAllTextHistoryMessages(session.sessionId)).catch(() => []);
+        if (!Array.isArray(messages) || messages.length === 0) {
+            return currentRawStoreRef;
+        }
+        const baseDir = providerBinding.runtimeHomeDir?.trim()
+            || path.resolve(path.dirname(this.config.databasePath), "runtime", "codex-resume-history");
+        const syntheticDir = path.join(baseDir, ".codingns-synthetic-resume");
+        const syntheticFilePath = path.join(syntheticDir, `${session.sessionId}.jsonl`);
+        const serialized = messages
+            .map((message) => JSON.stringify({
+            timestamp: message.timestamp,
+            type: "event_msg",
+            payload: {
+                type: message.role === "assistant" ? "agent_message" : "user_message",
+                message: message.content
+            }
+        }))
+            .join("\n");
+        mkdirSync(syntheticDir, { recursive: true });
+        writeFileSync(syntheticFilePath, `${serialized}\n`, "utf8");
+        return syntheticFilePath;
     }
     buildBindingSnapshot(sessionId, provider, providerSessionId, rawStoreRef) {
         const pendingValue = `pending://${provider}/${sessionId}`;
@@ -1482,6 +1689,112 @@ export class SessionLiveRuntimeService {
             await listener(event);
         }
     }
+    async reconcileTerminalRuntimeSnapshot(sessionId, runtime) {
+        const timestamp = runtime.lastEventAt ?? runtime.completedAt ?? runtime.startedAt;
+        const runningState = toStoredRunningState(runtime.runningState);
+        const currentSnapshot = this.sessionStatusSnapshotRepository.findBySessionId(sessionId);
+        for (const userId of this.authUserRepository.listIds()) {
+            const current = this.sessionStateRepository.findBySessionAndUser(sessionId, userId);
+            if (current?.lastEventAt
+                && current.lastEventAt.localeCompare(timestamp) > 0
+                && isTerminalSessionRunningState(current.runningState)) {
+                continue;
+            }
+            this.sessionStateRepository.upsert({
+                sessionId,
+                userId,
+                runningState,
+                activitySource: "runtime",
+                favorite: current?.favorite ?? false,
+                lastEventAt: timestamp,
+                completedAt: isTerminalSessionRunningState(runningState)
+                    ? (runtime.completedAt ?? timestamp)
+                    : current?.completedAt ?? null,
+                lastSeenAt: current?.lastSeenAt ?? null,
+                updatedAt: nowIso()
+            });
+        }
+        this.upsertSnapshot(sessionId, {
+            syncStatus: runningState === "failed" ? "error" : "idle",
+            syncCursor: currentSnapshot?.syncCursor ?? null,
+            lastSyncAt: timestamp,
+            lastErrorCode: runningState === "failed" ? runtime.errorCode ?? null : null,
+            lastErrorDetail: runningState === "failed" ? runtime.detail ?? null : null,
+            resumedAt: currentSnapshot?.resumedAt ?? null
+        });
+        this.sessionActivityAuthorityService.observe(createRuntimeActivityObservation(sessionId, runtime));
+        await this.emitExternalRuntimeEnvelope({
+            type: "session.runtime_status",
+            sessionId,
+            status: runtime.runningState,
+            detail: runtime.detail,
+            interruptSource: runtime.interruptSource,
+            timestamp
+        });
+        if (isTerminalSessionRunningState(runningState)) {
+            await this.emitTerminalStateEvent({
+                sessionId,
+                status: runningState,
+                timestamp,
+                detail: runtime.detail,
+                source: "runtime"
+            });
+            void this.dispatchNextQueuedMessage(sessionId);
+        }
+    }
+    async forceInterruptInactiveSession(sessionId) {
+        const timestamp = nowIso();
+        const currentSnapshot = this.sessionStatusSnapshotRepository.findBySessionId(sessionId);
+        for (const userId of this.authUserRepository.listIds()) {
+            const current = this.sessionStateRepository.findBySessionAndUser(sessionId, userId);
+            if (!current || !isPendingSessionRunningState(current.runningState)) {
+                continue;
+            }
+            this.sessionStateRepository.upsert({
+                ...current,
+                runningState: "interrupted",
+                activitySource: "runtime",
+                completedAt: timestamp,
+                updatedAt: timestamp
+            });
+        }
+        this.clearExternalRuntimeSnapshot(sessionId);
+        this.upsertSnapshot(sessionId, {
+            syncStatus: "idle",
+            syncCursor: currentSnapshot?.syncCursor ?? null,
+            lastSyncAt: timestamp,
+            lastErrorCode: null,
+            lastErrorDetail: null,
+            resumedAt: currentSnapshot?.resumedAt ?? null
+        });
+        this.sessionActivityAuthorityService.observe({
+            sessionId,
+            runId: null,
+            runningState: "interrupted",
+            source: "authoritative_runtime",
+            confidence: "strong",
+            detail: "检测到会话实际已停止，已自动修正残留运行状态",
+            interruptSource: "runtime",
+            errorCode: null,
+            observedAt: timestamp
+        });
+        await this.emitExternalRuntimeEnvelope({
+            type: "session.runtime_status",
+            sessionId,
+            status: "interrupted",
+            detail: "检测到会话实际已停止，已自动修正残留运行状态",
+            interruptSource: "runtime",
+            timestamp
+        });
+        await this.emitTerminalStateEvent({
+            sessionId,
+            status: "interrupted",
+            timestamp,
+            detail: "检测到会话实际已停止，已自动修正残留运行状态",
+            source: "runtime"
+        });
+        void this.dispatchNextQueuedMessage(sessionId);
+    }
     beginPendingSendDebugTrace(input) {
         if (!isPerfDebugEnabled()) {
             return null;
@@ -1619,7 +1932,7 @@ export class SessionLiveRuntimeService {
         }
     }
     async resolveNextUserSequence(sessionId, messageCount) {
-        let maxSequence = Math.max(messageCount, 0);
+        let maxSequence = 0;
         const envelope = await Promise.resolve(this.sessionHistoryService.readRecentHistoryEnvelope(sessionId, 10)).catch(() => {
             return null;
         });
@@ -1628,6 +1941,9 @@ export class SessionLiveRuntimeService {
                 maxSequence = message.sequence;
             }
         }
+        if (maxSequence <= 0) {
+            maxSequence = Math.max(messageCount, 0);
+        }
         return Math.max(maxSequence + 1, 1);
     }
     async waitForResolvedStartBinding(sessionId, workspaceId, provider, handle) {
@@ -1764,6 +2080,39 @@ export class SessionLiveRuntimeService {
     clearExternalRuntimeSnapshot(sessionId) {
         this.externalRuntimeSnapshots.delete(sessionId);
     }
+    getFreshExternalRuntimeSnapshot(sessionId) {
+        const snapshot = this.externalRuntimeSnapshots.get(sessionId) ?? null;
+        if (!snapshot) {
+            return null;
+        }
+        if (!isExternalRuntimeSnapshotExpired(snapshot)) {
+            return snapshot;
+        }
+        this.clearExternalRuntimeSnapshot(sessionId);
+        this.sessionActivityAuthorityService.clearSession(sessionId);
+        return null;
+    }
+    suppressInterruptedExternalRuntime(sessionId) {
+        this.externalRuntimeInterruptSuppressions.set(sessionId, Date.now() + EXTERNAL_RUNTIME_INTERRUPT_SUPPRESSION_MS);
+    }
+    clearExternalRuntimeInterruptSuppression(sessionId) {
+        this.externalRuntimeInterruptSuppressions.delete(sessionId);
+    }
+    shouldIgnoreInterruptedExternalRuntime(sessionId) {
+        const expiresAt = this.externalRuntimeInterruptSuppressions.get(sessionId);
+        if (!expiresAt) {
+            return false;
+        }
+        if (Date.now() >= expiresAt) {
+            this.externalRuntimeInterruptSuppressions.delete(sessionId);
+            return false;
+        }
+        return true;
+    }
+    async forceInterruptExternalSession(sessionId) {
+        this.suppressInterruptedExternalRuntime(sessionId);
+        await this.forceInterruptInactiveSession(sessionId);
+    }
     async resolveActiveClaudePermissionSession(input) {
         const activeSnapshots = this.providerRuntimeService
             .listSnapshots()
@@ -1835,6 +2184,13 @@ function createExternalRuntimeActivityObservation(sessionId, snapshot) {
         observedAt: snapshot.updatedAt
     };
 }
+function isExternalRuntimeSnapshotExpired(snapshot) {
+    const updatedAtMs = Date.parse(snapshot.updatedAt);
+    if (!Number.isFinite(updatedAtMs)) {
+        return true;
+    }
+    return Date.now() - updatedAtMs > EXTERNAL_RUNTIME_SNAPSHOT_MAX_AGE_MS;
+}
 function createRuntimeEventObservation(sessionId, event, startedAt) {
     return {
         sessionId,
@@ -2111,21 +2467,33 @@ function createProviderRuntimeAdapters(config, options = {}) {
     if ("dispose" in claudeAdapter && typeof claudeAdapter.dispose === "function") {
         disposables.push(claudeAdapter);
     }
-    const codexTransportHelper = process.env.VITEST
-        ? null
-        : new CodexAppServerHelperClient(config.codexCliPath, {
-            homeDir: config.codexHomeDir
-        });
-    if (codexTransportHelper) {
-        disposables.push(codexTransportHelper);
-    }
     return {
         adapters: [
             claudeAdapter,
+            new LegnaRuntimeAdapter({
+                homeDir: config.legnaCodeHomeDir,
+                commandPath: config.legnaCodeCliPath,
+                legacyClaudeHomeDir: config.claudeCodeHomeDir
+            }),
             new CodexRuntimeAdapter({
                 homeDir: config.codexHomeDir,
                 commandPath: config.codexCliPath,
-                transportFactory: codexTransportHelper?.createTransport.bind(codexTransportHelper),
+                transportFactory: process.env.VITEST
+                    ? undefined
+                    : (request) => {
+                        const client = new CodexAppServerHelperClient(config.codexCliPath, {
+                            homeDir: request.runtimeHomeDir?.trim() || config.codexHomeDir,
+                            runtimeEnv: request.runtimeEnv ?? null
+                        });
+                        const transport = client.createTransport();
+                        return {
+                            ...transport,
+                            close() {
+                                transport.close();
+                                client.dispose();
+                            }
+                        };
+                    },
                 handleServerRequest: options.handleCodexServerRequest
             }),
             new GeminiRuntimeAdapter({
@@ -2150,12 +2518,16 @@ function resolveRuntimeInstructionFilePath(provider, workspacePath, explicitFile
         const resolvedExplicit = path.resolve(normalizedExplicit);
         return existsSync(resolvedExplicit) ? resolvedExplicit : null;
     }
-    if (provider !== "claude-code") {
+    const defaultInstructionPath = provider === "claude-code"
+        ? path.join(workspacePath, "CLAUDE.md")
+        : provider === "legna-code"
+            ? path.join(workspacePath, "LEGNA.md")
+            : null;
+    if (!defaultInstructionPath) {
         return null;
     }
-    const defaultClaudeInstructionPath = path.join(workspacePath, "CLAUDE.md");
-    return existsSync(defaultClaudeInstructionPath)
-        ? path.resolve(defaultClaudeInstructionPath)
+    return existsSync(defaultInstructionPath)
+        ? path.resolve(defaultInstructionPath)
         : null;
 }
 function buildClaudeHookBridgeConfig(config) {
@@ -2215,4 +2587,30 @@ function workspaceSlug(workspacePath) {
         .replaceAll("\\", "-")
         .replaceAll("/", "-");
 }
+function normalizeOptionalBindingValue(value) {
+    const normalized = value?.trim();
+    return normalized && normalized.length > 0 ? normalized : null;
+}
+function logOpenCodeOrderEnvelopeDebug(scope, detail) {
+    if (!OPENCODE_ORDER_DEBUG_ENABLED) {
+        return;
+    }
+    console.info(`[opencode-order-envelope] ${scope}`, {
+        timestamp: new Date().toISOString(),
+        ...detail
+    });
+}
+function summarizeOpenCodeOrderMessage(message) {
+    const content = typeof message.content === "string" ? message.content : "";
+    const normalized = content.replace(/\s+/g, " ").trim();
+    return {
+        messageId: message.messageId ?? null,
+        role: message.role ?? null,
+        kind: message.kind ?? null,
+        sequence: message.sequence ?? null,
+        timestamp: message.timestamp ?? null,
+        rawRef: message.rawRef ?? null,
+        contentPreview: normalized.length > 80 ? `${normalized.slice(0, 80)}...` : normalized
+    };
+}
 //# sourceMappingURL=session-live-runtime-service.js.map