@jingyi0605/codingns 0.1.1 → 0.1.3

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

@@ -3,8 +3,13 @@ import path from "node:path";
 import { ClaudeRuntimeAdapter, CodexRuntimeAdapter, OpenCodeRuntimeAdapter, ProviderRuntimeService } from "@codingns/session-sync-core";
 import { AppError } from "../../shared/errors/app-error.js";
 import { createId } from "../../shared/utils/id.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 { SessionPermissionRequestService } from "./session-permission-request-service.js";
 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";
 export class SessionLiveRuntimeService {
     sessionHistoryService;
     sessionMessageAttachmentService;
@@ -18,13 +23,16 @@ export class SessionLiveRuntimeService {
     sessionStatusSnapshotRepository;
     config;
     providerRuntimeService;
+    sessionActivityAuthorityService;
+    sessionPermissionRequestService;
+    runtimeAdapterDisposables;
     externalRuntimeSnapshots = new Map();
     runtimeListeners = new Map();
     runtimeMessageSeenSessions = new Set();
     runtimeHistoryFallbackSentSessions = new Set();
     queueDispatchSessions = new Set();
     queueRetryTimers = new Map();
-    constructor(sessionHistoryService, sessionMessageAttachmentService, workspaceService, sessionChangedFileService, sessionBindingRepository, authUserRepository, sessionSendQueueRepository, sessionIndexRepository, sessionStateRepository, sessionStatusSnapshotRepository, config) {
+    constructor(sessionHistoryService, sessionMessageAttachmentService, workspaceService, sessionChangedFileService, sessionBindingRepository, authUserRepository, sessionSendQueueRepository, sessionIndexRepository, sessionStateRepository, sessionStatusSnapshotRepository, config, sessionActivityAuthorityService = new SessionActivityAuthorityService()) {
         this.sessionHistoryService = sessionHistoryService;
         this.sessionMessageAttachmentService = sessionMessageAttachmentService;
         this.workspaceService = workspaceService;
@@ -36,13 +44,24 @@ export class SessionLiveRuntimeService {
         this.sessionStateRepository = sessionStateRepository;
         this.sessionStatusSnapshotRepository = sessionStatusSnapshotRepository;
         this.config = config;
-        this.providerRuntimeService = new ProviderRuntimeService(createProviderRuntimeAdapters(config));
+        this.sessionActivityAuthorityService = sessionActivityAuthorityService;
+        this.sessionPermissionRequestService = new SessionPermissionRequestService(sessionHistoryService, sessionBindingRepository, authUserRepository, workspaceService, config, async (envelope) => {
+            await this.emitExternalRuntimeEnvelope(envelope);
+        }, async (input) => {
+            return this.resolveActiveClaudePermissionSession(input);
+        });
+        const runtimeAdapters = createProviderRuntimeAdapters(config, {
+            handleCodexServerRequest: async (input) => this.sessionPermissionRequestService.handleCodexServerRequest(input.sessionId, input.providerSessionId, input.request)
+        });
+        this.runtimeAdapterDisposables = runtimeAdapters.disposables;
+        this.providerRuntimeService = new ProviderRuntimeService(runtimeAdapters.adapters);
     }
     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");
@@ -244,20 +263,16 @@ export class SessionLiveRuntimeService {
         };
     }
     getClaudeHookBridgeConfig() {
-        const bridgeUrl = `http://127.0.0.1:${this.config.port}/api/providers/claude-code/hook-bridge/events`;
-        const scriptPath = path.resolve(process.cwd(), "scripts", "claude-hook-bridge.cjs");
-        const command = `node "${scriptPath}" --url "${bridgeUrl}" --token "${this.config.claudeHookBridgeToken}"`;
-        return {
-            provider: "claude-code",
-            bridgeUrl,
-            token: this.config.claudeHookBridgeToken,
-            scriptPath,
-            command,
-            supportedEvents: ["UserPromptSubmit", "SessionStart", "Stop", "StopFailure", "SessionEnd"]
-        };
+        return buildClaudeHookBridgeConfig(this.config);
     }
     async ingestClaudeHookEvent(payload) {
         const hookEventName = normalizeClaudeHookEventName(payload.hook_event_name);
+        logPermissionDebug("claude_hook_event.ingest.begin", {
+            hookEventName,
+            sessionId: payload.session_id ?? null,
+            cwd: payload.cwd ?? null,
+            transcriptPath: payload.transcript_path ?? null
+        });
         if (!hookEventName) {
             throw new AppError({
                 statusCode: 400,
@@ -267,20 +282,44 @@ export class SessionLiveRuntimeService {
             });
         }
         if (!isSupportedClaudeHookEvent(hookEventName)) {
+            logPermissionDebug("claude_hook_event.ingest.unsupported", {
+                hookEventName
+            });
             return {
                 accepted: true,
                 ignored: true,
-                sessionId: null
+                sessionId: null,
+                bridgeResponse: null
             };
         }
+        if (hookEventName === "PreToolUse") {
+            logPermissionDebug("claude_hook_event.route", {
+                hookEventName,
+                route: "handleClaudePreToolUse"
+            });
+            return this.sessionPermissionRequestService.handleClaudePreToolUse(payload);
+        }
+        if (hookEventName === "PermissionRequest") {
+            logPermissionDebug("claude_hook_event.route", {
+                hookEventName,
+                route: "handleClaudePermissionRequest"
+            });
+            return this.sessionPermissionRequestService.handleClaudePermissionRequest(payload);
+        }
         const providerSessionId = normalizeRequiredText(payload.session_id, "session_id");
         const workspacePath = normalizeRequiredText(payload.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
+            });
             return {
                 accepted: true,
                 ignored: true,
-                sessionId: null
+                sessionId: null,
+                bridgeResponse: null
             };
         }
         const binding = await this.resolveClaudeExternalBinding({
@@ -291,11 +330,18 @@ export class SessionLiveRuntimeService {
         });
         const timestamp = nowIso();
         const runtimeUpdate = mapClaudeHookToRuntimeUpdate(hookEventName, payload, timestamp);
+        logPermissionDebug("claude_hook_event.runtime_update", {
+            hookEventName,
+            sessionId: binding.sessionId,
+            providerSessionId,
+            hasRuntimeUpdate: runtimeUpdate !== null
+        });
         if (!runtimeUpdate) {
             return {
                 accepted: true,
                 ignored: true,
-                sessionId: binding.sessionId
+                sessionId: binding.sessionId,
+                bridgeResponse: null
             };
         }
         if (this.shouldIgnoreClaudeExternalRuntimeUpdate(binding.sessionId)) {
@@ -303,7 +349,8 @@ export class SessionLiveRuntimeService {
             return {
                 accepted: true,
                 ignored: true,
-                sessionId: binding.sessionId
+                sessionId: binding.sessionId,
+                bridgeResponse: null
             };
         }
         await this.applyExternalRuntimeUpdate({
@@ -316,7 +363,8 @@ export class SessionLiveRuntimeService {
         return {
             accepted: true,
             ignored: false,
-            sessionId: binding.sessionId
+            sessionId: binding.sessionId,
+            bridgeResponse: null
         };
     }
     async getSessionRuntime(sessionId, userId) {
@@ -328,24 +376,33 @@ export class SessionLiveRuntimeService {
         this.maybeDispatchQueuedMessages(session);
         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))
+            : externalRuntimeSnapshot
+                ? this.sessionActivityAuthorityService.observe(createExternalRuntimeActivityObservation(sessionId, externalRuntimeSnapshot))
+                : this.sessionActivityAuthorityService.resolvePersistedSession(session);
         if (runtimeSnapshot) {
             return {
                 sessionId,
                 provider: session.provider,
                 providerSessionId: runtimeSnapshot.providerSessionId ?? session.providerSessionId,
-                runningState: runtimeSnapshot.runningState,
+                runningState: resolution.runningState,
                 hasActiveRun: true,
                 canAttach: true,
                 canInterrupt: runtimeSnapshot.supportsInterrupt,
                 inRunInputMode: capabilities.inRunInputMode,
-                detail: runtimeSnapshot.detail,
-                errorCode: runtimeSnapshot.runningState === "failed"
-                    ? runtimeSnapshot.errorCode ?? session.lastErrorCode
+                activityResolutionSource: resolution.activityResolutionSource,
+                activityConfidence: resolution.activityConfidence,
+                runId: resolution.runId,
+                detail: resolution.detail,
+                errorCode: resolution.runningState === "failed"
+                    ? resolution.errorCode ?? session.lastErrorCode
                     : null,
-                errorDetail: runtimeSnapshot.runningState === "failed"
-                    ? runtimeSnapshot.detail ?? session.lastErrorDetail
+                errorDetail: resolution.runningState === "failed"
+                    ? resolution.detail ?? session.lastErrorDetail
                     : null,
-                updatedAt: runtimeSnapshot.lastEventAt ?? runtimeSnapshot.startedAt,
+                updatedAt: resolution.updatedAt,
+                watchdogTriggeredAt: resolution.watchdogTriggeredAt,
                 contextUsage
             };
         }
@@ -354,33 +411,41 @@ export class SessionLiveRuntimeService {
                 sessionId,
                 provider: "claude-code",
                 providerSessionId: externalRuntimeSnapshot.providerSessionId,
-                runningState: externalRuntimeSnapshot.runningState,
+                runningState: resolution.runningState,
                 hasActiveRun: true,
                 canAttach: false,
                 canInterrupt: false,
                 inRunInputMode: capabilities.inRunInputMode,
-                detail: externalRuntimeSnapshot.detail,
-                errorCode: session.runningState === "failed" ? session.lastErrorCode : null,
-                errorDetail: session.runningState === "failed" ? session.lastErrorDetail : null,
-                updatedAt: externalRuntimeSnapshot.updatedAt,
+                activityResolutionSource: resolution.activityResolutionSource,
+                activityConfidence: resolution.activityConfidence,
+                runId: resolution.runId,
+                detail: resolution.detail,
+                errorCode: resolution.runningState === "failed" ? resolution.errorCode ?? session.lastErrorCode : null,
+                errorDetail: resolution.runningState === "failed" ? resolution.detail ?? session.lastErrorDetail : null,
+                updatedAt: resolution.updatedAt,
+                watchdogTriggeredAt: resolution.watchdogTriggeredAt,
                 contextUsage
             };
         }
-        const persistedErrorCode = session.runningState === "failed" ? session.lastErrorCode : null;
-        const persistedErrorDetail = session.runningState === "failed" ? session.lastErrorDetail : null;
+        const persistedErrorCode = resolution.runningState === "failed" ? resolution.errorCode ?? session.lastErrorCode : null;
+        const persistedErrorDetail = resolution.runningState === "failed" ? resolution.detail ?? session.lastErrorDetail : null;
         return {
             sessionId,
             provider: session.provider,
             providerSessionId: session.providerSessionId,
-            runningState: session.runningState ?? "idle",
+            runningState: resolution.runningState,
             hasActiveRun: false,
             canAttach: false,
             canInterrupt: false,
             inRunInputMode: capabilities.inRunInputMode,
+            activityResolutionSource: resolution.activityResolutionSource,
+            activityConfidence: resolution.activityConfidence,
+            runId: resolution.runId,
             detail: persistedErrorDetail,
             errorCode: persistedErrorCode,
             errorDetail: persistedErrorDetail,
-            updatedAt: session.lastEventAt ?? session.updatedAt,
+            updatedAt: resolution.updatedAt,
+            watchdogTriggeredAt: resolution.watchdogTriggeredAt,
             contextUsage
         };
     }
@@ -412,9 +477,16 @@ export class SessionLiveRuntimeService {
             detail: interrupted.detail ?? "interrupt requested"
         };
     }
+    async listPermissionRequests(sessionId, userId) {
+        return this.sessionPermissionRequestService.listSessionPermissionRequests(sessionId, userId);
+    }
+    async replyPermissionRequest(sessionId, userId, requestId, input) {
+        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);
         if (runtimeSnapshot) {
             void onEnvelope({
                 type: "session.runtime_status",
@@ -433,6 +505,9 @@ export class SessionLiveRuntimeService {
                 timestamp: externalRuntimeSnapshot.updatedAt
             });
         }
+        if (initialActivityEnvelope) {
+            void onEnvelope(initialActivityEnvelope);
+        }
         const runtimeSubscription = this.providerRuntimeService.subscribe(sessionId, async (event) => {
             const envelope = this.mapRuntimeEventToEnvelope(sessionId, event);
             if (!envelope) {
@@ -441,10 +516,18 @@ export class SessionLiveRuntimeService {
             await onEnvelope(envelope);
         });
         const externalSubscription = this.subscribeExternalRuntime(sessionId, onEnvelope);
+        const activitySubscription = this.sessionActivityAuthorityService.subscribe(sessionId, async () => {
+            const envelope = this.buildSessionActivityEnvelope(sessionId);
+            if (!envelope) {
+                return;
+            }
+            await onEnvelope(envelope);
+        });
         return {
             close: () => {
                 runtimeSubscription.close();
                 externalSubscription.close();
+                activitySubscription.close();
             }
         };
     }
@@ -455,7 +538,12 @@ export class SessionLiveRuntimeService {
         this.queueRetryTimers.clear();
         this.runtimeMessageSeenSessions.clear();
         this.runtimeHistoryFallbackSentSessions.clear();
+        this.sessionActivityAuthorityService.dispose();
+        await this.sessionPermissionRequestService.dispose();
         await this.providerRuntimeService.dispose();
+        for (const disposable of this.runtimeAdapterDisposables) {
+            disposable.dispose();
+        }
         this.externalRuntimeSnapshots.clear();
         this.runtimeListeners.clear();
     }
@@ -490,6 +578,49 @@ export class SessionLiveRuntimeService {
             await listener(envelope);
         }));
     }
+    buildSessionActivityEnvelope(sessionId) {
+        const runtimeSnapshot = this.providerRuntimeService.getSnapshot(sessionId);
+        if (runtimeSnapshot) {
+            const resolution = this.sessionActivityAuthorityService.observe(createRuntimeActivityObservation(sessionId, runtimeSnapshot));
+            return this.mapResolutionToActivityEnvelope(resolution, {
+                hasActiveRun: true,
+                canInterrupt: runtimeSnapshot.supportsInterrupt
+            });
+        }
+        const externalRuntimeSnapshot = this.externalRuntimeSnapshots.get(sessionId) ?? null;
+        if (externalRuntimeSnapshot) {
+            const resolution = this.sessionActivityAuthorityService.observe(createExternalRuntimeActivityObservation(sessionId, externalRuntimeSnapshot));
+            return this.mapResolutionToActivityEnvelope(resolution, {
+                hasActiveRun: true,
+                canInterrupt: false
+            });
+        }
+        const resolution = this.sessionActivityAuthorityService.getResolution(sessionId);
+        if (!resolution) {
+            return null;
+        }
+        return this.mapResolutionToActivityEnvelope(resolution, {
+            hasActiveRun: resolution.runningState === "stale" || resolution.runningState === "unknown",
+            canInterrupt: false
+        });
+    }
+    mapResolutionToActivityEnvelope(resolution, options) {
+        return {
+            type: "session.activity",
+            sessionId: resolution.sessionId,
+            runningState: resolution.runningState,
+            activityResolutionSource: resolution.activityResolutionSource,
+            activityConfidence: resolution.activityConfidence,
+            runId: resolution.runId,
+            detail: resolution.detail,
+            errorCode: resolution.errorCode,
+            errorDetail: resolution.detail,
+            hasActiveRun: options.hasActiveRun,
+            canInterrupt: options.canInterrupt,
+            updatedAt: resolution.updatedAt,
+            watchdogTriggeredAt: resolution.watchdogTriggeredAt
+        };
+    }
     async resolveClaudeExternalBinding(input) {
         const rawStoreRef = input.transcriptPath ??
             findClaudeSessionFile(this.config.claudeCodeHomeDir, input.providerSessionId) ??
@@ -592,6 +723,16 @@ export class SessionLiveRuntimeService {
             lastErrorDetail: input.runningState === "failed" ? (input.detail ?? "Claude hook failed") : null,
             resumedAt: this.sessionStatusSnapshotRepository.findBySessionId(input.sessionId)?.resumedAt ?? null
         });
+        this.sessionActivityAuthorityService.observe({
+            sessionId: input.sessionId,
+            runId: null,
+            runningState: input.runningState,
+            source: "authoritative_provider_event",
+            confidence: input.runningState === "failed" ? "strong" : "authoritative",
+            detail: input.detail,
+            errorCode: input.runningState === "failed" ? "CLAUDE_HOOK_STOP_FAILURE" : null,
+            observedAt: input.timestamp
+        });
         if (input.runningState === "running") {
             this.externalRuntimeSnapshots.set(input.sessionId, {
                 sessionId: input.sessionId,
@@ -648,6 +789,7 @@ export class SessionLiveRuntimeService {
             lastSeenAt: currentState?.lastSeenAt ?? null,
             updatedAt: nowIso()
         });
+        this.sessionActivityAuthorityService.observe(createRuntimeActivityObservation(request.sessionId, snapshot));
     }
     async sendLiveMessageDirect(input, persistedAttachments) {
         const requestStartedAt = nowIso();
@@ -863,13 +1005,7 @@ export class SessionLiveRuntimeService {
     }
     createRuntimeBackedSession(input) {
         const timestamp = nowIso();
-        const providerSessionId = input.snapshot.providerSessionId ?? `pending://${input.provider}/${input.sessionId}`;
-        const rawStoreRef = input.snapshot.rawStoreRef ?? `pending://${input.provider}/${input.sessionId}`;
-        this.sessionHistoryService.persistSessionBinding(input.sessionId, input.workspaceId, {
-            provider: input.snapshot.provider,
-            providerSessionId,
-            rawStoreRef
-        });
+        this.sessionHistoryService.persistSessionBinding(input.sessionId, input.workspaceId, this.buildBindingSnapshot(input.sessionId, input.snapshot.provider, input.snapshot.providerSessionId, input.snapshot.rawStoreRef));
         this.sessionIndexRepository.upsert({
             sessionId: input.sessionId,
             workspaceId: input.workspaceId,
@@ -903,6 +1039,18 @@ export class SessionLiveRuntimeService {
             lastSeenAt: null,
             updatedAt: timestamp
         });
+        this.sessionActivityAuthorityService.observe(createRuntimeActivityObservation(input.sessionId, input.snapshot));
+    }
+    ensurePendingSessionBinding(sessionId, workspaceId, provider) {
+        this.sessionHistoryService.persistSessionBinding(sessionId, workspaceId, this.buildBindingSnapshot(sessionId, provider, null, null));
+    }
+    buildBindingSnapshot(sessionId, provider, providerSessionId, rawStoreRef) {
+        const pendingValue = `pending://${provider}/${sessionId}`;
+        return {
+            provider,
+            providerSessionId: providerSessionId ?? pendingValue,
+            rawStoreRef: rawStoreRef ?? pendingValue
+        };
     }
     async persistRuntimeEvent(sessionId, workspaceId, userId, event) {
         this.sessionHistoryService.persistSessionBinding(sessionId, workspaceId, {
@@ -993,6 +1141,7 @@ export class SessionLiveRuntimeService {
             lastSeenAt: currentState?.lastSeenAt ?? null,
             updatedAt: nowIso()
         });
+        this.sessionActivityAuthorityService.observe(createRuntimeEventObservation(sessionId, event, this.providerRuntimeService.getSnapshot(sessionId)?.startedAt ?? null));
         this.upsertSnapshot(sessionId, {
             syncStatus: event.type === "error" ? "error" : "idle",
             syncCursor: this.sessionStatusSnapshotRepository.findBySessionId(sessionId)?.syncCursor ?? null,
@@ -1110,6 +1259,32 @@ export class SessionLiveRuntimeService {
     clearExternalRuntimeSnapshot(sessionId) {
         this.externalRuntimeSnapshots.delete(sessionId);
     }
+    async resolveActiveClaudePermissionSession(input) {
+        const activeSnapshots = this.providerRuntimeService
+            .listSnapshots()
+            .filter((snapshot) => snapshot.provider === "claude-code" &&
+            snapshot.workspaceId === input.workspaceId &&
+            isActiveRuntimeState(snapshot.runningState));
+        if (activeSnapshots.length !== 1) {
+            return null;
+        }
+        const activeSnapshot = activeSnapshots[0];
+        if (!activeSnapshot) {
+            return null;
+        }
+        const rawStoreRef = input.transcriptPath ??
+            activeSnapshot.rawStoreRef ??
+            buildClaudeRawStoreRef(this.config.claudeCodeHomeDir, input.workspacePath, input.providerSessionId);
+        this.sessionHistoryService.persistSessionBinding(activeSnapshot.sessionId, input.workspaceId, {
+            provider: "claude-code",
+            providerSessionId: input.providerSessionId,
+            rawStoreRef
+        });
+        return {
+            sessionId: activeSnapshot.sessionId,
+            rawStoreRef
+        };
+    }
 }
 function createSyntheticUserMessage(provider, providerSessionId, content, timestamp, sequence, attachments = []) {
     const syntheticId = createId();
@@ -1127,6 +1302,51 @@ function createSyntheticUserMessage(provider, providerSessionId, content, timest
         rawRef: `synthetic://${provider}/${providerSessionId}/${syntheticId}`
     };
 }
+function createRuntimeActivityObservation(sessionId, snapshot) {
+    return {
+        sessionId,
+        runId: buildRuntimeRunId(sessionId, snapshot.startedAt),
+        runningState: snapshot.runningState,
+        source: "authoritative_runtime",
+        confidence: snapshot.runningState === "failed" || snapshot.runningState === "completed" || snapshot.runningState === "interrupted"
+            ? "strong"
+            : "authoritative",
+        detail: snapshot.detail,
+        errorCode: snapshot.runningState === "failed" ? snapshot.errorCode ?? null : null,
+        observedAt: snapshot.lastEventAt ?? snapshot.startedAt
+    };
+}
+function createExternalRuntimeActivityObservation(sessionId, snapshot) {
+    return {
+        sessionId,
+        runId: null,
+        runningState: snapshot.runningState,
+        source: "authoritative_provider_event",
+        confidence: snapshot.runningState === "failed" ? "strong" : "authoritative",
+        detail: snapshot.detail,
+        errorCode: snapshot.runningState === "failed" ? "CLAUDE_HOOK_STOP_FAILURE" : null,
+        observedAt: snapshot.updatedAt
+    };
+}
+function createRuntimeEventObservation(sessionId, event, startedAt) {
+    return {
+        sessionId,
+        runId: buildRuntimeRunId(sessionId, startedAt ?? event.timestamp),
+        runningState: event.type === "message" ? "running" : event.status ?? "running",
+        source: "authoritative_runtime",
+        confidence: event.type === "error" || event.status === "completed" || event.status === "interrupted"
+            ? "strong"
+            : "authoritative",
+        detail: event.type === "message"
+            ? "Host 正在接收这一轮运行的实时事件"
+            : event.detail,
+        errorCode: event.type === "error" ? event.errorCode : null,
+        observedAt: event.type === "message" ? event.message.timestamp : event.timestamp
+    };
+}
+function buildRuntimeRunId(sessionId, startedAt) {
+    return `runtime:${sessionId}:${startedAt}`;
+}
 function withTimeout(promise, timeoutMs) {
     return new Promise((resolve, reject) => {
         const timer = setTimeout(() => {
@@ -1151,7 +1371,10 @@ function normalizeClaudeHookEventName(value) {
     return normalized && normalized.length > 0 ? normalized : null;
 }
 function isSupportedClaudeHookEvent(value) {
-    return (value === "UserPromptSubmit" ||
+    return (value === "PreToolUse" ||
+        value === "PermissionRequest" ||
+        value === "Notification" ||
+        value === "UserPromptSubmit" ||
         value === "SessionStart" ||
         value === "Stop" ||
         value === "StopFailure" ||
@@ -1270,17 +1493,86 @@ function mapQueueItemRecordToView(record) {
 function isTerminalSessionRunningState(state) {
     return state === "completed" || state === "interrupted" || state === "failed";
 }
-function createProviderRuntimeAdapters(config) {
-    return [
-        new ClaudeRuntimeAdapter({
-            homeDir: config.claudeCodeHomeDir
-        }),
-        new CodexRuntimeAdapter(),
-        new OpenCodeRuntimeAdapter({
-            baseUrl: config.opencodeBaseUrl,
-            baseUrlResolver: config.opencodeBaseUrlResolver?.resolve.bind(config.opencodeBaseUrlResolver)
+function createProviderRuntimeAdapters(config, options = {}) {
+    const claudeHookBridgeConfig = buildClaudeHookBridgeConfig(config);
+    const claudeAdapter = process.env.VITEST
+        ? new ClaudeRuntimeAdapter({
+            homeDir: config.claudeCodeHomeDir,
+            hookBridge: {
+                url: claudeHookBridgeConfig.bridgeUrl,
+                token: config.claudeHookBridgeToken,
+                scriptPath: claudeHookBridgeConfig.scriptPath
+            }
         })
+        : new ClaudeRuntimeHelperAdapter({
+            homeDir: config.claudeCodeHomeDir,
+            hookBridge: {
+                url: claudeHookBridgeConfig.bridgeUrl,
+                token: config.claudeHookBridgeToken,
+                scriptPath: claudeHookBridgeConfig.scriptPath
+            }
+        });
+    const disposables = [];
+    if ("dispose" in claudeAdapter && typeof claudeAdapter.dispose === "function") {
+        disposables.push(claudeAdapter);
+    }
+    const codexTransportHelper = process.env.VITEST
+        ? null
+        : new CodexAppServerHelperClient(config.codexCliPath);
+    if (codexTransportHelper) {
+        disposables.push(codexTransportHelper);
+    }
+    return {
+        adapters: [
+            claudeAdapter,
+            new CodexRuntimeAdapter({
+                homeDir: config.codexHomeDir,
+                commandPath: config.codexCliPath,
+                transportFactory: codexTransportHelper?.createTransport.bind(codexTransportHelper),
+                handleServerRequest: options.handleCodexServerRequest
+            }),
+            new OpenCodeRuntimeAdapter({
+                baseUrl: config.opencodeBaseUrl,
+                baseUrlResolver: config.opencodeBaseUrlResolver?.resolve.bind(config.opencodeBaseUrlResolver)
+            })
+        ],
+        disposables
+    };
+}
+function buildClaudeHookBridgeConfig(config) {
+    const bridgeUrl = `http://127.0.0.1:${config.port}/api/providers/claude-code/hook-bridge/events`;
+    const scriptPath = resolveClaudeHookBridgeScriptPath();
+    const command = `node "${scriptPath}" --url "${bridgeUrl}" --token "${config.claudeHookBridgeToken}"`;
+    return {
+        provider: "claude-code",
+        bridgeUrl,
+        token: config.claudeHookBridgeToken,
+        scriptPath,
+        command,
+        supportedEvents: [
+            "PreToolUse",
+            "PermissionRequest",
+            "Notification",
+            "UserPromptSubmit",
+            "SessionStart",
+            "Stop",
+            "StopFailure",
+            "SessionEnd"
+        ]
+    };
+}
+function resolveClaudeHookBridgeScriptPath() {
+    const candidates = [
+        path.resolve(process.cwd(), "scripts", "claude-hook-bridge.cjs"),
+        path.resolve(process.cwd(), "..", "scripts", "claude-hook-bridge.cjs"),
+        path.resolve(process.cwd(), "..", "..", "scripts", "claude-hook-bridge.cjs")
     ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return candidates[0];
 }
 function buildClaudeRawStoreRef(homeDir, workspacePath, sessionId) {
     return path.join(homeDir, "projects", workspaceSlug(workspacePath), `${sessionId}.jsonl`);