@jingyi0605/codingns 0.1.4 → 0.2.0

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

@@ -1,8 +1,10 @@
 import { existsSync, readdirSync } from "node:fs";
 import path from "node:path";
-import { ClaudeRuntimeAdapter, CodexRuntimeAdapter, OpenCodeRuntimeAdapter, ProviderRuntimeService } from "@codingns/session-sync-core";
+import { performance } from "node:perf_hooks";
+import { ClaudeRuntimeAdapter, CodexRuntimeAdapter, GeminiRuntimeAdapter, KimiRuntimeAdapter, OpenCodeRuntimeAdapter, ProviderRuntimeService } from "@codingns/session-sync-core";
 import { AppError } 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";
@@ -10,6 +12,8 @@ import { SessionPermissionRequestService } from "./session-permission-request-se
 import { 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 RUNTIME_START_BINDING_WAIT_TIMEOUT_MS = 10_000;
+const START_BINDING_POLL_INTERVAL_MS = 50;
 export class SessionLiveRuntimeService {
     sessionHistoryService;
     sessionMessageAttachmentService;
@@ -28,10 +32,12 @@ export class SessionLiveRuntimeService {
     runtimeAdapterDisposables;
     externalRuntimeSnapshots = new Map();
     runtimeListeners = new Map();
+    terminalStateListeners = new Set();
     runtimeMessageSeenSessions = new Set();
     runtimeHistoryFallbackSentSessions = new Set();
     queueDispatchSessions = new Set();
     queueRetryTimers = new Map();
+    pendingSendDebugTracesBySessionId = new Map();
     constructor(sessionHistoryService, sessionMessageAttachmentService, workspaceService, sessionChangedFileService, sessionBindingRepository, authUserRepository, sessionSendQueueRepository, sessionIndexRepository, sessionStateRepository, sessionStatusSnapshotRepository, config, sessionActivityAuthorityService = new SessionActivityAuthorityService()) {
         this.sessionHistoryService = sessionHistoryService;
         this.sessionMessageAttachmentService = sessionMessageAttachmentService;
@@ -58,63 +64,113 @@ export class SessionLiveRuntimeService {
     }
     async startLiveSession(input) {
         const requestStartedAt = nowIso();
-        const capabilities = this.sessionHistoryService.getProviderCapabilitiesSnapshot(input.provider);
-        const workspace = this.workspaceService.getWorkspaceOrThrow(input.workspaceId);
         const sessionId = createId();
-        this.ensurePendingSessionBinding(sessionId, workspace.id, input.provider);
-        const persistedAttachments = this.persistMessageAttachments(sessionId, input.clientRequestId, input.runtimeOptions?.attachments ?? []);
-        const providerPrompt = this.sessionMessageAttachmentService.buildProviderPrompt(input.provider, input.content, persistedAttachments.runtimeAttachments);
-        this.ensureCapability(capabilities.canStartSession, "provider", "provider 不支持 start-live");
-        this.ensureCapability(capabilities.canSendMessage, "provider", "provider 不支持实时对话");
-        const handle = await this.launchRuntimeRun({
-            sessionId,
-            workspaceId: workspace.id,
-            workspacePath: workspace.path,
-            provider: input.provider,
-            providerSessionId: null,
-            rawStoreRef: null,
-            sequenceBase: 1,
-            options: {
-                content: input.content,
-                clientRequestId: input.clientRequestId,
-                model: input.runtimeOptions?.model ?? null,
-                reasoningLevel: input.runtimeOptions?.reasoningLevel ?? null,
-                permissionMode: input.runtimeOptions?.permissionMode ?? null,
-                providerPrompt,
-                attachments: persistedAttachments.runtimeAttachments
-            }
-        }, "start");
-        const snapshot = handle.getSnapshot();
-        this.attachRuntimePersistence(handle, sessionId, workspace.id, input.userId);
-        this.createRuntimeBackedSession({
+        const workspace = this.workspaceService.getWorkspaceOrThrow(input.workspaceId);
+        const debugTrace = this.beginPendingSendDebugTrace({
+            mode: "start_live",
             sessionId,
             workspaceId: workspace.id,
-            userId: input.userId,
             provider: input.provider,
-            initialContent: input.content,
-            snapshot
+            clientRequestId: input.clientRequestId
         });
-        const binding = this.sessionHistoryService.getBindingOrThrow(sessionId);
-        const acceptedMessage = await this.findAcceptedUserMessage(sessionId, this.sessionMessageAttachmentService.buildAcceptedContentCandidates(input.content, providerPrompt), requestStartedAt);
-        const acceptedAt = acceptedMessage?.timestamp ?? nowIso();
-        const boundAttachments = this.sessionMessageAttachmentService.bindClientRequestToMessage(sessionId, input.clientRequestId, acceptedMessage?.messageId ?? null);
-        return {
-            sessionId,
-            provider: input.provider,
-            providerSessionId: binding.providerSessionId,
-            acceptedAt,
-            clientRequestId: input.clientRequestId,
-            message: (acceptedMessage
-                ? {
-                    ...acceptedMessage,
-                    attachments: boundAttachments
+        try {
+            const capabilities = this.sessionHistoryService.getProviderCapabilitiesSnapshot(input.provider);
+            this.ensurePendingSessionBinding(sessionId, workspace.id, input.provider);
+            const persistedAttachments = this.persistMessageAttachments(sessionId, input.clientRequestId, input.runtimeOptions?.attachments ?? []);
+            const providerPrompt = this.sessionMessageAttachmentService.buildProviderPrompt(input.provider, input.content, persistedAttachments.runtimeAttachments);
+            this.ensureCapability(capabilities.canStartSession, "provider", "provider 不支持 start-live");
+            this.ensureCapability(capabilities.canSendMessage, "provider", "provider 不支持实时对话");
+            const launchRuntimeStartedAtMs = performance.now();
+            const handle = await this.launchRuntimeRun({
+                sessionId,
+                workspaceId: workspace.id,
+                workspacePath: workspace.path,
+                provider: input.provider,
+                providerSessionId: null,
+                rawStoreRef: null,
+                sequenceBase: 1,
+                options: {
+                    content: input.content,
+                    clientRequestId: input.clientRequestId,
+                    model: input.runtimeOptions?.model ?? null,
+                    reasoningLevel: input.runtimeOptions?.reasoningLevel ?? null,
+                    permissionMode: input.runtimeOptions?.permissionMode ?? null,
+                    providerPrompt,
+                    attachments: persistedAttachments.runtimeAttachments
                 }
-                : null) ??
-                createSyntheticUserMessage(input.provider, binding.providerSessionId, input.content, acceptedAt, 1, boundAttachments.length > 0
-                    ? boundAttachments
-                    : persistedAttachments.messageAttachments),
-            session: this.sessionHistoryService.getSession(sessionId, input.userId)
-        };
+            }, "start");
+            this.logSendDebugStep(debugTrace, "launch_runtime", launchRuntimeStartedAtMs, {
+                userId: input.userId
+            });
+            const snapshot = handle.getSnapshot();
+            this.attachRuntimePersistence(handle, sessionId, workspace.id, input.userId);
+            this.createRuntimeBackedSession({
+                sessionId,
+                workspaceId: workspace.id,
+                userId: input.userId,
+                provider: input.provider,
+                parentSessionId: input.parentSessionId ?? null,
+                sessionKind: input.sessionKind ?? "default",
+                annotationSourceMessageId: input.annotationSourceMessageId ?? null,
+                annotationSourceText: input.annotationSourceText ?? null,
+                initialContent: input.content,
+                snapshot
+            });
+            const startBindingTask = this.waitForResolvedStartBinding(sessionId, workspace.id, input.provider, handle).catch(() => {
+                return;
+            });
+            if (shouldAwaitStartBindingBeforeAcceptedUserLookup(input.provider)) {
+                const bindingWaitStartedAtMs = performance.now();
+                await Promise.race([
+                    startBindingTask,
+                    waitForAcceptedUserLookupWindow()
+                ]);
+                this.logSendDebugStep(debugTrace, "binding_wait", bindingWaitStartedAtMs, {
+                    provider: input.provider
+                });
+            }
+            const binding = this.sessionHistoryService.getBindingOrThrow(sessionId);
+            const acceptedLookupStartedAtMs = performance.now();
+            const acceptedMessage = shouldAwaitAcceptedUserMessage(input.provider)
+                ? await this.findAcceptedUserMessage(sessionId, this.sessionMessageAttachmentService.buildAcceptedContentCandidates(input.content, providerPrompt), requestStartedAt)
+                : null;
+            this.logSendDebugStep(debugTrace, "accepted_user_lookup", acceptedLookupStartedAtMs, {
+                awaited: shouldAwaitAcceptedUserMessage(input.provider),
+                matched: Boolean(acceptedMessage)
+            });
+            if (!shouldAwaitStartBindingBeforeAcceptedUserLookup(input.provider)) {
+                void startBindingTask;
+            }
+            const acceptedAt = acceptedMessage?.timestamp ?? nowIso();
+            const boundAttachments = this.sessionMessageAttachmentService.bindClientRequestToMessage(sessionId, input.clientRequestId, acceptedMessage?.messageId ?? null);
+            const session = this.sessionHistoryService.getSession(sessionId, input.userId);
+            this.markSendDebugResponseReady(debugTrace, {
+                returnedAcceptedMessage: Boolean(acceptedMessage),
+                returnedSyntheticUser: !acceptedMessage,
+                providerSessionId: binding.providerSessionId
+            });
+            return {
+                sessionId: session.sessionId,
+                provider: input.provider,
+                providerSessionId: binding.providerSessionId,
+                acceptedAt,
+                clientRequestId: input.clientRequestId,
+                message: (acceptedMessage
+                    ? {
+                        ...acceptedMessage,
+                        attachments: boundAttachments
+                    }
+                    : null) ??
+                    createSyntheticUserMessage(input.provider, binding.providerSessionId, input.content, acceptedAt, 1, boundAttachments.length > 0
+                        ? boundAttachments
+                        : persistedAttachments.messageAttachments),
+                session
+            };
+        }
+        catch (error) {
+            this.failPendingSendDebugTrace(debugTrace, error);
+            throw error;
+        }
     }
     async sendLiveMessage(input) {
         return this.sendLiveMessageDirect(input);
@@ -169,7 +225,8 @@ export class SessionLiveRuntimeService {
                 field: "queueItemId"
             });
         }
-        const runtimeSnapshot = this.providerRuntimeService.getSnapshot(sessionId);
+        const runtimeSessionId = this.resolveRuntimeSessionId(sessionId);
+        const runtimeSnapshot = this.providerRuntimeService.getSnapshot(runtimeSessionId);
         if (!runtimeSnapshot || !isActiveRuntimeState(runtimeSnapshot.runningState)) {
             throw new AppError({
                 statusCode: 409,
@@ -225,7 +282,7 @@ export class SessionLiveRuntimeService {
             };
         }
         catch (error) {
-            if (isQueueDispatchDeferredError(error)) {
+            if (isQueueDispatchRetryableError(error)) {
                 this.sessionSendQueueRepository.markQueued(queueItem.id, nowIso());
                 this.scheduleQueueRetry(sessionId);
             }
@@ -368,8 +425,9 @@ export class SessionLiveRuntimeService {
         };
     }
     async getSessionRuntime(sessionId, userId) {
-        const runtimeSnapshot = this.providerRuntimeService.getSnapshot(sessionId);
-        const externalRuntimeSnapshot = this.externalRuntimeSnapshots.get(sessionId) ?? null;
+        const runtimeSessionId = this.resolveRuntimeSessionId(sessionId);
+        const runtimeSnapshot = this.providerRuntimeService.getSnapshot(runtimeSessionId);
+        const externalRuntimeSnapshot = this.externalRuntimeSnapshots.get(runtimeSessionId) ?? null;
         const session = runtimeSnapshot || externalRuntimeSnapshot
             ? this.sessionHistoryService.getSession(sessionId, userId)
             : await this.sessionHistoryService.refreshRuntimeFallbackSession(sessionId, userId);
@@ -377,9 +435,9 @@ export class SessionLiveRuntimeService {
         const capabilities = await this.sessionHistoryService.getSessionCapabilities(sessionId);
         const contextUsage = await this.sessionHistoryService.getSessionContextUsage(sessionId).catch(() => null);
         const resolution = runtimeSnapshot
-            ? this.sessionActivityAuthorityService.observe(createRuntimeActivityObservation(sessionId, runtimeSnapshot))
+            ? this.sessionActivityAuthorityService.observe(createRuntimeActivityObservation(runtimeSessionId, runtimeSnapshot))
             : externalRuntimeSnapshot
-                ? this.sessionActivityAuthorityService.observe(createExternalRuntimeActivityObservation(sessionId, externalRuntimeSnapshot))
+                ? this.sessionActivityAuthorityService.observe(createExternalRuntimeActivityObservation(runtimeSessionId, externalRuntimeSnapshot))
                 : this.sessionActivityAuthorityService.resolvePersistedSession(session);
         if (runtimeSnapshot) {
             return {
@@ -451,7 +509,8 @@ export class SessionLiveRuntimeService {
     }
     async interruptSession(sessionId, userId) {
         this.sessionHistoryService.getSession(sessionId, userId);
-        const runtime = this.providerRuntimeService.getSnapshot(sessionId);
+        const runtimeSessionId = this.resolveRuntimeSessionId(sessionId);
+        const runtime = this.providerRuntimeService.getSnapshot(runtimeSessionId);
         if (!runtime || (runtime.runningState !== "running" && runtime.runningState !== "starting")) {
             throw new AppError({
                 statusCode: 409,
@@ -460,7 +519,7 @@ export class SessionLiveRuntimeService {
                 field: "sessionId"
             });
         }
-        const interrupted = await this.providerRuntimeService.interrupt(sessionId).catch((error) => {
+        const interrupted = await this.providerRuntimeService.interrupt(runtimeSessionId).catch((error) => {
             if (error instanceof Error && error.message === "INTERRUPT_NOT_SUPPORTED") {
                 throw new AppError({
                     statusCode: 400,
@@ -477,6 +536,14 @@ export class SessionLiveRuntimeService {
             detail: interrupted.detail ?? "interrupt requested"
         };
     }
+    registerTerminalStateListener(listener) {
+        this.terminalStateListeners.add(listener);
+        return {
+            close: () => {
+                this.terminalStateListeners.delete(listener);
+            }
+        };
+    }
     async listPermissionRequests(sessionId, userId) {
         return this.sessionPermissionRequestService.listSessionPermissionRequests(sessionId, userId);
     }
@@ -484,9 +551,10 @@ export class SessionLiveRuntimeService {
         return this.sessionPermissionRequestService.replyToSessionPermissionRequest(sessionId, userId, requestId, input);
     }
     subscribeRuntime(sessionId, onEnvelope) {
-        const runtimeSnapshot = this.providerRuntimeService.getSnapshot(sessionId);
-        const externalRuntimeSnapshot = this.externalRuntimeSnapshots.get(sessionId) ?? null;
-        const initialActivityEnvelope = this.buildSessionActivityEnvelope(sessionId);
+        const runtimeSessionId = this.resolveRuntimeSessionId(sessionId);
+        const runtimeSnapshot = this.providerRuntimeService.getSnapshot(runtimeSessionId);
+        const externalRuntimeSnapshot = this.externalRuntimeSnapshots.get(runtimeSessionId) ?? null;
+        const initialActivityEnvelope = this.buildSessionActivityEnvelope(sessionId, runtimeSessionId);
         if (runtimeSnapshot) {
             void onEnvelope({
                 type: "session.runtime_status",
@@ -508,16 +576,21 @@ export class SessionLiveRuntimeService {
         if (initialActivityEnvelope) {
             void onEnvelope(initialActivityEnvelope);
         }
-        const runtimeSubscription = this.providerRuntimeService.subscribe(sessionId, async (event) => {
-            const envelope = this.mapRuntimeEventToEnvelope(sessionId, event);
+        const runtimeSubscription = this.providerRuntimeService.subscribe(runtimeSessionId, async (event) => {
+            const envelope = this.mapRuntimeEventToEnvelope(sessionId, event, runtimeSessionId);
             if (!envelope) {
                 return;
             }
             await onEnvelope(envelope);
         });
-        const externalSubscription = this.subscribeExternalRuntime(sessionId, onEnvelope);
-        const activitySubscription = this.sessionActivityAuthorityService.subscribe(sessionId, async () => {
-            const envelope = this.buildSessionActivityEnvelope(sessionId);
+        const externalSubscription = this.subscribeExternalRuntime(runtimeSessionId, async (envelope) => {
+            await onEnvelope({
+                ...envelope,
+                sessionId
+            });
+        });
+        const activitySubscription = this.sessionActivityAuthorityService.subscribe(runtimeSessionId, async () => {
+            const envelope = this.buildSessionActivityEnvelope(sessionId, runtimeSessionId);
             if (!envelope) {
                 return;
             }
@@ -578,31 +651,67 @@ export class SessionLiveRuntimeService {
             await listener(envelope);
         }));
     }
-    buildSessionActivityEnvelope(sessionId) {
-        const runtimeSnapshot = this.providerRuntimeService.getSnapshot(sessionId);
+    buildSessionActivityEnvelope(sessionId, runtimeSessionId = sessionId) {
+        const runtimeSnapshot = this.providerRuntimeService.getSnapshot(runtimeSessionId);
         if (runtimeSnapshot) {
-            const resolution = this.sessionActivityAuthorityService.observe(createRuntimeActivityObservation(sessionId, runtimeSnapshot));
-            return this.mapResolutionToActivityEnvelope(resolution, {
-                hasActiveRun: true,
-                canInterrupt: runtimeSnapshot.supportsInterrupt
-            });
+            const resolution = this.sessionActivityAuthorityService.observe(createRuntimeActivityObservation(runtimeSessionId, runtimeSnapshot));
+            return {
+                ...this.mapResolutionToActivityEnvelope(resolution, {
+                    hasActiveRun: true,
+                    canInterrupt: runtimeSnapshot.supportsInterrupt
+                }),
+                sessionId
+            };
         }
-        const externalRuntimeSnapshot = this.externalRuntimeSnapshots.get(sessionId) ?? null;
+        const externalRuntimeSnapshot = this.externalRuntimeSnapshots.get(runtimeSessionId) ?? null;
         if (externalRuntimeSnapshot) {
-            const resolution = this.sessionActivityAuthorityService.observe(createExternalRuntimeActivityObservation(sessionId, externalRuntimeSnapshot));
-            return this.mapResolutionToActivityEnvelope(resolution, {
-                hasActiveRun: true,
-                canInterrupt: false
-            });
+            const resolution = this.sessionActivityAuthorityService.observe(createExternalRuntimeActivityObservation(runtimeSessionId, externalRuntimeSnapshot));
+            return {
+                ...this.mapResolutionToActivityEnvelope(resolution, {
+                    hasActiveRun: true,
+                    canInterrupt: false
+                }),
+                sessionId
+            };
         }
-        const resolution = this.sessionActivityAuthorityService.getResolution(sessionId);
+        const resolution = this.sessionActivityAuthorityService.getResolution(runtimeSessionId);
         if (!resolution) {
             return null;
         }
-        return this.mapResolutionToActivityEnvelope(resolution, {
-            hasActiveRun: resolution.runningState === "stale" || resolution.runningState === "unknown",
-            canInterrupt: false
-        });
+        return {
+            ...this.mapResolutionToActivityEnvelope(resolution, {
+                hasActiveRun: resolution.runningState === "stale" || resolution.runningState === "unknown",
+                canInterrupt: false
+            }),
+            sessionId
+        };
+    }
+    resolveRuntimeSessionId(sessionId) {
+        if (this.providerRuntimeService.getSnapshot(sessionId)
+            || this.externalRuntimeSnapshots.has(sessionId)) {
+            return sessionId;
+        }
+        const listSnapshots = "listSnapshots" in this.providerRuntimeService
+            && typeof this.providerRuntimeService.listSnapshots === "function"
+            ? this.providerRuntimeService.listSnapshots.bind(this.providerRuntimeService)
+            : null;
+        if (!listSnapshots) {
+            return sessionId;
+        }
+        const linkedSnapshot = listSnapshots()
+            .find((snapshot) => this.isLinkedGeminiRuntimeSession(snapshot.sessionId, sessionId));
+        return linkedSnapshot?.sessionId ?? sessionId;
+    }
+    isLinkedGeminiRuntimeSession(candidateSessionId, targetSessionId) {
+        if (candidateSessionId === targetSessionId) {
+            return true;
+        }
+        const binding = this.sessionBindingRepository.findBySessionId(candidateSessionId);
+        if (!binding || binding.provider !== "gemini") {
+            return false;
+        }
+        return isGeminiPendingRuntimeAliasBinding(binding.providerSessionId, targetSessionId)
+            || isGeminiPendingRuntimeAliasBinding(binding.rawStoreRef, targetSessionId);
     }
     mapResolutionToActivityEnvelope(resolution, options) {
         return {
@@ -660,6 +769,7 @@ export class SessionLiveRuntimeService {
             workspaceId: input.workspaceId,
             provider: "claude-code",
             parentSessionId: null,
+            sessionKind: "default",
             isSubagent: false,
             subagentLabel: null,
             title: `Claude 会话 ${input.providerSessionId.slice(0, 8)}`,
@@ -764,6 +874,13 @@ export class SessionLiveRuntimeService {
             };
         await this.emitExternalRuntimeEnvelope(envelope);
         if (isTerminalSessionRunningState(input.runningState)) {
+            await this.emitTerminalStateEvent({
+                sessionId: input.sessionId,
+                status: input.runningState,
+                timestamp: input.timestamp,
+                detail: input.detail,
+                source: "external_runtime"
+            });
             void this.dispatchNextQueuedMessage(input.sessionId);
         }
     }
@@ -794,80 +911,118 @@ export class SessionLiveRuntimeService {
     async sendLiveMessageDirect(input, persistedAttachments) {
         const requestStartedAt = nowIso();
         const session = this.sessionHistoryService.getSession(input.sessionId, input.userId);
-        const capabilities = await this.sessionHistoryService.getSessionCapabilities(input.sessionId);
-        const workspace = this.workspaceService.getWorkspaceOrThrow(session.workspaceId);
-        const runtimeMode = shouldStartNativeSessionOnFirstMessage(session);
-        const resolvedAttachments = persistedAttachments
-            ?? this.persistMessageAttachments(input.sessionId, input.clientRequestId, input.runtimeOptions?.attachments ?? []);
-        const providerPrompt = this.sessionMessageAttachmentService.buildProviderPrompt(session.provider, input.content, resolvedAttachments.runtimeAttachments);
-        this.ensureCapability(capabilities.canSendMessage, "sessionId", "provider 不支持实时对话");
-        const runtimeRequest = {
+        const debugTrace = this.beginPendingSendDebugTrace({
+            mode: "send_live",
             sessionId: input.sessionId,
             workspaceId: session.workspaceId,
-            workspacePath: workspace.path,
             provider: session.provider,
-            providerSessionId: runtimeMode === "start" ? null : session.providerSessionId,
-            rawStoreRef: runtimeMode === "start" ? null : session.rawStoreRef,
-            sequenceBase: runtimeMode === "start"
+            clientRequestId: input.clientRequestId
+        });
+        try {
+            const capabilities = await this.sessionHistoryService.getSessionCapabilities(input.sessionId);
+            const workspace = this.workspaceService.getWorkspaceOrThrow(session.workspaceId);
+            const runtimeMode = shouldStartNativeSessionOnFirstMessage(session);
+            const syntheticForkRawStoreRef = runtimeMode === "start" && shouldResumeCodexSyntheticForkSession(session)
+                ? session.rawStoreRef
+                : null;
+            const nextUserSequence = runtimeMode === "start"
                 ? 1
-                : Math.max(session.messageCount + 1, 1),
-            options: {
-                content: input.content,
-                clientRequestId: input.clientRequestId,
-                model: input.runtimeOptions?.model ?? null,
-                reasoningLevel: input.runtimeOptions?.reasoningLevel ?? null,
-                permissionMode: input.runtimeOptions?.permissionMode ?? null,
-                providerPrompt,
-                attachments: resolvedAttachments.runtimeAttachments
+                : 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);
+            this.ensureCapability(capabilities.canSendMessage, "sessionId", "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,
+                sequenceBase: nextUserSequence,
+                options: {
+                    content: input.content,
+                    clientRequestId: input.clientRequestId,
+                    model: input.runtimeOptions?.model ?? null,
+                    reasoningLevel: input.runtimeOptions?.reasoningLevel ?? null,
+                    permissionMode: input.runtimeOptions?.permissionMode ?? null,
+                    providerPrompt,
+                    attachments: resolvedAttachments.runtimeAttachments
+                }
+            };
+            const runtimeSessionId = this.resolveRuntimeSessionId(input.sessionId);
+            const activeRun = this.providerRuntimeService.getSnapshot(runtimeSessionId);
+            const externalRuntimeSnapshot = this.externalRuntimeSnapshots.get(runtimeSessionId);
+            if (activeRun &&
+                activeRun.provider === "claude-code" &&
+                isActiveRuntimeState(activeRun.runningState)) {
+                this.clearExternalRuntimeSnapshot(runtimeSessionId);
             }
-        };
-        const activeRun = this.providerRuntimeService.getSnapshot(input.sessionId);
-        const externalRuntimeSnapshot = this.externalRuntimeSnapshots.get(input.sessionId);
-        if (activeRun &&
-            activeRun.provider === "claude-code" &&
-            isActiveRuntimeState(activeRun.runningState)) {
-            this.clearExternalRuntimeSnapshot(input.sessionId);
-        }
-        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 &&
+                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)) {
+                const submitStartedAtMs = performance.now();
+                await this.providerRuntimeService.submitToActiveRun(runtimeSessionId, runtimeRequest.options)
+                    .catch((error) => {
+                    throw mapSessionProviderError(error);
+                });
+                this.logSendDebugStep(debugTrace, "submit_to_active_run", submitStartedAtMs, {
+                    runtimeMode,
+                    activeRunState: activeRun.runningState
+                });
+            }
+            else {
+                const startRuntimeStartedAtMs = performance.now();
+                await this.startRuntimeRun(runtimeRequest, input.userId, runtimeMode);
+                this.logSendDebugStep(debugTrace, "start_runtime_run", startRuntimeStartedAtMs, {
+                    runtimeMode
+                });
+            }
+            const binding = this.sessionHistoryService.getBindingOrThrow(input.sessionId);
+            const acceptedLookupStartedAtMs = performance.now();
+            const acceptedMessage = await this.findAcceptedUserMessage(input.sessionId, this.sessionMessageAttachmentService.buildAcceptedContentCandidates(input.content, providerPrompt), requestStartedAt);
+            this.logSendDebugStep(debugTrace, "accepted_user_lookup", acceptedLookupStartedAtMs, {
+                matched: Boolean(acceptedMessage)
             });
-        }
-        if (activeRun && isActiveRuntimeState(activeRun.runningState)) {
-            await this.providerRuntimeService.submitToActiveRun(input.sessionId, runtimeRequest.options)
-                .catch((error) => {
-                throw mapSessionProviderError(error);
+            const acceptedAt = acceptedMessage?.timestamp ?? nowIso();
+            const boundAttachments = this.sessionMessageAttachmentService.bindClientRequestToMessage(input.sessionId, input.clientRequestId, acceptedMessage?.messageId ?? null);
+            this.refreshSyntheticSessionTitle(session, input.content, input.userId);
+            this.markSendDebugResponseReady(debugTrace, {
+                runtimeMode,
+                returnedAcceptedMessage: Boolean(acceptedMessage),
+                returnedSyntheticUser: !acceptedMessage,
+                providerSessionId: binding.providerSessionId
             });
+            return {
+                sessionId: input.sessionId,
+                provider: session.provider,
+                providerSessionId: binding.providerSessionId,
+                acceptedAt,
+                clientRequestId: input.clientRequestId,
+                message: (acceptedMessage
+                    ? {
+                        ...acceptedMessage,
+                        attachments: boundAttachments
+                    }
+                    : null) ??
+                    createSyntheticUserMessage(session.provider, binding.providerSessionId, input.content, acceptedAt, nextUserSequence, boundAttachments.length > 0
+                        ? boundAttachments
+                        : resolvedAttachments.messageAttachments)
+            };
         }
-        else {
-            await this.startRuntimeRun(runtimeRequest, input.userId, runtimeMode);
+        catch (error) {
+            this.failPendingSendDebugTrace(debugTrace, error);
+            throw error;
         }
-        const binding = this.sessionHistoryService.getBindingOrThrow(input.sessionId);
-        const acceptedMessage = await this.findAcceptedUserMessage(input.sessionId, this.sessionMessageAttachmentService.buildAcceptedContentCandidates(input.content, providerPrompt), requestStartedAt);
-        const acceptedAt = acceptedMessage?.timestamp ?? nowIso();
-        const boundAttachments = this.sessionMessageAttachmentService.bindClientRequestToMessage(input.sessionId, input.clientRequestId, acceptedMessage?.messageId ?? null);
-        return {
-            sessionId: input.sessionId,
-            provider: session.provider,
-            providerSessionId: binding.providerSessionId,
-            acceptedAt,
-            clientRequestId: input.clientRequestId,
-            message: (acceptedMessage
-                ? {
-                    ...acceptedMessage,
-                    attachments: boundAttachments
-                }
-                : null) ??
-                createSyntheticUserMessage(session.provider, binding.providerSessionId, input.content, acceptedAt, Math.max(session.messageCount + 1, 1), boundAttachments.length > 0
-                    ? boundAttachments
-                    : resolvedAttachments.messageAttachments)
-        };
     }
     async dispatchNextQueuedMessage(sessionId) {
         if (this.queueDispatchSessions.has(sessionId)) {
@@ -919,7 +1074,7 @@ export class SessionLiveRuntimeService {
                 this.sessionSendQueueRepository.delete(nextQueueItem.id);
             }
             catch (error) {
-                if (isQueueDispatchDeferredError(error)) {
+                if (isQueueDispatchRetryableError(error)) {
                     this.sessionSendQueueRepository.markQueued(nextQueueItem.id, nowIso());
                     this.scheduleQueueRetry(sessionId);
                     return;
@@ -1010,7 +1165,10 @@ export class SessionLiveRuntimeService {
             sessionId: input.sessionId,
             workspaceId: input.workspaceId,
             provider: input.provider,
-            parentSessionId: null,
+            parentSessionId: input.parentSessionId,
+            sessionKind: input.sessionKind,
+            annotationSourceMessageId: input.annotationSourceMessageId,
+            annotationSourceText: input.annotationSourceText,
             isSubagent: false,
             subagentLabel: null,
             title: buildSessionTitle(input.initialContent),
@@ -1053,6 +1211,7 @@ export class SessionLiveRuntimeService {
         };
     }
     async persistRuntimeEvent(sessionId, workspaceId, userId, event) {
+        this.observePendingSendDebugTraceEvent(sessionId, event);
         this.sessionHistoryService.persistSessionBinding(sessionId, workspaceId, {
             provider: event.provider,
             providerSessionId: event.providerSessionId,
@@ -1152,9 +1311,151 @@ export class SessionLiveRuntimeService {
         });
         await this.maybeEmitRuntimeHistoryFallback(sessionId, event);
         if (isTerminalRuntimeEventStatus(event.status)) {
+            if (!isTerminalSessionRunningState(currentRunningState)) {
+                await this.emitTerminalStateEvent({
+                    sessionId,
+                    status: event.status,
+                    timestamp: event.timestamp,
+                    detail: event.detail ?? null,
+                    source: "runtime"
+                });
+            }
             void this.dispatchNextQueuedMessage(sessionId);
         }
     }
+    async emitTerminalStateEvent(event) {
+        for (const listener of this.terminalStateListeners) {
+            await listener(event);
+        }
+    }
+    beginPendingSendDebugTrace(input) {
+        if (!isPerfDebugEnabled()) {
+            return null;
+        }
+        const trace = {
+            ...input,
+            startedAtMs: performance.now(),
+            responseReadyAtMs: null,
+            firstRuntimeEventAtMs: null
+        };
+        const queue = this.pendingSendDebugTracesBySessionId.get(input.sessionId) ?? [];
+        queue.push(trace);
+        this.pendingSendDebugTracesBySessionId.set(input.sessionId, queue);
+        logPerformance(`session_send.${trace.mode}.begin`, 0, this.buildSendDebugDetail(trace), {
+            force: true,
+            thresholdMs: 0
+        });
+        return trace;
+    }
+    logSendDebugStep(trace, step, startedAtMs, detail = {}) {
+        if (!trace) {
+            return;
+        }
+        logPerformance(`session_send.${trace.mode}.${step}`, performance.now() - startedAtMs, {
+            ...this.buildSendDebugDetail(trace),
+            ...detail
+        }, {
+            force: true,
+            thresholdMs: 0
+        });
+    }
+    markSendDebugResponseReady(trace, detail = {}) {
+        if (!trace || trace.responseReadyAtMs !== null) {
+            return;
+        }
+        trace.responseReadyAtMs = performance.now();
+        logPerformance(`session_send.${trace.mode}.response_ready`, trace.responseReadyAtMs - trace.startedAtMs, {
+            ...this.buildSendDebugDetail(trace),
+            ...detail
+        }, {
+            force: true,
+            thresholdMs: 0
+        });
+    }
+    failPendingSendDebugTrace(trace, error) {
+        if (!trace) {
+            return;
+        }
+        logPerformance(`session_send.${trace.mode}.error`, performance.now() - trace.startedAtMs, {
+            ...this.buildSendDebugDetail(trace),
+            error: error instanceof Error ? error.message : String(error)
+        }, {
+            force: true,
+            thresholdMs: 0
+        });
+        this.removePendingSendDebugTrace(trace);
+    }
+    observePendingSendDebugTraceEvent(sessionId, event) {
+        const trace = this.peekPendingSendDebugTrace(sessionId);
+        if (!trace) {
+            return;
+        }
+        const nowMs = performance.now();
+        if (trace.firstRuntimeEventAtMs === null) {
+            trace.firstRuntimeEventAtMs = nowMs;
+            logPerformance(`session_send.${trace.mode}.first_runtime_event`, trace.firstRuntimeEventAtMs - trace.startedAtMs, {
+                ...this.buildSendDebugDetail(trace),
+                eventType: event.type,
+                status: event.status,
+                role: event.type === "message" ? event.message.role : null,
+                kind: event.type === "message" ? event.message.kind : null,
+                responseReady: trace.responseReadyAtMs !== null
+            }, {
+                force: true,
+                thresholdMs: 0
+            });
+        }
+        if (event.type === "message" && event.message.role === "assistant") {
+            logPerformance(`session_send.${trace.mode}.first_assistant_message`, nowMs - trace.startedAtMs, {
+                ...this.buildSendDebugDetail(trace),
+                kind: event.message.kind,
+                contentLength: event.message.content.length,
+                responseToAssistantMs: trace.responseReadyAtMs === null ? null : nowMs - trace.responseReadyAtMs
+            }, {
+                force: true,
+                thresholdMs: 0
+            });
+            this.removePendingSendDebugTrace(trace);
+            return;
+        }
+        if (event.type === "error" ||
+            (event.type !== "message" && isTerminalRuntimeEventStatus(event.status))) {
+            logPerformance(`session_send.${trace.mode}.completed_without_assistant`, nowMs - trace.startedAtMs, {
+                ...this.buildSendDebugDetail(trace),
+                eventType: event.type,
+                status: event.status,
+                detail: event.detail
+            }, {
+                force: true,
+                thresholdMs: 0
+            });
+            this.removePendingSendDebugTrace(trace);
+        }
+    }
+    peekPendingSendDebugTrace(sessionId) {
+        const queue = this.pendingSendDebugTracesBySessionId.get(sessionId);
+        return queue && queue.length > 0 ? queue[0] : null;
+    }
+    removePendingSendDebugTrace(trace) {
+        const queue = this.pendingSendDebugTracesBySessionId.get(trace.sessionId);
+        if (!queue || queue.length === 0) {
+            return;
+        }
+        const nextQueue = queue.filter((item) => item !== trace);
+        if (nextQueue.length === 0) {
+            this.pendingSendDebugTracesBySessionId.delete(trace.sessionId);
+            return;
+        }
+        this.pendingSendDebugTracesBySessionId.set(trace.sessionId, nextQueue);
+    }
+    buildSendDebugDetail(trace) {
+        return {
+            sessionId: trace.sessionId,
+            workspaceId: trace.workspaceId,
+            provider: trace.provider,
+            clientRequestId: trace.clientRequestId
+        };
+    }
     async findAcceptedUserMessage(sessionId, content, minTimestamp) {
         try {
             return await withTimeout(this.sessionHistoryService.findLatestUserMessage(sessionId, content, 12, minTimestamp), 1200);
@@ -1163,6 +1464,36 @@ export class SessionLiveRuntimeService {
             return null;
         }
     }
+    async resolveNextUserSequence(sessionId, messageCount) {
+        let maxSequence = Math.max(messageCount, 0);
+        const envelope = await Promise.resolve(this.sessionHistoryService.readRecentHistoryEnvelope(sessionId, 10)).catch(() => {
+            return null;
+        });
+        for (const message of envelope?.messages ?? []) {
+            if (Number.isFinite(message.sequence) && message.sequence > maxSequence) {
+                maxSequence = message.sequence;
+            }
+        }
+        return Math.max(maxSequence + 1, 1);
+    }
+    async waitForResolvedStartBinding(sessionId, workspaceId, provider, handle) {
+        if (provider !== "gemini" && provider !== "kimi") {
+            return;
+        }
+        const startedAt = Date.now();
+        while (Date.now() - startedAt < RUNTIME_START_BINDING_WAIT_TIMEOUT_MS) {
+            const snapshot = handle.getSnapshot();
+            if (hasResolvedRuntimeBinding(snapshot.providerSessionId, snapshot.rawStoreRef)) {
+                this.sessionHistoryService.persistSessionBinding(sessionId, workspaceId, {
+                    provider: snapshot.provider,
+                    providerSessionId: snapshot.providerSessionId,
+                    rawStoreRef: snapshot.rawStoreRef
+                });
+                return;
+            }
+            await waitForRuntimeBindingPoll();
+        }
+    }
     persistMessageAttachments(sessionId, clientRequestId, attachments) {
         if (!clientRequestId || attachments.length === 0) {
             return {
@@ -1176,12 +1507,30 @@ export class SessionLiveRuntimeService {
             attachments
         });
     }
-    mapRuntimeEventToEnvelope(sessionId, event) {
+    refreshSyntheticSessionTitle(session, content, userId) {
+        const currentIndex = this.sessionIndexRepository.findIndexRecordBySessionId(session.sessionId);
+        if (!currentIndex) {
+            return;
+        }
+        const parentTitle = session.parentSessionId
+            ? this.sessionHistoryService.getSession(session.parentSessionId, userId).title
+            : null;
+        const nextTitle = resolveRuntimeSessionTitle(currentIndex.provider, currentIndex.title, content, parentTitle, session.forkMethod, session.forkSourceType);
+        if (!nextTitle || nextTitle === currentIndex.title) {
+            return;
+        }
+        this.sessionIndexRepository.upsert({
+            ...currentIndex,
+            title: nextTitle,
+            updatedAt: nowIso()
+        });
+    }
+    mapRuntimeEventToEnvelope(sessionId, event, originSessionId = sessionId) {
         if (event.type === "message") {
             return {
                 type: "session.runtime_message",
                 sessionId,
-                message: event.message,
+                message: this.sessionHistoryService.resolveMessageOrigin(originSessionId, event.message),
                 source: "runtime"
             };
         }
@@ -1445,10 +1794,31 @@ function buildSessionTitle(content) {
     const title = content.trim().replace(/\s+/g, " ");
     return title.slice(0, 48) || "继续对话";
 }
+function resolveRuntimeSessionTitle(provider, existingTitle, content, parentTitle, forkMethod, forkSourceType) {
+    const normalizedExistingTitle = existingTitle.trim();
+    const normalizedParentTitle = parentTitle?.trim() ?? "";
+    const isForkSession = Boolean(forkMethod || forkSourceType);
+    if (normalizedExistingTitle.length > 0 &&
+        !isSyntheticRuntimeSessionTitle(provider, normalizedExistingTitle) &&
+        (!isForkSession || normalizedExistingTitle !== normalizedParentTitle)) {
+        return null;
+    }
+    return buildSessionTitle(content);
+}
+function isSyntheticRuntimeSessionTitle(provider, title) {
+    if (provider !== "codex") {
+        return false;
+    }
+    return (/^rollout-\d{4}-\d{2}-\d{2}t/i.test(title) ||
+        /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(title));
+}
 function shouldStartNativeSessionOnFirstMessage(session) {
     if (session.provider !== "codex" && session.provider !== "opencode") {
         return "continue";
     }
+    if (session.provider === "codex" && session.providerSessionId.startsWith("rollout-")) {
+        return "start";
+    }
     if (session.messageCount > 0) {
         return "continue";
     }
@@ -1456,6 +1826,12 @@ function shouldStartNativeSessionOnFirstMessage(session) {
         ? "continue"
         : "start";
 }
+function shouldResumeCodexSyntheticForkSession(session) {
+    return (session.provider === "codex"
+        && session.messageCount > 0
+        && session.providerSessionId.startsWith("rollout-")
+        && Boolean(session.rawStoreRef?.trim()));
+}
 function isActiveRuntimeState(state) {
     return state === "starting" || state === "running";
 }
@@ -1465,12 +1841,25 @@ function isTerminalRuntimeEventStatus(status) {
 function isPendingSessionRunningState(state) {
     return state === "starting" || state === "running";
 }
-function isQueueDispatchDeferredError(error) {
+function isQueueDispatchRetryableError(error) {
     if (error instanceof AppError) {
-        return error.errorCode === "ACTIVE_RUN_EXISTS" || error.errorCode === "SESSION_NOT_RUNNING";
+        if (error.errorCode === "ACTIVE_RUN_EXISTS"
+            || error.errorCode === "SESSION_NOT_RUNNING"
+            || error.errorCode === "IN_RUN_INPUT_NOT_SUPPORTED"
+            || error.errorCode === "SESSION_EXTERNAL_RUN_ACTIVE"
+            || error.errorCode === "PROVIDER_RUNTIME_UNAVAILABLE"
+            || error.errorCode === "PROVIDER_RUNTIME_TIMEOUT") {
+            return true;
+        }
+        return error.statusCode >= 500;
     }
     if (error instanceof Error) {
-        return error.message === "ACTIVE_RUN_EXISTS";
+        return (error.message === "ACTIVE_RUN_EXISTS"
+            || error.message === "SESSION_NOT_RUNNING"
+            || error.message === "IN_RUN_INPUT_NOT_SUPPORTED"
+            || error.message === "SESSION_EXTERNAL_RUN_ACTIVE"
+            || error.message === "SERVER_UNAVAILABLE"
+            || error.message === "SERVER_TIMEOUT");
     }
     return false;
 }
@@ -1493,6 +1882,32 @@ function mapQueueItemRecordToView(record) {
 function isTerminalSessionRunningState(state) {
     return state === "completed" || state === "interrupted" || state === "failed";
 }
+function hasResolvedRuntimeBinding(providerSessionId, rawStoreRef) {
+    if (!providerSessionId?.trim() || !rawStoreRef?.trim()) {
+        return false;
+    }
+    return !providerSessionId.trim().toLowerCase().startsWith("pending://")
+        && !rawStoreRef.trim().toLowerCase().startsWith("pending://");
+}
+function waitForRuntimeBindingPoll() {
+    return new Promise((resolve) => {
+        setTimeout(resolve, START_BINDING_POLL_INTERVAL_MS);
+    });
+}
+function isGeminiPendingRuntimeAliasBinding(value, targetSessionId) {
+    return value.trim().toLowerCase() === `pending://gemini/${targetSessionId.trim().toLowerCase()}`;
+}
+function shouldAwaitAcceptedUserMessage(provider) {
+    return provider !== "gemini";
+}
+function shouldAwaitStartBindingBeforeAcceptedUserLookup(provider) {
+    return provider === "kimi";
+}
+function waitForAcceptedUserLookupWindow() {
+    return new Promise((resolve) => {
+        setTimeout(resolve, 1200);
+    });
+}
 function createProviderRuntimeAdapters(config, options = {}) {
     const claudeHookBridgeConfig = buildClaudeHookBridgeConfig(config);
     const claudeAdapter = process.env.VITEST
@@ -1518,7 +1933,9 @@ function createProviderRuntimeAdapters(config, options = {}) {
     }
     const codexTransportHelper = process.env.VITEST
         ? null
-        : new CodexAppServerHelperClient(config.codexCliPath);
+        : new CodexAppServerHelperClient(config.codexCliPath, {
+            homeDir: config.codexHomeDir
+        });
     if (codexTransportHelper) {
         disposables.push(codexTransportHelper);
     }
@@ -1531,6 +1948,14 @@ function createProviderRuntimeAdapters(config, options = {}) {
                 transportFactory: codexTransportHelper?.createTransport.bind(codexTransportHelper),
                 handleServerRequest: options.handleCodexServerRequest
             }),
+            new GeminiRuntimeAdapter({
+                homeDir: config.geminiHomeDir,
+                commandPath: config.geminiCliPath
+            }),
+            new KimiRuntimeAdapter({
+                homeDir: config.kimiHomeDir,
+                commandPath: config.kimiCliPath
+            }),
             new OpenCodeRuntimeAdapter({
                 baseUrl: config.opencodeBaseUrl,
                 baseUrlResolver: config.opencodeBaseUrlResolver?.resolve.bind(config.opencodeBaseUrlResolver)