vibe-coding-master 0.7.44 → 0.7.46

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,66 @@ 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_SUBAGENT_MODEL: modelId,
+                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 +185,51 @@ 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"
+    "ANTHROPIC_SMALL_FAST_MODEL",
+    "CLAUDE_CODE_SUBAGENT_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 +242,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
     });

package/dist/backend/services/harness-service.js

@@ -53,11 +53,13 @@ const VCM_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM
 const VCM_STOP_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,runtimeSessionToken:process.env.VCM_RUNTIME_SESSION_TOKEN,event}));});'"'"' | curl -fsS --retry 2 --retry-delay 1 --retry-all-errors --connect-timeout 1 --max-time 2 -X POST "\${VCM_API_URL}/api/hooks/claude-code/stop" -H "content-type: application/json" --data-binary @- || true'`;
 const VCM_PERMISSION_REQUEST_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,runtimeSessionToken:process.env.VCM_RUNTIME_SESSION_TOKEN,event}));});'"'"' | curl -fsS --max-time 5 -X POST "\${VCM_API_URL}/api/hooks/claude-code/permission-request" -H "content-type: application/json" --data-binary @- || true'`;
 const VCM_BASH_GUARD_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ]; then exit 0; fi; guard=""; repo="$(git rev-parse --show-toplevel 2>/dev/null || true)"; if [ -n "$repo" ] && [ -f "$repo/.ai/tools/vcm-bash-guard" ]; then guard="$repo/.ai/tools/vcm-bash-guard"; else cwd="$(pwd -P 2>/dev/null || pwd)"; dir="$cwd"; while [ -n "$dir" ] && [ "$dir" != "/" ]; do if [ -f "$dir/.ai/tools/vcm-bash-guard" ]; then guard="$dir/.ai/tools/vcm-bash-guard"; break; fi; dir="$(dirname "$dir")"; done; if [ -z "$guard" ] && [ -n "\${CLAUDE_PROJECT_DIR:-}" ] && [ -f "\${CLAUDE_PROJECT_DIR}/.ai/tools/vcm-bash-guard" ]; then guard="\${CLAUDE_PROJECT_DIR}/.ai/tools/vcm-bash-guard"; fi; fi; [ -n "$guard" ] || exit 0; python3 "$guard" || exit 0'`;
+const VCM_SUBAGENT_GUARD_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ]; then exit 0; fi; guard=""; repo="$(git rev-parse --show-toplevel 2>/dev/null || true)"; if [ -n "$repo" ] && [ -f "$repo/.ai/tools/vcm-subagent-guard" ]; then guard="$repo/.ai/tools/vcm-subagent-guard"; else cwd="$(pwd -P 2>/dev/null || pwd)"; dir="$cwd"; while [ -n "$dir" ] && [ "$dir" != "/" ]; do if [ -f "$dir/.ai/tools/vcm-subagent-guard" ]; then guard="$dir/.ai/tools/vcm-subagent-guard"; break; fi; dir="$(dirname "$dir")"; done; if [ -z "$guard" ] && [ -n "\${CLAUDE_PROJECT_DIR:-}" ] && [ -f "\${CLAUDE_PROJECT_DIR}/.ai/tools/vcm-subagent-guard" ]; then guard="\${CLAUDE_PROJECT_DIR}/.ai/tools/vcm-subagent-guard"; fi; fi; [ -n "$guard" ] || { printf "%s\\n" "{\\"hookSpecificOutput\\":{\\"hookEventName\\":\\"PreToolUse\\",\\"permissionDecision\\":\\"deny\\",\\"permissionDecisionReason\\":\\"VCM subagent policy is unavailable. Refresh the VCM Harness before invoking subagents.\\"}}"; exit 0; }; python3 "$guard"'`;
 const VCM_BASH_DEFAULT_TIMEOUT_MS = "600000";
 const VCM_AUTO_MEMORY_ENABLED = false;
 const VCM_HOOK_DEFINITIONS = [
     { eventName: "PreToolUse", matcher: "Bash", command: VCM_BASH_GUARD_HOOK_COMMAND, timeout: 10 },
     { eventName: "PreToolUse", matcher: "Write|Edit", command: VCM_BASH_GUARD_HOOK_COMMAND, timeout: 10 },
+    { eventName: "PreToolUse", matcher: "Agent", command: VCM_SUBAGENT_GUARD_HOOK_COMMAND, timeout: 10 },
     { eventName: "UserPromptSubmit", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "PreToolUse", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "PostToolUse", command: VCM_HOOK_COMMAND, timeout: 5 },

package/dist/backend/services/session-service.js

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import path from "node:path";
 import { ROLE_NAMES, isDispatchableRole } from "../../shared/constants.js";
-import { CCR_GPT_SESSION_MODEL, isCcrSessionModel } from "../../shared/types/session.js";
+import { isCodexBridgeSessionModel } from "../../shared/types/session.js";
 import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
@@ -598,21 +598,21 @@ export function createSessionService(deps) {
         return migrateRunningProjectToolSessionCwd(repoRoot, resumed, targetCwd);
     }
     async function getModelLaunchEnvironment(model) {
-        if (!deps.ccrIntegration) {
-            if (isCcrSessionModel(model)) {
+        if (!deps.codexBridgeIntegration) {
+            if (isCodexBridgeSessionModel(model)) {
                 throw new VcmError({
-                    code: "CCR_UNAVAILABLE",
-                    message: "CCR integration is not available in this VCM runtime.",
+                    code: "CODEX_BRIDGE_UNAVAILABLE",
+                    message: "Codex Bridge integration is not available in this VCM runtime.",
                     statusCode: 409,
-                    hint: "Enable and configure CCR GPT models before starting this session."
+                    hint: "Enable and configure Codex Bridge before starting this session."
                 });
             }
             return {};
         }
-        return deps.ccrIntegration.getLaunchEnvironment(model);
+        return deps.codexBridgeIntegration.getLaunchEnvironment(model);
     }
     async function getModelLaunchSettingsOverride(model) {
-        return deps.ccrIntegration?.getLaunchSettingsOverride(model);
+        return deps.codexBridgeIntegration?.getLaunchSettingsOverride(model);
     }
     function isRuntimeSessionAlive(session) {
         if (!session || isExitedStatus(session.status) || session.pid === undefined) {
@@ -1642,7 +1642,7 @@ function normalizeClaudeModel(value) {
         || value === "claude-opus-4-8"
         || value === "sonnet"
         || value === "fable"
-        || value === CCR_GPT_SESSION_MODEL) {
+        || isCodexBridgeSessionModel(value)) {
         return value;
     }
     return "default";
@@ -1660,20 +1660,20 @@ function normalizeClaudeEffort(value) {
 }
 function assertResumeProviderCompatible(session, requestedModel) {
     const persistedModel = normalizeClaudeModel(session.model);
-    if (isCcrSessionModel(persistedModel) !== isCcrSessionModel(requestedModel)) {
+    if (isCodexBridgeSessionModel(persistedModel) !== isCodexBridgeSessionModel(requestedModel)) {
         throw new VcmError({
             code: "SESSION_PROVIDER_SWITCH_REQUIRES_RESTART",
             message: `Cannot resume ${session.role} with a different model provider.`,
             statusCode: 409,
-            hint: "Use Restart to switch between native Claude and CCR models."
+            hint: "Use Restart to switch between native Claude and Codex Bridge models."
         });
     }
-    if (isCcrSessionModel(requestedModel) && !session.claudeConfigDir) {
+    if (isCodexBridgeSessionModel(requestedModel) && !session.claudeConfigDir) {
         throw new VcmError({
-            code: "CCR_SESSION_CONFIG_MISSING",
-            message: `${session.role} was created before isolated CCR session storage was enabled.`,
+            code: "CODEX_BRIDGE_SESSION_CONFIG_MISSING",
+            message: `${session.role} was created without isolated Codex Bridge session storage.`,
             statusCode: 409,
-            hint: "Restart this role once to create an isolated CCR session."
+            hint: "Restart this role once to create an isolated Codex Bridge session."
         });
     }
 }
@@ -1713,7 +1713,7 @@ function buildUsageTelemetryEnvironment(apiUrl, role, model) {
         OTEL_LOG_TOOL_DETAILS: "0",
         OTEL_LOG_RAW_API_BODIES: "0"
     };
-    if (!apiUrl || isCcrSessionModel(model)) {
+    if (!apiUrl || isCodexBridgeSessionModel(model)) {
         return disabled;
     }
     return {

package/dist/backend/services/usage-analytics-service.js

@@ -76,7 +76,7 @@ function extractApiRequestEvents(payload) {
                     continue;
                 }
                 const model = normalizeModel(readString(attributes.model));
-                if (isCcrModel(model)) {
+                if (isCodexBridgeModel(model)) {
                     continue;
                 }
                 const sequence = readInteger(attributes["event.sequence"]);
@@ -334,9 +334,9 @@ function normalizeModel(input) {
     const model = input?.slice(0, 200).trim();
     return model && isSafeGroupKey(model) ? model : "unknown";
 }
-function isCcrModel(model) {
+function isCodexBridgeModel(model) {
     const normalized = model.toLowerCase();
-    return normalized.startsWith("gpt-") || normalized.startsWith("ccr:") || normalized.includes("codex api/");
+    return normalized.startsWith("gpt-") || normalized.startsWith("codex-bridge:");
 }
 function isSafeGroupKey(value) {
     return value !== "__proto__" && value !== "prototype" && value !== "constructor";

package/dist/backend/templates/harness/architect-agent.js

@@ -125,6 +125,7 @@ ${renderRoleMemoryRules("architect")}
 #### Code Scaffolding
 
 - Use the Agent tool to invoke \`vcm-architect-scaffold-worker\` in the foreground after the plan and Scaffold Manifest are complete. Give it the exact plan path and require it to return before this Architect turn continues.
+- Do not invoke any other subagent.
 - Use one scaffold worker. Do not run it in the background or end the Architect turn while it is active.
 - Review the worker commit, actual diff, callable surfaces, marker placement, ledger reconciliation, and L0 results yourself. Architect owns every final scaffold claim and must correct any worker error before marking planning complete.
 - Create or update only the minimum module/file scaffolding needed to make boundaries, callable surfaces, and placeholders unambiguous. Minimum limits depth (no business implementation), never breadth: every \`create\`, \`change\`, and \`delete\` item must be scaffolded.

package/dist/backend/templates/harness/coder-agent.js

@@ -50,6 +50,7 @@ ${renderRoleMemoryRules("coder")}
 ### Parallel Worker Implementation
 
 - Coder may use Claude Code subagents to invoke \`vcm-coder-worker\` for parallel implementation.
+- Do not invoke any other subagent.
 - Use workers when the task has at least 20 \`VCM:CODE\` markers and the marker distribution can form at least two worker-sized groups.
 - Under a complete scaffold, marker implementations are order-independent — signatures, types, and cross-item contracts are frozen by the scaffold — so never serialize worker-sized groups for presumed implementation-order dependencies. When a group's module-scoped checks need peers that are still unimplemented, narrow that worker's assigned validation scope instead of serializing.
 - An item counts as blocked only when a genuine implementation attempt has produced objective compile/check evidence already reported under the failure rules; prediction never blocks an item. A blocked marker item never exempts the remaining markers from worker dispatch.

package/dist/shared/types/session.js

@@ -52,32 +52,38 @@ export const CLAUDE_MODEL_OPTIONS = [
         available: true
     }
 ];
-export const CCR_LOCAL_GATEWAY_BASE_URL = "http://127.0.0.1:3456";
-export const CCR_CONTAINER_GATEWAY_BASE_URL = "http://host.docker.internal:3456";
-export const CCR_GATEWAY_BASE_URL = CCR_CONTAINER_GATEWAY_BASE_URL;
-export const CCR_GATEWAY_BASE_URLS = [
-    CCR_LOCAL_GATEWAY_BASE_URL,
-    CCR_CONTAINER_GATEWAY_BASE_URL
+export const CODEX_BRIDGE_LOCAL_BASE_URL = "http://127.0.0.1:3456";
+export const CODEX_BRIDGE_CONTAINER_BASE_URL = "http://host.docker.internal:3456";
+export const CODEX_BRIDGE_BASE_URL = CODEX_BRIDGE_CONTAINER_BASE_URL;
+export const CODEX_BRIDGE_BASE_URLS = [
+    CODEX_BRIDGE_LOCAL_BASE_URL,
+    CODEX_BRIDGE_CONTAINER_BASE_URL
 ];
-export const CCR_GPT_MODEL_ID = "Codex API/gpt-5.6-sol";
-export const CCR_GPT_SESSION_MODEL = `ccr:${CCR_GPT_MODEL_ID}`;
-export const CCR_GPT_EFFECTIVE_CONTEXT_TOKENS = 258_400;
-export const CCR_GPT_AUTO_COMPACT_WINDOW_TOKENS = CCR_GPT_EFFECTIVE_CONTEXT_TOKENS;
-export const CCR_GPT_AUTO_COMPACT_PERCENT = 90;
-export function isCcrSessionModel(model) {
-    return model === CCR_GPT_SESSION_MODEL;
+export const CODEX_BRIDGE_EFFECTIVE_CONTEXT_TOKENS = 258_400;
+export const CODEX_BRIDGE_AUTO_COMPACT_WINDOW_TOKENS = CODEX_BRIDGE_EFFECTIVE_CONTEXT_TOKENS;
+export const CODEX_BRIDGE_AUTO_COMPACT_PERCENT = 90;
+export function isCodexBridgeSessionModel(model) {
+    return typeof model === "string"
+        && model.startsWith("codex-bridge:")
+        && model.length > "codex-bridge:".length;
 }
-export function createSessionModelOptions(ccrAvailable = false, unavailableReason = "CCR GPT models are unavailable.") {
+export function toCodexBridgeSessionModel(modelId) {
+    return `codex-bridge:${modelId}`;
+}
+export function getCodexBridgeModelId(model) {
+    return model.slice("codex-bridge:".length);
+}
+export function createSessionModelOptions(codexBridgeModels = [], unavailableReason) {
     return [
         ...CLAUDE_MODEL_OPTIONS,
-        {
-            value: CCR_GPT_SESSION_MODEL,
-            label: "GPT-5.6 Sol (CCR)",
-            description: "GPT-5.6 Sol through the host CCR gateway",
-            source: "ccr",
-            available: ccrAvailable,
-            ...(ccrAvailable ? {} : { unavailableReason })
-        }
+        ...codexBridgeModels.map((model) => ({
+            value: toCodexBridgeSessionModel(model.id),
+            label: `${model.displayName ?? model.id} (Codex Bridge)`,
+            description: `${model.id} through the host Codex Bridge`,
+            source: "codex-bridge",
+            available: unavailableReason === undefined,
+            ...(unavailableReason === undefined ? {} : { unavailableReason })
+        }))
     ];
 }
 const BASE_EFFORT_OPTIONS = [