@jingyi0605/codingns 0.6.0 → 0.6.5

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

@@ -1,17 +1,20 @@
-import { existsSync, readdirSync } from "node:fs";
+import { existsSync, mkdirSync, 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";
 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 { createProviderCapabilityBlockedError } from "../provider/provider-disabled.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 { buildClaudeCompatibleHookBridgeUrl, buildClaudeCompatibleRawStoreRef, buildClaudeCompatibleSessionTitle, findClaudeCompatibleSessionFile, isClaudeCompatibleProvider } from "./claude-compatible-provider-registry.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,7 +30,9 @@ export class SessionLiveRuntimeService {
     sessionIndexRepository;
     sessionStateRepository;
     sessionStatusSnapshotRepository;
+    sessionProviderConfigService;
     config;
+    openCliSessionPromptService;
     providerRuntimeService;
     sessionActivityAuthorityService;
     sessionPermissionRequestService;
@@ -42,7 +47,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(), openCliSessionPromptService = null) {
         this.sessionHistoryService = sessionHistoryService;
         this.sessionMessageAttachmentService = sessionMessageAttachmentService;
         this.workspaceService = workspaceService;
@@ -53,7 +58,9 @@ export class SessionLiveRuntimeService {
         this.sessionIndexRepository = sessionIndexRepository;
         this.sessionStateRepository = sessionStateRepository;
         this.sessionStatusSnapshotRepository = sessionStatusSnapshotRepository;
+        this.sessionProviderConfigService = sessionProviderConfigService;
         this.config = config;
+        this.openCliSessionPromptService = openCliSessionPromptService;
         this.sessionActivityAuthorityService = sessionActivityAuthorityService;
         this.sessionPermissionRequestService = new SessionPermissionRequestService(sessionHistoryService, sessionBindingRepository, authUserRepository, workspaceService, config, async (envelope) => {
             await this.emitExternalRuntimeEnvelope(envelope);
@@ -79,12 +86,25 @@ 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 resolvedProviderPrompt = this.composeProviderPrompt(input.provider, providerPrompt, providerLaunchContext.runtimeEnv);
             const providerInstructionFilePath = resolveRuntimeInstructionFilePath(input.provider, workspace.path, input.runtimeOptions?.providerInstructionFilePath ?? null);
-            this.ensureCapability(capabilities.canStartSession, "provider", "provider 不支持 start-live");
-            this.ensureCapability(capabilities.canSendMessage, "provider", "provider 不支持实时对话");
+            this.ensureCapability(capabilities, "provider", "canStartSession", "provider 不支持 start-live");
+            this.ensureCapability(capabilities, "provider", "canSendMessage", "provider 不支持实时对话");
             const launchRuntimeStartedAtMs = performance.now();
             const handle = await this.launchRuntimeRun({
                 sessionId,
@@ -93,6 +113,8 @@ export class SessionLiveRuntimeService {
                 provider: input.provider,
                 providerSessionId: null,
                 rawStoreRef: null,
+                runtimeHomeDir: providerLaunchContext.runtimeHomeDir,
+                runtimeEnv: providerLaunchContext.runtimeEnv,
                 sequenceBase: 1,
                 options: {
                     content: input.content,
@@ -100,11 +122,16 @@ export class SessionLiveRuntimeService {
                     model: input.runtimeOptions?.model ?? null,
                     reasoningLevel: input.runtimeOptions?.reasoningLevel ?? null,
                     permissionMode: input.runtimeOptions?.permissionMode ?? null,
-                    providerPrompt,
+                    providerPrompt: resolvedProviderPrompt,
                     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
             });
@@ -149,7 +176,7 @@ export class SessionLiveRuntimeService {
             if (!shouldAwaitStartBindingBeforeAcceptedUserLookup(input.provider)) {
                 void startBindingTask;
             }
-            const acceptedAt = acceptedMessage?.timestamp ?? nowIso();
+            const acceptedAt = acceptedMessage?.timestamp ?? requestStartedAt;
             const boundAttachments = this.sessionMessageAttachmentService.bindClientRequestToMessage(sessionId, input.clientRequestId, acceptedMessage?.messageId ?? null);
             const session = this.resolveStartedSession({
                 sessionId,
@@ -203,6 +230,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 = {
@@ -330,16 +358,25 @@ export class SessionLiveRuntimeService {
             deleted: true
         };
     }
-    getClaudeHookBridgeConfig() {
-        return buildClaudeHookBridgeConfig(this.config);
-    }
-    async ingestClaudeHookEvent(payload) {
-        const hookEventName = normalizeClaudeHookEventName(payload.hook_event_name);
+    getClaudeHookBridgeConfig(provider = "claude-code") {
+        return buildClaudeHookBridgeConfig(this.config, provider);
+    }
+    async ingestClaudeHookEvent(providerOrPayload, payload) {
+        const hasExplicitProvider = typeof providerOrPayload === "string"
+            && isClaudeCompatibleProvider(providerOrPayload);
+        const provider = hasExplicitProvider
+            ? providerOrPayload
+            : "claude-code";
+        const resolvedPayload = hasExplicitProvider
+            ? (payload ?? {})
+            : providerOrPayload;
+        const hookEventName = normalizeClaudeHookEventName(resolvedPayload.hook_event_name);
         logPermissionDebug("claude_hook_event.ingest.begin", {
+            provider,
             hookEventName,
-            sessionId: payload.session_id ?? null,
-            cwd: payload.cwd ?? null,
-            transcriptPath: payload.transcript_path ?? null
+            sessionId: resolvedPayload.session_id ?? null,
+            cwd: resolvedPayload.cwd ?? null,
+            transcriptPath: resolvedPayload.transcript_path ?? null
         });
         if (!hookEventName) {
             throw new AppError({
@@ -365,23 +402,23 @@ export class SessionLiveRuntimeService {
                 hookEventName,
                 route: "handleClaudePreToolUse"
             });
-            return this.sessionPermissionRequestService.handleClaudePreToolUse(payload);
+            return this.sessionPermissionRequestService.handleClaudePreToolUse(resolvedPayload, provider);
         }
         if (hookEventName === "PermissionRequest") {
             logPermissionDebug("claude_hook_event.route", {
                 hookEventName,
                 route: "handleClaudePermissionRequest"
             });
-            return this.sessionPermissionRequestService.handleClaudePermissionRequest(payload);
+            return this.sessionPermissionRequestService.handleClaudePermissionRequest(resolvedPayload, provider);
         }
-        const providerSessionId = normalizeRequiredText(payload.session_id, "session_id");
-        const workspacePath = normalizeRequiredText(payload.cwd, "cwd");
+        const providerSessionId = normalizeRequiredText(resolvedPayload.session_id, "session_id");
+        const workspacePath = normalizeRequiredText(resolvedPayload.cwd, "cwd");
         const workspace = this.workspaceService.findWorkspaceByPath(workspacePath);
         if (!workspace) {
             logPermissionDebug("claude_hook_event.workspace_not_found", {
                 hookEventName,
-                sessionId: payload.session_id ?? null,
-                cwd: payload.cwd ?? null
+                sessionId: resolvedPayload.session_id ?? null,
+                cwd: resolvedPayload.cwd ?? null
             });
             return {
                 accepted: true,
@@ -391,13 +428,14 @@ export class SessionLiveRuntimeService {
             };
         }
         const binding = await this.resolveClaudeExternalBinding({
+            provider,
             providerSessionId,
             workspaceId: workspace.id,
             workspacePath: workspace.path,
-            transcriptPath: normalizeOptionalText(payload.transcript_path)
+            transcriptPath: normalizeOptionalText(resolvedPayload.transcript_path)
         });
         const timestamp = nowIso();
-        const runtimeUpdate = mapClaudeHookToRuntimeUpdate(hookEventName, payload, timestamp);
+        const runtimeUpdate = mapClaudeHookToRuntimeUpdate(hookEventName, resolvedPayload, timestamp);
         logPermissionDebug("claude_hook_event.runtime_update", {
             hookEventName,
             sessionId: binding.sessionId,
@@ -422,6 +460,7 @@ export class SessionLiveRuntimeService {
             };
         }
         await this.applyExternalRuntimeUpdate({
+            provider,
             sessionId: binding.sessionId,
             workspaceId: workspace.id,
             providerSessionId,
@@ -483,7 +522,7 @@ export class SessionLiveRuntimeService {
         if (externalRuntimeSnapshot) {
             return {
                 sessionId,
-                provider: "claude-code",
+                provider: externalRuntimeSnapshot.provider,
                 providerSessionId: externalRuntimeSnapshot.providerSessionId,
                 runningState: resolution.runningState,
                 hasActiveRun: externalHasActiveRun,
@@ -649,6 +688,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) => {
@@ -867,10 +916,10 @@ export class SessionLiveRuntimeService {
     }
     async resolveClaudeExternalBinding(input) {
         const rawStoreRef = input.transcriptPath ??
-            findClaudeSessionFile(this.config.claudeCodeHomeDir, input.providerSessionId) ??
-            buildClaudeRawStoreRef(this.config.claudeCodeHomeDir, input.workspacePath, input.providerSessionId);
-        let binding = this.sessionBindingRepository.findByProviderSession("claude-code", input.providerSessionId) ??
-            this.sessionBindingRepository.findByRawStoreRef("claude-code", rawStoreRef);
+            findClaudeCompatibleSessionFile(this.config, input.provider, input.workspacePath, input.providerSessionId) ??
+            buildClaudeCompatibleRawStoreRef(this.config, input.provider, input.workspacePath, input.providerSessionId);
+        let binding = this.sessionBindingRepository.findByProviderSession(input.provider, input.providerSessionId) ??
+            this.sessionBindingRepository.findByRawStoreRef(input.provider, rawStoreRef);
         if (!binding) {
             const userIds = this.authUserRepository.listIds();
             const bootstrapUserId = userIds[0] ?? null;
@@ -883,8 +932,8 @@ export class SessionLiveRuntimeService {
                 });
             }
             binding =
-                this.sessionBindingRepository.findByProviderSession("claude-code", input.providerSessionId) ??
-                    this.sessionBindingRepository.findByRawStoreRef("claude-code", rawStoreRef);
+                this.sessionBindingRepository.findByProviderSession(input.provider, input.providerSessionId) ??
+                    this.sessionBindingRepository.findByRawStoreRef(input.provider, rawStoreRef);
         }
         if (binding) {
             return {
@@ -895,19 +944,19 @@ export class SessionLiveRuntimeService {
         const sessionId = createId();
         const timestamp = nowIso();
         this.sessionHistoryService.persistSessionBinding(sessionId, input.workspaceId, {
-            provider: "claude-code",
+            provider: input.provider,
             providerSessionId: input.providerSessionId,
             rawStoreRef
         });
         this.sessionIndexRepository.upsert({
             sessionId,
             workspaceId: input.workspaceId,
-            provider: "claude-code",
+            provider: input.provider,
             parentSessionId: null,
             sessionKind: "default",
             isSubagent: false,
             subagentLabel: null,
-            title: `Claude 会话 ${input.providerSessionId.slice(0, 8)}`,
+            title: buildClaudeCompatibleSessionTitle(input.provider, input.providerSessionId),
             messageCount: 0,
             isArchived: false,
             lastMessageAt: null,
@@ -988,7 +1037,7 @@ export class SessionLiveRuntimeService {
         if (input.runningState === "running") {
             this.externalRuntimeSnapshots.set(input.sessionId, {
                 sessionId: input.sessionId,
-                provider: "claude-code",
+                provider: input.provider,
                 providerSessionId: input.providerSessionId,
                 rawStoreRef: input.rawStoreRef,
                 runningState: input.runningState,
@@ -1027,14 +1076,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") {
+        if (isClaudeCompatibleProvider(request.provider)) {
             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,24 +1115,61 @@ 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 && isClaudeCompatibleProvider(activeRun?.provider)) {
+                this.clearExternalRuntimeSnapshot(runtimeSessionId);
+            }
+            if (hasActiveRun
+                || (!activeRun &&
+                    isClaudeCompatibleProvider(session.provider) &&
+                    externalRuntimeSnapshot &&
+                    isActiveRuntimeState(externalRuntimeSnapshot.runningState))) {
+                this.assertProviderBindingStableDuringActiveRun(existingBinding, resolvedProviderBinding);
+            }
+            if (!activeRun &&
+                isClaudeCompatibleProvider(session.provider) &&
+                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);
             const resolvedAttachments = persistedAttachments
                 ?? this.persistMessageAttachments(input.sessionId, input.clientRequestId, input.runtimeOptions?.attachments ?? []);
             const providerPrompt = this.sessionMessageAttachmentService.buildProviderPrompt(session.provider, input.content, resolvedAttachments.runtimeAttachments);
+            const resolvedProviderPrompt = this.composeProviderPrompt(session.provider, providerPrompt, providerLaunchContext.runtimeEnv);
             const providerInstructionFilePath = resolveRuntimeInstructionFilePath(session.provider, workspace.path, input.runtimeOptions?.providerInstructionFilePath ?? null);
-            this.ensureCapability(capabilities.canSendMessage, "sessionId", "provider 不支持实时对话");
+            this.ensureCapability(capabilities, "sessionId", "canSendMessage", "provider 不支持实时对话");
             const runtimeRequest = {
                 sessionId: input.sessionId,
                 workspaceId: session.workspaceId,
                 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,
@@ -1091,31 +1177,12 @@ export class SessionLiveRuntimeService {
                     model: input.runtimeOptions?.model ?? null,
                     reasoningLevel: input.runtimeOptions?.reasoningLevel ?? null,
                     permissionMode: input.runtimeOptions?.permissionMode ?? null,
-                    providerPrompt,
+                    providerPrompt: resolvedProviderPrompt,
                     providerInstructionFilePath,
                     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 +1192,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 +1220,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
                 });
@@ -1154,7 +1236,7 @@ export class SessionLiveRuntimeService {
             this.logSendDebugStep(debugTrace, "accepted_user_lookup", acceptedLookupStartedAtMs, {
                 matched: Boolean(acceptedMessage)
             });
-            const acceptedAt = acceptedMessage?.timestamp ?? nowIso();
+            const acceptedAt = acceptedMessage?.timestamp ?? requestStartedAt;
             this.sessionHistoryService.resolveMessageOriginByClientRequestId(input.sessionId, input.clientRequestId, acceptedMessage?.messageId ?? null, acceptedAt);
             const boundAttachments = this.sessionMessageAttachmentService.bindClientRequestToMessage(input.sessionId, input.clientRequestId, acceptedMessage?.messageId ?? null);
             this.refreshSyntheticSessionTitle(session, input.content, input.userId);
@@ -1186,6 +1268,20 @@ export class SessionLiveRuntimeService {
             throw error;
         }
     }
+    composeProviderPrompt(provider, basePrompt, runtimeEnv) {
+        const openCliPrompt = this.openCliSessionPromptService?.buildPrompt({
+            provider,
+            runtimeEnv
+        }) ?? null;
+        if (!openCliPrompt) {
+            return basePrompt;
+        }
+        const normalizedBasePrompt = basePrompt?.trim() ?? "";
+        if (!normalizedBasePrompt) {
+            return openCliPrompt;
+        }
+        return `${normalizedBasePrompt}\n\n${openCliPrompt}`;
+    }
     async dispatchNextQueuedMessage(sessionId) {
         if (this.queueDispatchSessions.has(sessionId)) {
             return;
@@ -1263,7 +1359,7 @@ export class SessionLiveRuntimeService {
         if (externalRuntimeSnapshot && isActiveRuntimeState(externalRuntimeSnapshot.runningState)) {
             return true;
         }
-        if (session.provider === "claude-code" && isPendingSessionRunningState(session.runningState)) {
+        if (isClaudeCompatibleProvider(session.provider) && isPendingSessionRunningState(session.runningState)) {
             return true;
         }
         return false;
@@ -1291,7 +1387,7 @@ export class SessionLiveRuntimeService {
     }
     async resolveQueueDispatchSession(sessionId, userId) {
         const session = this.sessionHistoryService.getSession(sessionId, userId);
-        if (session.provider !== "claude-code"
+        if (!isClaudeCompatibleProvider(session.provider)
             || !isPendingSessionRunningState(session.runningState)) {
             return session;
         }
@@ -1305,14 +1401,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 +1490,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 +1963,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 +1972,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) {
@@ -1859,7 +2063,7 @@ export class SessionLiveRuntimeService {
         };
     }
     async maybeEmitRuntimeHistoryFallback(sessionId, event) {
-        if (event.provider !== "claude-code") {
+        if (!isClaudeCompatibleProvider(event.provider)) {
             return;
         }
         if (event.status === "starting") {
@@ -1880,16 +2084,11 @@ export class SessionLiveRuntimeService {
         this.runtimeHistoryFallbackSentSessions.add(sessionId);
         await this.emitExternalRuntimeEnvelope(envelope);
     }
-    ensureCapability(enabled, field, detail) {
-        if (enabled) {
+    ensureCapability(capabilities, field, capability, detail) {
+        if (capabilities[capability]) {
             return;
         }
-        throw new AppError({
-            statusCode: 400,
-            errorCode: "CAPABILITY_NOT_SUPPORTED",
-            detail,
-            field
-        });
+        throw createProviderCapabilityBlockedError(capabilities, field, detail);
     }
     upsertSnapshot(sessionId, input) {
         this.sessionStatusSnapshotRepository.upsert({
@@ -1901,7 +2100,7 @@ export class SessionLiveRuntimeService {
     shouldIgnoreClaudeExternalRuntimeUpdate(sessionId) {
         const runtimeSnapshot = this.getLiveRuntimeSnapshot(sessionId);
         return Boolean(runtimeSnapshot &&
-            runtimeSnapshot.provider === "claude-code" &&
+            isClaudeCompatibleProvider(runtimeSnapshot.provider) &&
             isActiveRuntimeState(runtimeSnapshot.runningState));
     }
     clearExternalRuntimeSnapshot(sessionId) {
@@ -1943,7 +2142,7 @@ export class SessionLiveRuntimeService {
     async resolveActiveClaudePermissionSession(input) {
         const activeSnapshots = this.providerRuntimeService
             .listSnapshots()
-            .filter((snapshot) => snapshot.provider === "claude-code" &&
+            .filter((snapshot) => snapshot.provider === input.provider &&
             snapshot.workspaceId === input.workspaceId &&
             isActiveRuntimeState(snapshot.runningState));
         if (activeSnapshots.length !== 1) {
@@ -1955,9 +2154,9 @@ export class SessionLiveRuntimeService {
         }
         const rawStoreRef = input.transcriptPath ??
             activeSnapshot.rawStoreRef ??
-            buildClaudeRawStoreRef(this.config.claudeCodeHomeDir, input.workspacePath, input.providerSessionId);
+            buildClaudeCompatibleRawStoreRef(this.config, input.provider, input.workspacePath, input.providerSessionId);
         this.sessionHistoryService.persistSessionBinding(activeSnapshot.sessionId, input.workspaceId, {
-            provider: "claude-code",
+            provider: input.provider,
             providerSessionId: input.providerSessionId,
             rawStoreRef
         });
@@ -2272,7 +2471,8 @@ function waitForAcceptedUserLookupWindow() {
     });
 }
 function createProviderRuntimeAdapters(config, options = {}) {
-    const claudeHookBridgeConfig = buildClaudeHookBridgeConfig(config);
+    const claudeHookBridgeConfig = buildClaudeHookBridgeConfig(config, "claude-code");
+    const legnaHookBridgeConfig = buildClaudeHookBridgeConfig(config, "legna-code");
     const claudeAdapter = process.env.VITEST
         ? new ClaudeRuntimeAdapter({
             homeDir: config.claudeCodeHomeDir,
@@ -2294,21 +2494,38 @@ 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,
+                hookBridge: {
+                    url: legnaHookBridgeConfig.bridgeUrl,
+                    token: config.claudeHookBridgeToken,
+                    scriptPath: legnaHookBridgeConfig.scriptPath
+                }
+            }),
             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,20 +2550,27 @@ function resolveRuntimeInstructionFilePath(provider, workspacePath, explicitFile
         const resolvedExplicit = path.resolve(normalizedExplicit);
         return existsSync(resolvedExplicit) ? resolvedExplicit : null;
     }
-    if (provider !== "claude-code") {
+    const defaultInstructionFileNames = {
+        "claude-code": "CLAUDE.md",
+        "legna-code": "LEGNA.md"
+    };
+    const defaultInstructionFileName = defaultInstructionFileNames[provider];
+    const defaultInstructionPath = defaultInstructionFileName
+        ? path.join(workspacePath, defaultInstructionFileName)
+        : 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) {
-    const bridgeUrl = `http://127.0.0.1:${config.port}/api/providers/claude-code/hook-bridge/events`;
+function buildClaudeHookBridgeConfig(config, provider) {
+    const bridgeUrl = buildClaudeCompatibleHookBridgeUrl(config, provider);
     const scriptPath = resolveClaudeHookBridgeScriptPath();
     const command = `node "${scriptPath}" --url "${bridgeUrl}" --token "${config.claudeHookBridgeToken}"`;
     return {
-        provider: "claude-code",
+        provider,
         bridgeUrl,
         token: config.claudeHookBridgeToken,
         scriptPath,
@@ -2376,26 +2600,30 @@ function resolveClaudeHookBridgeScriptPath() {
     }
     return candidates[0];
 }
-function buildClaudeRawStoreRef(homeDir, workspacePath, sessionId) {
-    return path.join(homeDir, "projects", workspaceSlug(workspacePath), `${sessionId}.jsonl`);
+function normalizeOptionalBindingValue(value) {
+    const normalized = value?.trim();
+    return normalized && normalized.length > 0 ? normalized : null;
 }
-function findClaudeSessionFile(homeDir, sessionId) {
-    const projectsDir = path.join(homeDir, "projects");
-    if (!existsSync(projectsDir)) {
-        return null;
+function logOpenCodeOrderEnvelopeDebug(scope, detail) {
+    if (!OPENCODE_ORDER_DEBUG_ENABLED) {
+        return;
     }
-    const candidates = readdirSync(projectsDir, { withFileTypes: true })
-        .filter((entry) => entry.isDirectory())
-        .map((entry) => path.join(projectsDir, entry.name, `${sessionId}.jsonl`))
-        .filter((candidate) => existsSync(candidate));
-    return candidates[0] ?? null;
+    console.info(`[opencode-order-envelope] ${scope}`, {
+        timestamp: new Date().toISOString(),
+        ...detail
+    });
 }
-function workspaceSlug(workspacePath) {
-    const trimmed = workspacePath.replace(/[\\/]+$/, "");
-    const normalizedDriveLetter = trimmed.replace(/^[A-Z](?=:)/, (value) => value.toLowerCase());
-    return normalizedDriveLetter
-        .replaceAll(":", "-")
-        .replaceAll("\\", "-")
-        .replaceAll("/", "-");
+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