vibe-coding-master 0.7.43 → 0.7.45

package/dist/backend/services/claude-hook-service.js

@@ -158,7 +158,7 @@ export function createClaudeHookService(deps) {
             ? await deps.harnessFeedbackService?.handleTaskRetrospectiveHook(context.project.repoRoot, {
                 taskSlug: activeTask.taskSlug,
                 eventName,
-                memoryReviewSucceeded: memoryState?.status !== "failed"
+                memoryReviewStatus: memoryState?.status ?? "idle"
             })
             : false;
         if (memoryHandled || retrospectiveHandled) {
@@ -212,6 +212,16 @@ export function createClaudeHookService(deps) {
         if (memoryResult) {
             return memoryResult;
         }
+        const prompt = stringOrUndefined(input.event.prompt);
+        if (input.role === "project-manager"
+            && prompt
+            && isDirectUserPrompt(prompt)
+            && deps.workflowControlService) {
+            const workflowState = await deps.workflowControlService.getState(createWorkflowControlContext(context));
+            if (workflowState.awaitingUser) {
+                await deps.workflowControlService.resolveUserInput(createWorkflowControlContext(context));
+            }
+        }
         const session = await deps.sessionService.recordClaudeHookEvent(context.project.repoRoot, {
             taskSlug: context.taskSlug,
             role: input.role,
@@ -266,7 +276,7 @@ export function createClaudeHookService(deps) {
             handoffDir: context.task.handoffDir,
             taskSlug: context.taskSlug,
             role: input.role,
-            prompt: stringOrUndefined(input.event.prompt)
+            prompt
         });
         if (submitted) {
             await deps.architectRestartService?.recordRouteAccepted(context.project.repoRoot, context.taskSlug, submitted);
@@ -298,6 +308,7 @@ export function createClaudeHookService(deps) {
             return completedHookResult(input, eventName);
         }
         await clearStopFailureRecoveryState(context, input.role);
+        let pmAwaitingUser = false;
         if (options.allowBlock && deps.jobGuard) {
             const verdict = await deps.jobGuard.evaluateStop({
                 repoRoot: context.project.repoRoot,
@@ -319,12 +330,42 @@ export function createClaudeHookService(deps) {
                 };
             }
         }
+        if (input.role === "project-manager" && deps.workflowControlService) {
+            const workflowState = await deps.workflowControlService.getState(createWorkflowControlContext(context));
+            if (workflowState.awaitingUser) {
+                pmAwaitingUser = true;
+            }
+            else {
+                const lastAssistantMessage = stringOrUndefined(input.event.last_assistant_message);
+                if (options.allowBlock && lastAssistantMessage && asksUserQuestion(lastAssistantMessage)) {
+                    return {
+                        ok: true,
+                        eventName,
+                        taskSlug: context.taskSlug,
+                        role: input.role,
+                        sessionUpdated: false,
+                        dispatchedCount: 0,
+                        stopDecision: {
+                            behavior: "block",
+                            reason: "You asked the user a question without registering the wait. Use vcm-ask-user with the exact question, then ask that question and stop. Do not advance or route the workflow."
+                        }
+                    };
+                }
+            }
+        }
         await deps.roleStallDetector?.recordHook({
             ...createStallContext(context),
             role: input.role,
             eventName,
             event: input.event
         });
+        if (pmAwaitingUser) {
+            return recordTurnEnd(input, context, eventName, {
+                dispatchRouteFiles: false,
+                notifyGateway: true,
+                settleGuard: false
+            });
+        }
         return recordTurnEnd(input, context, eventName, {
             dispatchRouteFiles: !isReviewerRoleName(input.role),
             notifyGateway: true,
@@ -554,6 +595,17 @@ export function createClaudeHookService(deps) {
         if (!deps.autoMemoryService || !(await deps.autoMemoryService.isRoleMemoryTurn(context.taskRepoRoot, input.role))) {
             return undefined;
         }
+        const prompt = stringOrUndefined(input.event.prompt);
+        if (eventName === "UserPromptSubmit"
+            && input.role === "project-manager"
+            && prompt
+            && isDirectUserPrompt(prompt)
+            && deps.workflowControlService) {
+            const workflowState = await deps.workflowControlService.getState(createWorkflowControlContext(context));
+            if (workflowState.awaitingUser) {
+                await deps.workflowControlService.resolveUserInput(createWorkflowControlContext(context));
+            }
+        }
         const session = await deps.sessionService.recordClaudeHookEvent(context.project.repoRoot, {
             taskSlug: context.taskSlug,
             role: input.role,
@@ -593,6 +645,10 @@ export function createClaudeHookService(deps) {
             role: input.role,
             eventName
         });
+        if (eventName === "Stop") {
+            const memoryState = await deps.autoMemoryService.getState(context.project.repoRoot, context.taskRepoRoot);
+            await deps.harnessFeedbackService?.completeWaitingTaskRetrospective(context.project.repoRoot, context.taskSlug, memoryState.status);
+        }
         return {
             ok: true,
             eventName,
@@ -613,6 +669,14 @@ export function createClaudeHookService(deps) {
             ...(stoppedRole ? { stoppedRole } : {})
         };
     }
+    function createWorkflowControlContext(context) {
+        return {
+            taskRepoRoot: context.taskRepoRoot,
+            stateRoot: context.config.stateRoot,
+            handoffDir: context.task.handoffDir,
+            taskSlug: context.taskSlug
+        };
+    }
     async function isCurrentRoleHook(context, input, eventName) {
         const current = await deps.sessionService.getRoleSession(context.project.repoRoot, context.taskSlug, input.role);
         return Boolean(current && matchesRoleHookSession(current, {
@@ -1017,3 +1081,17 @@ function normalizeDiagnosticString(value, maxLength) {
 function stringOrUndefined(value) {
     return typeof value === "string" ? value : undefined;
 }
+function isDirectUserPrompt(prompt) {
+    const normalized = prompt.trim();
+    return normalized.length > 0 && !/^\[VCM(?:\s|\])/i.test(normalized);
+}
+function asksUserQuestion(message) {
+    const withoutCodeBlocks = message.replace(/```[\s\S]*?```/g, "");
+    const lines = withoutCodeBlocks
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    return lines.some((line) => /[?？]["')\]}】”’]*$/.test(line)
+        || /^(?:please\s+(?:answer|choose|confirm|decide|provide|select|tell)|(?:can|could|do|does|is|are|should|will|would)\s+you\b)/i.test(line)
+        || /^(?:请(?:回答|选择|确认|决定|提供|告知)|你(?:是否|能否|要不要|可否)|是否需要你|需要你(?:选择|确认|决定|提供|告知))/.test(line));
+}

package/dist/backend/services/{ccr-integration-service.js → codex-bridge-integration-service.js}

@@ -1,19 +1,19 @@
-import { CCR_GATEWAY_BASE_URL, CCR_GPT_AUTO_COMPACT_PERCENT, CCR_GPT_AUTO_COMPACT_WINDOW_TOKENS, CCR_GPT_EFFECTIVE_CONTEXT_TOKENS, CCR_GPT_MODEL_ID, createSessionModelOptions, isCcrSessionModel } from "../../shared/types/session.js";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { CODEX_BRIDGE_AUTO_COMPACT_PERCENT, CODEX_BRIDGE_AUTO_COMPACT_WINDOW_TOKENS, CODEX_BRIDGE_BASE_URL, CODEX_BRIDGE_EFFECTIVE_CONTEXT_TOKENS, createSessionModelOptions, getCodexBridgeModelId, isCodexBridgeSessionModel } from "../../shared/types/session.js";
 import { VcmError } from "../errors.js";
 import { resolveVcmDataDir } from "../vcm-data-dir.js";
 const DEFAULT_CACHE_TTL_MS = 10_000;
-const DEFAULT_API_KEY_HELPER_PATH = fileURLToPath(new URL("../../../scripts/ccr-api-key-helper.mjs", import.meta.url));
-export function createCcrIntegrationService(deps) {
+const DEFAULT_API_KEY_HELPER_PATH = fileURLToPath(new URL("../../../scripts/codex-bridge-api-key-helper.mjs", import.meta.url));
+export function createCodexBridgeIntegrationService(deps) {
     const now = deps.now ?? (() => new Date());
     const cacheTtlMs = deps.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
     const baseEnv = deps.baseEnv ?? process.env;
-    const configDir = deps.configDir ?? path.join(resolveVcmDataDir(baseEnv), "claude", "ccr");
+    const configDir = deps.configDir ?? path.join(resolveVcmDataDir(baseEnv), "claude", "codex-bridge");
     let cachedProbe;
     let inFlight;
     async function probe(force = false) {
-        const settings = await deps.settings.getCcrIntegrationSettings();
+        const settings = await deps.settings.getCodexBridgeIntegrationSettings();
         if (!settings.apiKey) {
             throw missingApiKeyError();
         }
@@ -24,7 +24,7 @@ export function createCcrIntegrationService(deps) {
         if (inFlight) {
             return inFlight;
         }
-        inFlight = deps.gateway.probe(settings.apiKey).then((result) => {
+        inFlight = deps.bridge.probe(settings.apiKey).then((result) => {
             const checkedAtDate = now();
             cachedProbe = {
                 result,
@@ -38,14 +38,15 @@ export function createCcrIntegrationService(deps) {
         return inFlight;
     }
     async function buildStatus(options = {}) {
-        const settings = await deps.settings.getCcrIntegrationSettings();
+        const settings = await deps.settings.getCodexBridgeIntegrationSettings();
         if (!settings.enabled) {
             return createStatus({
                 enabled: false,
                 apiKeyConfigured: Boolean(settings.apiKey),
                 connectionState: "disabled",
                 modelAvailable: false,
-                error: settings.apiKey ? undefined : "Save a CCR API key before enabling CCR GPT models."
+                models: [],
+                error: settings.apiKey ? undefined : "Save a Codex Bridge API key before enabling Codex models."
             });
         }
         if (!cachedProbe && options.refreshIfMissing) {
@@ -56,7 +57,8 @@ export function createCcrIntegrationService(deps) {
                 enabled: true,
                 apiKeyConfigured: true,
                 connectionState: "checking",
-                modelAvailable: false
+                modelAvailable: false,
+                models: []
             });
         }
         return createStatus({
@@ -64,13 +66,14 @@ export function createCcrIntegrationService(deps) {
             apiKeyConfigured: true,
             connectionState: cachedProbe.result.connectionState,
             modelAvailable: cachedProbe.result.modelAvailable,
+            models: cachedProbe.result.models,
             checkedAt: cachedProbe.checkedAt,
             error: cachedProbe.result.error
         });
     }
     return {
         async initialize() {
-            const settings = await deps.settings.getCcrIntegrationSettings();
+            const settings = await deps.settings.getCodexBridgeIntegrationSettings();
             if (settings.enabled) {
                 await probe(true);
             }
@@ -80,15 +83,15 @@ export function createCcrIntegrationService(deps) {
         },
         async updateSettings(input) {
             if (input.apiKey !== undefined && typeof input.apiKey !== "string") {
-                throw invalidSettingsError("CCR API key must be a string.");
+                throw invalidSettingsError("Codex Bridge API key must be a string.");
             }
             if (input.enabled !== undefined && typeof input.enabled !== "boolean") {
-                throw invalidSettingsError("CCR enabled state must be a boolean.");
+                throw invalidSettingsError("Codex Bridge enabled state must be a boolean.");
             }
             if (input.clearApiKey !== undefined && typeof input.clearApiKey !== "boolean") {
-                throw invalidSettingsError("CCR clear-key state must be a boolean.");
+                throw invalidSettingsError("Codex Bridge clear-key state must be a boolean.");
             }
-            const current = await deps.settings.getCcrIntegrationSettings();
+            const current = await deps.settings.getCodexBridgeIntegrationSettings();
             const clearApiKey = input.clearApiKey === true;
             const nextApiKey = clearApiKey
                 ? ""
@@ -99,7 +102,7 @@ export function createCcrIntegrationService(deps) {
             if (nextEnabled && !nextApiKey) {
                 throw missingApiKeyError();
             }
-            await deps.settings.updateCcrIntegrationSettings({
+            await deps.settings.updateCodexBridgeIntegrationSettings({
                 enabled: nextEnabled,
                 apiKey: nextApiKey
             });
@@ -114,64 +117,65 @@ export function createCcrIntegrationService(deps) {
             return buildStatus();
         },
         async checkConnection() {
-            const settings = await deps.settings.getCcrIntegrationSettings();
+            const settings = await deps.settings.getCodexBridgeIntegrationSettings();
             if (!settings.enabled) {
                 throw new VcmError({
-                    code: "CCR_DISABLED",
-                    message: "CCR GPT models are disabled.",
+                    code: "CODEX_BRIDGE_DISABLED",
+                    message: "Codex Bridge models are disabled.",
                     statusCode: 409,
-                    hint: "Save the CCR API key and enable CCR GPT models before checking the connection."
+                    hint: "Save the Codex Bridge API key and enable Codex models before checking the connection."
                 });
             }
             await probe(true);
             return buildStatus();
         },
         async getLaunchEnvironment(model) {
-            if (!isCcrSessionModel(model)) {
+            if (!isCodexBridgeSessionModel(model)) {
                 return buildNativeLaunchEnvironment(baseEnv);
             }
-            const settings = await deps.settings.getCcrIntegrationSettings();
+            const settings = await deps.settings.getCodexBridgeIntegrationSettings();
             if (!settings.enabled) {
                 throw new VcmError({
-                    code: "CCR_DISABLED",
-                    message: "CCR GPT models are disabled.",
+                    code: "CODEX_BRIDGE_DISABLED",
+                    message: "Codex Bridge models are disabled.",
                     statusCode: 409,
-                    hint: "Enable CCR GPT models in VCM Settings before starting this session."
+                    hint: "Enable Codex Bridge in VCM Settings before starting this session."
                 });
             }
             const checked = await probe();
-            if (checked.result.connectionState !== "available" || !checked.result.modelAvailable) {
+            const modelId = getCodexBridgeModelId(model);
+            const modelAvailable = checked.result.models.some((available) => available.id === modelId);
+            if (checked.result.connectionState !== "available" || !modelAvailable) {
                 throw new VcmError({
-                    code: "CCR_MODEL_UNAVAILABLE",
-                    message: checked.result.error ?? `CCR model ${CCR_GPT_MODEL_ID} is unavailable.`,
+                    code: "CODEX_BRIDGE_MODEL_UNAVAILABLE",
+                    message: checked.result.error ?? `Codex Bridge model ${modelId} is unavailable.`,
                     statusCode: 409,
-                    hint: "Check that host CCR is running on port 3456 and exposes GPT-5.6 Sol."
+                    hint: "Check Codex Bridge on port 3456, refresh its Codex login, and verify the selected model."
                 });
             }
-            const gatewayBaseUrl = checked.result.baseUrl ?? CCR_GATEWAY_BASE_URL;
-            const gatewayHost = new URL(gatewayBaseUrl).hostname;
-            const noProxy = mergeNoProxy(deps.baseEnv?.NO_PROXY ?? deps.baseEnv?.no_proxy ?? process.env.NO_PROXY ?? process.env.no_proxy, gatewayHost);
+            const bridgeBaseUrl = checked.result.baseUrl ?? CODEX_BRIDGE_BASE_URL;
+            const bridgeHost = new URL(bridgeBaseUrl).hostname;
+            const noProxy = mergeNoProxy(deps.baseEnv?.NO_PROXY ?? deps.baseEnv?.no_proxy ?? process.env.NO_PROXY ?? process.env.no_proxy, bridgeHost);
             return {
-                ANTHROPIC_BASE_URL: gatewayBaseUrl,
-                ANTHROPIC_API_BASE_URL: gatewayBaseUrl,
-                CLAUDE_AGENT_API_BASE_URL: gatewayBaseUrl,
+                ANTHROPIC_BASE_URL: bridgeBaseUrl,
+                ANTHROPIC_API_BASE_URL: bridgeBaseUrl,
+                CLAUDE_AGENT_API_BASE_URL: bridgeBaseUrl,
                 ANTHROPIC_AUTH_TOKEN: undefined,
                 ANTHROPIC_API_KEY: undefined,
-                ANTHROPIC_MODEL: CCR_GPT_MODEL_ID,
-                CCR_CLAUDE_CODE_MODEL: CCR_GPT_MODEL_ID,
-                CODEXL_CLAUDE_CODE_MODEL: CCR_GPT_MODEL_ID,
-                ANTHROPIC_SMALL_FAST_MODEL: CCR_GPT_MODEL_ID,
+                ANTHROPIC_MODEL: modelId,
+                CODEX_BRIDGE_CLAUDE_MODEL: modelId,
+                ANTHROPIC_SMALL_FAST_MODEL: modelId,
                 CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: "1",
-                CLAUDE_CODE_MAX_CONTEXT_TOKENS: String(CCR_GPT_EFFECTIVE_CONTEXT_TOKENS),
-                CLAUDE_CODE_AUTO_COMPACT_WINDOW: String(CCR_GPT_AUTO_COMPACT_WINDOW_TOKENS),
-                CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: String(CCR_GPT_AUTO_COMPACT_PERCENT),
+                CLAUDE_CODE_MAX_CONTEXT_TOKENS: String(CODEX_BRIDGE_EFFECTIVE_CONTEXT_TOKENS),
+                CLAUDE_CODE_AUTO_COMPACT_WINDOW: String(CODEX_BRIDGE_AUTO_COMPACT_WINDOW_TOKENS),
+                CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: String(CODEX_BRIDGE_AUTO_COMPACT_PERCENT),
                 CLAUDE_CONFIG_DIR: configDir,
                 NO_PROXY: noProxy,
                 no_proxy: noProxy
             };
         },
         async getLaunchSettingsOverride(model) {
-            if (!isCcrSessionModel(model)) {
+            if (!isCodexBridgeSessionModel(model)) {
                 return undefined;
             }
             return {
@@ -180,51 +184,50 @@ export function createCcrIntegrationService(deps) {
         }
     };
 }
-const CCR_BASE_URL_KEYS = [
+const BRIDGE_BASE_URL_KEYS = [
     "ANTHROPIC_BASE_URL",
     "ANTHROPIC_API_BASE_URL",
     "CLAUDE_AGENT_API_BASE_URL"
 ];
-const CCR_MODEL_KEYS = [
+const BRIDGE_MODEL_KEYS = [
     "ANTHROPIC_MODEL",
     "ANTHROPIC_SMALL_FAST_MODEL"
 ];
-const CCR_ONLY_ENV_KEYS = [
-    "CCR_CLAUDE_CODE_MODEL",
-    "CODEXL_CLAUDE_CODE_MODEL",
+const BRIDGE_ONLY_ENV_KEYS = [
+    "CODEX_BRIDGE_CLAUDE_MODEL",
     "CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY"
 ];
 export function buildNativeLaunchEnvironment(baseEnv) {
     const environment = {};
-    let inheritedCcrTakeover = false;
+    let inheritedBridgeTakeover = false;
     if (baseEnv.CLAUDE_CONFIG_DIR?.trim()) {
         environment.CLAUDE_CONFIG_DIR = baseEnv.CLAUDE_CONFIG_DIR.trim();
     }
-    for (const key of CCR_BASE_URL_KEYS) {
-        if (isCcrGatewayUrl(baseEnv[key])) {
+    for (const key of BRIDGE_BASE_URL_KEYS) {
+        if (isCodexBridgeUrl(baseEnv[key])) {
             environment[key] = undefined;
-            inheritedCcrTakeover = true;
+            inheritedBridgeTakeover = true;
         }
     }
-    for (const key of CCR_MODEL_KEYS) {
-        if (isCcrModelName(baseEnv[key])) {
+    for (const key of BRIDGE_MODEL_KEYS) {
+        if (isCodexBridgeModelName(baseEnv[key], baseEnv.CODEX_BRIDGE_CLAUDE_MODEL)) {
             environment[key] = undefined;
-            inheritedCcrTakeover = true;
+            inheritedBridgeTakeover = true;
         }
     }
-    for (const key of CCR_ONLY_ENV_KEYS) {
+    for (const key of BRIDGE_ONLY_ENV_KEYS) {
         if (baseEnv[key] !== undefined) {
             environment[key] = undefined;
-            inheritedCcrTakeover = true;
+            inheritedBridgeTakeover = true;
         }
     }
-    if (inheritedCcrTakeover) {
+    if (inheritedBridgeTakeover) {
         environment.ANTHROPIC_AUTH_TOKEN = undefined;
         environment.ANTHROPIC_API_KEY = undefined;
     }
     return environment;
 }
-function isCcrGatewayUrl(value) {
+function isCodexBridgeUrl(value) {
     if (!value) {
         return false;
     }
@@ -237,32 +240,29 @@ function isCcrGatewayUrl(value) {
         return false;
     }
 }
-function isCcrModelName(value) {
-    if (!value) {
-        return false;
-    }
-    return value === CCR_GPT_MODEL_ID
-        || value.startsWith("anthropic/claude-ccr-h");
+function isCodexBridgeModelName(value, bridgeModel) {
+    return Boolean(value && bridgeModel && value === bridgeModel);
 }
 function createStatus(input) {
+    const { models, ...status } = input;
     const reason = input.error
-        ?? (input.enabled ? "CCR GPT-5.6 Sol is unavailable." : "Enable CCR GPT models in Settings.");
+        ?? (input.enabled ? "Codex Bridge models are unavailable." : "Enable Codex Bridge in Settings.");
     return {
-        ...input,
-        modelOptions: createSessionModelOptions(input.enabled && input.modelAvailable, reason)
+        ...status,
+        modelOptions: createSessionModelOptions(models, input.enabled && input.modelAvailable ? undefined : reason)
     };
 }
 function missingApiKeyError() {
     return new VcmError({
-        code: "CCR_API_KEY_MISSING",
-        message: "CCR API key is not configured.",
+        code: "CODEX_BRIDGE_API_KEY_MISSING",
+        message: "Codex Bridge API key is not configured.",
         statusCode: 400,
-        hint: "Save the CCR API key before enabling CCR GPT models."
+        hint: "Save the Codex Bridge API key before enabling Codex models."
     });
 }
 function invalidSettingsError(message) {
     return new VcmError({
-        code: "CCR_SETTINGS_INVALID",
+        code: "CODEX_BRIDGE_SETTINGS_INVALID",
         message,
         statusCode: 400
     });