@jingyi0605/codingns 0.6.0 → 0.6.1

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

@@ -6,7 +6,7 @@ import type { SessionIndexRepository } from "../../storage/repositories/session-
 import type { SessionSendQueueRepository } from "../../storage/repositories/session-send-queue-repository.js";
 import type { SessionStateRepository } from "../../storage/repositories/session-state-repository.js";
 import type { SessionStatusSnapshotRepository } from "../../storage/repositories/session-status-snapshot-repository.js";
-import type { SessionActivityConfidence, SessionInterruptSource, SessionActivityResolutionSource, SessionListItem, SessionResolvedRunningState, SessionSendQueueItemRecord } from "../../types/domain.js";
+import type { SessionActivityConfidence, SessionInterruptSource, SessionActivityResolutionSource, SessionListItem, SessionProviderConfigMode, SessionResolvedRunningState, SessionSendQueueItemRecord } from "../../types/domain.js";
 import { SessionActivityAuthorityService, type SessionActivityObservation } from "./session-activity-authority-service.js";
 import { SessionChangedFileService } from "./session-changed-file-service.js";
 import type { WorkspaceService } from "../workspace/workspace-service.js";
@@ -14,6 +14,7 @@ import type { SessionAttachmentInput } from "./session-message-attachment-servic
 import { SessionMessageAttachmentService } from "./session-message-attachment-service.js";
 import { type SessionPermissionEnvelope, type SessionPermissionReplyInput, type SessionPermissionRequestView } from "./session-permission-request-service.js";
 import type { SessionHistoryEnvelope, SessionHistoryMessageWithOrigin, SessionHistoryService } from "./session-history-service.js";
+import { SessionProviderConfigService } from "./session-provider-config-service.js";
 interface RuntimeSendOptions {
     model?: string | null;
     reasoningLevel?: string | null;
@@ -31,6 +32,8 @@ interface StartLiveSessionInput {
     sessionKind?: "default" | "annotation";
     annotationSourceMessageId?: string | null;
     annotationSourceText?: string | null;
+    providerConfigMode?: SessionProviderConfigMode;
+    providerPresetId?: string | null;
     runtimeOptions?: RuntimeSendOptions;
 }
 interface SendLiveMessageInput {
@@ -38,6 +41,8 @@ interface SendLiveMessageInput {
     userId: string;
     content: string;
     clientRequestId: string | null;
+    providerConfigMode?: SessionProviderConfigMode;
+    providerPresetId?: string | null;
     runtimeOptions?: RuntimeSendOptions;
 }
 interface LiveMessageAcceptedResult {
@@ -181,6 +186,7 @@ export declare class SessionLiveRuntimeService {
     private readonly sessionIndexRepository;
     private readonly sessionStateRepository;
     private readonly sessionStatusSnapshotRepository;
+    private readonly sessionProviderConfigService;
     private readonly config;
     private readonly providerRuntimeService;
     private readonly sessionActivityAuthorityService;
@@ -196,7 +202,7 @@ export declare class SessionLiveRuntimeService {
     private readonly queueDispatchSessions;
     private readonly queueRetryTimers;
     private readonly pendingSendDebugTracesBySessionId;
-    constructor(sessionHistoryService: SessionHistoryService, sessionMessageAttachmentService: SessionMessageAttachmentService, workspaceService: WorkspaceService, sessionChangedFileService: SessionChangedFileService, sessionBindingRepository: SessionBindingRepository, authUserRepository: AuthUserRepository, sessionSendQueueRepository: SessionSendQueueRepository, sessionIndexRepository: SessionIndexRepository, sessionStateRepository: SessionStateRepository, sessionStatusSnapshotRepository: SessionStatusSnapshotRepository, config: HostConfig, sessionActivityAuthorityService?: SessionActivityAuthorityService);
+    constructor(sessionHistoryService: SessionHistoryService, sessionMessageAttachmentService: SessionMessageAttachmentService, workspaceService: WorkspaceService, sessionChangedFileService: SessionChangedFileService, sessionBindingRepository: SessionBindingRepository, authUserRepository: AuthUserRepository, sessionSendQueueRepository: SessionSendQueueRepository, sessionIndexRepository: SessionIndexRepository, sessionStateRepository: SessionStateRepository, sessionStatusSnapshotRepository: SessionStatusSnapshotRepository, sessionProviderConfigService: SessionProviderConfigService, config: HostConfig, sessionActivityAuthorityService?: SessionActivityAuthorityService);
     startLiveSession(input: StartLiveSessionInput): Promise<LiveMessageAcceptedResult>;
     sendLiveMessage(input: SendLiveMessageInput): Promise<LiveMessageAcceptedResult>;
     listQueuedMessages(sessionId: string, userId: string): Promise<SessionQueueItemView[]>;
@@ -244,6 +250,13 @@ export declare class SessionLiveRuntimeService {
     private resolveStartedSession;
     private upsertRuntimeBackedSessionRecords;
     private ensurePendingSessionBinding;
+    private resolveEffectiveSessionProviderBinding;
+    private getSessionBindingOrThrow;
+    private resolveRequestedSessionProviderBinding;
+    private persistResolvedSessionProviderBinding;
+    private assertProviderBindingStableDuringActiveRun;
+    private hasSessionProviderBindingChanged;
+    private resolveCodexRuntimeRequestRawStoreRef;
     private buildBindingSnapshot;
     private persistRuntimeEvent;
     private emitTerminalStateEvent;

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,9 +9,10 @@ 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;
@@ -27,6 +28,7 @@ export class SessionLiveRuntimeService {
     sessionIndexRepository;
     sessionStateRepository;
     sessionStatusSnapshotRepository;
+    sessionProviderConfigService;
     config;
     providerRuntimeService;
     sessionActivityAuthorityService;
@@ -42,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;
@@ -53,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) => {
@@ -79,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);
@@ -93,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,
@@ -104,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
             });
@@ -203,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 = {
@@ -649,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) => {
@@ -1027,14 +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);
@@ -1066,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);
@@ -1083,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,
@@ -1096,26 +1165,7 @@ export class SessionLiveRuntimeService {
                     attachments: resolvedAttachments.runtimeAttachments
                 }
             };
-            const runtimeSessionId = this.resolveRuntimeSessionId(input.sessionId);
-            const activeRun = this.getLiveRuntimeSnapshot(runtimeSessionId);
-            const externalRuntimeSnapshot = this.getFreshExternalRuntimeSnapshot(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);
@@ -1125,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
                         });
@@ -1143,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
                 });
@@ -1305,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) {
@@ -1390,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}`;
@@ -1762,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;
         });
@@ -1771,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) {
@@ -2294,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({
@@ -2333,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) {
@@ -2398,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