vibe-coding-master 0.7.43 → 0.7.45

package/README.md

@@ -190,6 +190,12 @@ restart, but it does not infer transitions or choose the next role. Current
 artifacts, Gate Review state, Round/Turn state, and the role rules remain
 authoritative.
 
+Whenever Project Manager asks the user a question, it first uses
+`vcm-ask-user`. VCM records the wait and cancels any pending role dispatch in
+one state update. Stop Hook then ends the PM turn without route scanning. Only
+a new direct user message clears the wait, and the next role dispatch requires
+a fresh Workflow Review.
+
 Typical flow:
 
 ```text
@@ -237,18 +243,18 @@ Open `Usage Analytics` in the sidebar `Task` section to inspect native Claude
 Code usage for the active task. The report shows task totals and breakdowns by
 role and model for input, output, cache-read, and cache-creation tokens plus
 estimated USD cost. It combines every restart and resumed Claude session for
-all seven roles. CCR/GPT usage is excluded.
+all seven roles. Codex Bridge usage is excluded.
 
 VCM retains only aggregate task data in
 `<task-worktree>/.ai/vcm/telemetry/usage.json`. The file is temporary runtime
 state and is removed with the task worktree when the task is closed.
 
-### GPT Through Claude Code Router
+### GPT Through Codex Bridge
 
-VCM can launch its normal Claude Code sessions with `GPT-5.6 Sol (CCR)` through
-a host-running [Claude Code Router](https://github.com/musistudio/claude-code-router).
-CCR must already be installed, authenticated, configured, and running on the
-host. VCM does not manage the CCR process.
+VCM can launch its normal Claude Code sessions with models provided by a
+host-running Codex Bridge. The Bridge must already be installed and running,
+and Codex must be logged in on the host. VCM does not manage the Bridge process
+or Codex login.
 
 VCM automatically checks the local-host and DevContainer endpoints:
 
@@ -257,36 +263,34 @@ http://127.0.0.1:3456
 http://host.docker.internal:3456
 ```
 
-Configure CCR to listen on port `3456` with an API key. When VCM runs in a
-DevContainer, make the second endpoint reachable from the container. In the VCM
-`Settings` section:
+Configure Codex Bridge to listen on port `3456`. When VCM runs in a
+DevContainer, start it with a container-reachable bind address such as
+`codex-bridge serve --host 0.0.0.0 --port 3456`. In the VCM `Settings` section:
 
-1. enter and save the CCR API key;
-2. enable `CCR GPT models`;
+1. enter and save the Codex Bridge API key;
+2. enable `Codex Bridge models`;
 3. confirm the status is `available`;
-4. select `GPT-5.6 Sol (CCR)` in any Session model control.
+4. select any discovered Codex Bridge model in a Session model control.
 
 The key is stored in global VCM state (`~/.vcm/settings.json`) with owner-only
-permissions and is never returned by the settings API. It is used for CCR
-checks, model discovery, and the GPT-only `apiKeyHelper`. GPT sessions receive a
+permissions and is never returned by the settings API. It is used for Bridge
+checks, model discovery, and the Bridge-only `apiKeyHelper`. Bridge sessions receive a
 child-only `--settings` override and use the isolated Claude configuration root
-`~/.vcm/claude/ccr`. VCM never edits `~/.claude/settings.json`. Native Claude
+`~/.vcm/claude/codex-bridge`. VCM never edits `~/.claude/settings.json`. Native Claude
 sessions keep their normal configuration and account authentication; VCM only
-removes inherited environment variables that clearly point at the local CCR
-gateway from the native child process. Configure CCR without enabling its
-global Claude Code or Claude App takeover if those clients should remain on
-Anthropic.
+removes inherited environment variables that clearly point at the local Bridge
+from the native child process.
 
-CCR/GPT child processes use a hard context limit and auto-compaction window of
+Codex Bridge child processes use a hard context limit and auto-compaction window of
 `258400` tokens. VCM sets Claude Code's proactive compaction threshold to `90%`
-(about `232560` tokens), leaving headroom before the gateway limit. Native
+(about `232560` tokens), leaving headroom before the Codex API limit. Native
 Claude sessions receive no VCM-owned context override.
 
 Resume keeps the provider recorded by the existing Session. Use Restart when
-switching between a native Claude model and `GPT-5.6 Sol (CCR)`. If CCR is
-disabled, unreachable, rejects the key, or does not expose
-`Codex API/gpt-5.6-sol`, VCM blocks the new Start, Resume, or Restart and does
-not fall back to another model.
+switching between native Claude and Codex Bridge. If the Bridge is disabled,
+unreachable, rejects the key, has unavailable Codex credentials, or no longer
+exposes the selected model, VCM blocks the new Start, Resume, or Restart and
+does not fall back to another model.
 
 ## Launch Template
 
@@ -329,7 +333,8 @@ strict `workflow-progress.md` transition through `vcm-workflow-review`. VCM
 checks the confirmed dispatch history and current task artifacts, then grants
 one matching route. The target role's `UserPromptSubmit` consumes that approval
 and appends the confirmed transition. A rejected transition can be bypassed
-only by an exact one-time user authorization recorded through the VCM dialog.
+only by the user's exact one-time authorization recorded in the next Workflow
+Progress submission.
 
 If the flow stops, VCM always shows a blocking pause alert. `Pause alert sound`
 only controls the looping sound. Enabling Gateway turns that preference off once;
@@ -475,11 +480,14 @@ Use it to:
   appropriate
 
 VCM bundles the Claude Code LSP bridge and loads it only for Architect sessions,
-including CCR launches. The project environment must still
+including Codex Bridge launches. The project environment must still
 provide the language server for each detected language: `rust-analyzer`,
 `typescript-language-server`, `pyright-langserver`, `gopls`, `clangd`, or
 `jdtls`. Architect preloads `vcm-code-navigation` and uses LSP for semantic
-relationships; other roles use generated context and ordinary source reads.
+relationships. Accessors, backing fields, trait items, implementations, wrappers,
+and aliases are queried as separate symbols; a bounded source-text fallback may
+only locate candidates after the correct LSP query is demonstrably partial.
+Other roles use generated context and ordinary source reads.
 Harness Studio reports
 whether the server executable and plugin can run; the role Session performs the
 real workspace indexing and semantic query retries. VCM uses Claude Code progress
@@ -498,10 +506,11 @@ files.
 `Auto memory` is the switch for the entire automated memory workflow. During
 Review Task Harness after Final Acceptance, Project Manager, Architect, Coder,
 Tester, and an enabled Reviewer submit proposals in sequence through
-`vcm-propose-memory`. Harness Engineer verifies and consolidates them before VCM
-records the result as part of the same Task Harness Retrospective. Workflow roles
-cannot edit active memory directly; Harness Engineer edits it only during the
-assigned Auto Memory Retrospective.
+`vcm-propose-memory`. Harness Engineer verifies and consolidates them, commits
+the reviewed memory, and writes the assigned machine-readable review result as
+part of the same Task Harness Retrospective. Workflow roles cannot edit active
+memory directly; Harness Engineer edits it only during the assigned Auto Memory
+Retrospective.
 
 When Auto Memory is enabled, the planning Architect writes a provisional memory
 candidate before its post-planning Session restart. VCM snapshots that candidate
@@ -528,7 +537,10 @@ Final Acceptance
        -> Review pending Harness Feedback
        -> Review Auto Memory proposals, when Auto Memory is enabled
        -> Harness Engineer updates and commits memory, when Auto Memory is enabled
-  -> VCM records the committed memory result
+       -> Harness Engineer writes review-result.json, when Auto Memory is enabled
+  -> VCM validates and records the committed memory result
+  -> VCM dispatches durable-document assignments one at a time
+  -> Complete Task Harness Retrospective after every assignment completes
 ```
 
 Memory proposal prompts sent to Project Manager, Architect, Coder, Tester, and
@@ -542,16 +554,29 @@ impact, and durable-document disposition, then evaluates every proposal item
 independently. Each Add or Update decision records why the memory is necessary,
 what happens if it is absent, whether it belongs in memory or a durable
 document, and the exact final memory content when retained. VCM validates that
-the commit changes only assigned memory host files and only their
-`<VCM-memory>` blocks; it does not parse or apply Harness Engineer's semantic
-decisions. Harness Engineer review and retrospective work remain tool role
-activity and do not participate in Round completion.
+every existing entry and proposal has one structurally valid decision, every
+move decision has one durable-document assignment, moved content has already
+been removed from memory, and the commit changes only assigned memory host
+files and only their `<VCM-memory>` blocks. VCM does not decide whether the
+Harness Engineer's semantic judgment is correct. Harness Engineer review and
+retrospective work remain tool role activity and do not participate in Round
+completion.
+
+For `move-to-durable-doc`, memory is removed in the Harness Engineer commit
+before documentation work starts. VCM assigns architecture and known-issues
+documents to Architect and testing documentation to Tester. For another target,
+PM selects Architect, Coder, or Tester and asks the user only when ownership
+cannot be determined. These assignments are backend-dispatched work rather than
+a Docs-Only Flow. Each owner updates and commits the document, submits the exact
+assignment ID in `docs-update-report.md`, and finishes before the next assignment
+starts. Harness Studio shows assignment status and allows failed work to be
+retried.
 
 When Auto Memory is disabled, Review Task Harness does not collect proposals or
 ask Harness Engineer to update memory. When enabled, both automatic and manual
 review requests collect proposals before starting the retrospective. A failed
-proposal collection or combined retrospective memory review must be retried
-from Harness Studio.
+proposal collection, combined retrospective memory review, or durable-document
+assignment must be retried from Harness Studio.
 
 ## Closing a Task
 

package/dist/backend/adapters/claude-adapter.js

@@ -1,5 +1,5 @@
 import { roleRuntimeDisallowedTools, roleUsesLsp } from "../role-tool-policy.js";
-import { isCcrSessionModel } from "../../shared/types/session.js";
+import { isCodexBridgeSessionModel } from "../../shared/types/session.js";
 import { VcmError } from "../errors.js";
 export function createClaudeAdapter(runner) {
     return {
@@ -33,7 +33,7 @@ export function createClaudeAdapter(runner) {
             if (claudeSessionId) {
                 args.push(resume ? "--resume" : "--session-id", claudeSessionId);
             }
-            if (!isCcrSessionModel(model)) {
+            if (!isCodexBridgeSessionModel(model)) {
                 args.push("--model", model);
             }
             if (effort === "ultracode") {

package/dist/backend/adapters/codex-bridge-adapter.js

@@ -0,0 +1,213 @@
+import { CODEX_BRIDGE_BASE_URLS } from "../../shared/types/session.js";
+const DEFAULT_TIMEOUT_MS = 3_000;
+export function createCodexBridgeAdapter(deps = {}) {
+    const baseUrls = (deps.baseUrl ? [deps.baseUrl] : CODEX_BRIDGE_BASE_URLS)
+        .map((baseUrl) => baseUrl.replace(/\/+$/, ""));
+    const fetchImpl = deps.fetch ?? globalThis.fetch;
+    const timeoutMs = deps.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    return {
+        async probe(apiKey) {
+            const failures = [];
+            for (const baseUrl of baseUrls) {
+                const result = await probeEndpoint(fetchImpl, baseUrl, apiKey, timeoutMs);
+                if (result.baseUrl) {
+                    return result;
+                }
+                failures.push(result);
+            }
+            return combineProbeFailures(baseUrls, failures);
+        }
+    };
+}
+async function probeEndpoint(fetchImpl, baseUrl, apiKey, timeoutMs) {
+    try {
+        const health = await requestJson(fetchImpl, `${baseUrl}/health`, timeoutMs);
+        if (!health.response.ok) {
+            return invalidResponse(`Codex Bridge health check at ${baseUrl} returned HTTP ${health.response.status}.`);
+        }
+        if (!isCodexBridgeHealth(health.payload)) {
+            return {
+                connectionState: "not-codex-bridge",
+                modelAvailable: false,
+                models: [],
+                error: `${baseUrl} did not identify as Codex Bridge.`
+            };
+        }
+        const headers = {
+            authorization: `Bearer ${apiKey}`,
+            "user-agent": "VibeCodingMaster"
+        };
+        const auth = await requestJson(fetchImpl, `${baseUrl}/auth/status`, timeoutMs, headers);
+        if (auth.response.status === 401 || auth.response.status === 403) {
+            return {
+                connectionState: "unauthorized",
+                modelAvailable: false,
+                models: [],
+                baseUrl,
+                error: "Codex Bridge rejected the configured API key."
+            };
+        }
+        if (!auth.response.ok) {
+            return invalidResponse(responseError("Codex Bridge auth status", baseUrl, auth.response, auth.payload), baseUrl);
+        }
+        const authState = readAuthState(auth.payload);
+        if (!authState) {
+            return invalidResponse("Codex Bridge returned an invalid /auth/status response.", baseUrl);
+        }
+        if (authState.state !== "ready") {
+            return {
+                connectionState: "codex-auth-unavailable",
+                modelAvailable: false,
+                models: [],
+                baseUrl,
+                error: authState.message
+                    ?? `Codex authentication is ${authState.state}. Open Codex or run codex login, then retry.`
+            };
+        }
+        const modelsResponse = await requestJson(fetchImpl, `${baseUrl}/v1/models`, timeoutMs, headers);
+        if (!modelsResponse.response.ok) {
+            const code = readErrorCode(modelsResponse.payload);
+            const connectionState = code?.startsWith("CODEX_AUTH_")
+                ? "codex-auth-unavailable"
+                : modelsResponse.response.status === 401 || modelsResponse.response.status === 403
+                    ? "unauthorized"
+                    : "invalid-response";
+            return {
+                connectionState,
+                modelAvailable: false,
+                models: [],
+                baseUrl,
+                error: responseError("Codex Bridge model discovery", baseUrl, modelsResponse.response, modelsResponse.payload)
+            };
+        }
+        const models = readModelDescriptors(modelsResponse.payload);
+        if (!models) {
+            return invalidResponse("Codex Bridge returned an invalid /v1/models response.", baseUrl);
+        }
+        return {
+            connectionState: "available",
+            modelAvailable: models.length > 0,
+            models,
+            baseUrl,
+            ...(models.length > 0 ? {} : { error: "Codex Bridge did not expose any models." })
+        };
+    }
+    catch (error) {
+        const timedOut = isAbortError(error);
+        return {
+            connectionState: "unreachable",
+            modelAvailable: false,
+            models: [],
+            error: timedOut
+                ? `Codex Bridge connection timed out after ${timeoutMs} ms at ${baseUrl}.`
+                : `Codex Bridge could not be reached from the VCM backend at ${baseUrl}. Reason: ${errorMessage(error)}`
+        };
+    }
+}
+function combineProbeFailures(baseUrls, failures) {
+    const lastFailure = failures.at(-1);
+    return {
+        connectionState: lastFailure?.connectionState ?? "unreachable",
+        modelAvailable: false,
+        models: [],
+        error: `Codex Bridge was not found at ${baseUrls.join(" or ")}. ${failures
+            .map((failure) => failure.error)
+            .filter(Boolean)
+            .join(" ")}`.trim()
+    };
+}
+async function requestJson(fetchImpl, url, timeoutMs, headers = {}) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetchImpl(url, {
+            method: "GET",
+            headers: {
+                accept: "application/json",
+                ...headers
+            },
+            signal: controller.signal
+        });
+        let payload;
+        try {
+            payload = await response.json();
+        }
+        catch {
+            payload = undefined;
+        }
+        return { response, payload };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function isCodexBridgeHealth(value) {
+    return isObject(value)
+        && value.status === "ok"
+        && value.service === "codex-bridge";
+}
+function readAuthState(value) {
+    if (!isObject(value) || typeof value.state !== "string" || !value.state.trim()) {
+        return undefined;
+    }
+    return {
+        state: value.state.trim(),
+        ...(typeof value.message === "string" && value.message.trim()
+            ? { message: value.message.trim() }
+            : {})
+    };
+}
+function readModelDescriptors(value) {
+    if (!isObject(value) || !Array.isArray(value.data)) {
+        return undefined;
+    }
+    const models = [];
+    for (const item of value.data) {
+        if (!isObject(item) || typeof item.id !== "string" || !item.id.trim()) {
+            return undefined;
+        }
+        models.push({
+            id: item.id.trim(),
+            ...(typeof item.display_name === "string" && item.display_name.trim()
+                ? { displayName: item.display_name.trim() }
+                : {})
+        });
+    }
+    return models;
+}
+function responseError(operation, baseUrl, response, payload) {
+    const message = readErrorMessage(payload);
+    return `${operation} at ${baseUrl} returned HTTP ${response.status}.${message ? ` Reason: ${message}` : ""}`;
+}
+function readErrorCode(value) {
+    return isObject(value)
+        && isObject(value.error)
+        && typeof value.error.code === "string"
+        ? value.error.code
+        : undefined;
+}
+function readErrorMessage(value) {
+    return isObject(value)
+        && isObject(value.error)
+        && typeof value.error.message === "string"
+        ? value.error.message
+        : undefined;
+}
+function invalidResponse(error, baseUrl) {
+    return {
+        connectionState: "invalid-response",
+        modelAvailable: false,
+        models: [],
+        ...(baseUrl ? { baseUrl } : {}),
+        error
+    };
+}
+function isAbortError(error) {
+    return error instanceof Error && error.name === "AbortError";
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/backend/api/app-settings-routes.js

@@ -5,13 +5,13 @@ export function registerAppSettingsRoutes(app, deps) {
     app.put("/api/settings/preferences", async (request) => {
         return deps.appSettings.updatePreferences(request.body ?? {});
     });
-    app.get("/api/settings/ccr", async () => {
-        return deps.ccrIntegration.getStatus();
+    app.get("/api/settings/codex-bridge", async () => {
+        return deps.codexBridgeIntegration.getStatus();
     });
-    app.put("/api/settings/ccr", async (request) => {
-        return deps.ccrIntegration.updateSettings(request.body ?? {});
+    app.put("/api/settings/codex-bridge", async (request) => {
+        return deps.codexBridgeIntegration.updateSettings(request.body ?? {});
     });
-    app.post("/api/settings/ccr/check", async () => {
-        return deps.ccrIntegration.checkConnection();
+    app.post("/api/settings/codex-bridge/check", async () => {
+        return deps.codexBridgeIntegration.checkConnection();
     });
 }

package/dist/backend/api/artifact-routes.js

@@ -144,6 +144,9 @@ function artifactNameToPath(paths, artifactName) {
     if (artifactName === "test-report.md") {
         return paths.testReportPath;
     }
+    if (artifactName === "docs-update-report.md") {
+        return paths.docsUpdateReportPath;
+    }
     if (artifactName === "docs-sync-report.md") {
         return paths.docsSyncReportPath;
     }

package/dist/backend/api/harness-routes.js

@@ -208,6 +208,22 @@ export function registerHarnessRoutes(app, deps) {
         const { project, task } = await requireHarnessTaskContext(deps, request.body?.taskSlug);
         return deps.autoMemoryService.retryFailedReview(project.repoRoot, task.worktreePath);
     });
+    app.post("/api/projects/harness/memory/assignments/retry", async (request) => {
+        const { project, task } = await requireHarnessTaskContext(deps, request.body?.taskSlug);
+        return deps.autoMemoryService.retryDurableDocAssignment(project.repoRoot, task.worktreePath, request.body?.assignmentId ?? "");
+    });
+    app.post("/api/projects/harness/memory/assignments/owner", async (request) => {
+        const { project, task } = await requireHarnessTaskContext(deps, request.body?.taskSlug);
+        const owner = request.body?.owner;
+        if (owner !== "architect" && owner !== "coder" && owner !== "tester") {
+            throw new VcmError({
+                code: "DURABLE_DOC_OWNER_INVALID",
+                message: "Durable-document owner must be architect, coder, or tester.",
+                statusCode: 400
+            });
+        }
+        return deps.autoMemoryService.resolveDurableDocAssignmentOwner(project.repoRoot, task.worktreePath, request.body?.assignmentId ?? "", owner);
+    });
 }
 async function persistHarnessEngineerDefaults(appSettings, session) {
     const defaults = createDefaultToolSessionDefaults()["harness-engineer"];

package/dist/backend/api/task-routes.js

@@ -235,6 +235,7 @@ function degradedArtifactSummary(handoffDir) {
             architectDebugPath: `${handoffDir}/architect-debug.md`,
             architectureDiagnosisPath: `${handoffDir}/architecture-diagnosis.md`,
             testReportPath: `${handoffDir}/test-report.md`,
+            docsUpdateReportPath: `${handoffDir}/docs-update-report.md`,
             docsSyncReportPath: `${handoffDir}/docs-sync-report.md`,
             workflowProgressPath: `${handoffDir}/workflow-progress.md`,
             finalAcceptancePath: `${handoffDir}/final-acceptance.md`

package/dist/backend/api/workflow-control-routes.js

@@ -5,6 +5,18 @@ export function registerWorkflowControlRoutes(app, deps) {
         const context = await getContext(deps, request.params.taskSlug);
         return deps.workflowControlService.getState(context);
     });
+    app.post("/api/tasks/:taskSlug/ask-user", async (request) => {
+        const context = await getContext(deps, request.params.taskSlug);
+        const question = typeof request.body?.question === "string" ? request.body.question.trim() : "";
+        if (!question) {
+            throw new VcmError({
+                code: "WORKFLOW_USER_QUESTION_REQUIRED",
+                message: "A non-empty user question is required.",
+                statusCode: 400
+            });
+        }
+        return deps.workflowControlService.requestUserInput(context, question);
+    });
 }
 async function getContext(deps, taskSlug) {
     const project = await deps.projectService.getCurrentProject();

package/dist/backend/cli/install-vcm-harness.js

@@ -28,10 +28,12 @@ import { renderVcmLongRunningValidationSkillRules } from "../templates/harness/v
 import { renderVcmProposeMemorySkillRules } from "../templates/harness/vcm-propose-memory-skill.js";
 import { renderVcmReportHarnessIssueSkillRules } from "../templates/harness/vcm-report-harness-issue-skill.js";
 import { renderVcmRouteMessageSkillRules } from "../templates/harness/vcm-route-message-skill.js";
+import { renderAskUserTool, renderVcmAskUserSkillRules } from "../templates/harness/vcm-ask-user-skill.js";
 import { renderUpdateTaskStateTool, renderVcmTaskStateSkillRules } from "../templates/harness/vcm-task-state-skill.js";
 import { renderVcmWorkflowReviewSkillRules } from "../templates/harness/vcm-workflow-review-skill.js";
 import { renderCheckScaffoldLedgerTool } from "../templates/harness/check-scaffold-ledger.js";
 import { renderRequestArchitectRestartTool, renderRestartArchitectSkillRules } from "../templates/harness/restart-architect-skill.js";
+import { renderResolveDurableDocAssignmentTool } from "../templates/harness/resolve-durable-doc-assignment.js";
 import { readVcmPackageVersion } from "../app-version.js";
 const CLI_DIR = path.dirname(fileURLToPath(import.meta.url));
 const APP_ROOT = path.resolve(CLI_DIR, "../../..");
@@ -318,6 +320,12 @@ const WHOLE_FILES = [
         mode: 0o644,
         content: renderSkillFile("VCM Route Message Skill", "vcm-route-message", "Use when project-manager dispatches a VCM role or when a VCM role reports a question, result, blocker, or finding back to project-manager.", renderVcmRouteMessageSkillRules())
     },
+    {
+        path: ".claude/skills/vcm-ask-user/SKILL.md",
+        category: "skill",
+        mode: 0o644,
+        content: renderSkillFile("VCM Ask User Skill", "vcm-ask-user", "Use whenever project-manager asks the user a question and must pause the workflow.", renderVcmAskUserSkillRules())
+    },
     {
         path: ".claude/skills/vcm-task-state/SKILL.md",
         category: "skill",
@@ -360,6 +368,12 @@ const WHOLE_FILES = [
         mode: 0o755,
         content: renderRequestGateReviewTool()
     },
+    {
+        path: ".ai/tools/vcm-ask-user",
+        category: "runtime-tool",
+        mode: 0o755,
+        content: renderAskUserTool()
+    },
     {
         path: ".ai/tools/update-task-state",
         category: "runtime-tool",
@@ -378,6 +392,12 @@ const WHOLE_FILES = [
         mode: 0o755,
         content: renderRequestArchitectRestartTool()
     },
+    {
+        path: ".ai/tools/resolve-durable-doc-assignment",
+        category: "runtime-tool",
+        mode: 0o755,
+        content: renderResolveDurableDocAssignmentTool()
+    },
     {
         path: ".ai/tools/run-long-check",
         category: "runtime-tool",
@@ -642,6 +662,7 @@ function fixedDirectories() {
         ".claude/skills/vcm-harness-bootstrap/",
         ".claude/skills/vcm-long-running-validation/",
         ".claude/skills/vcm-route-message/",
+        ".claude/skills/vcm-ask-user/",
         ".claude/skills/vcm-task-state/",
         ".claude/skills/vcm-workflow-review/",
         ".claude/skills/vcm-gate-review/",

package/dist/backend/server.js

@@ -4,13 +4,13 @@ import Fastify from "fastify";
 import fastifyStatic from "@fastify/static";
 import { createArtifactService } from "./services/artifact-service.js";
 import { createClaudeAdapter } from "./adapters/claude-adapter.js";
-import { createCcrGatewayAdapter } from "./adapters/ccr-gateway-adapter.js";
+import { createCodexBridgeAdapter } from "./adapters/codex-bridge-adapter.js";
 import { createCommandRunner } from "./adapters/command-runner.js";
 import { createCommandDispatcher } from "./services/command-dispatcher.js";
 import { createClaudeHookService } from "./services/claude-hook-service.js";
 import { createGitAdapter } from "./adapters/git-adapter.js";
 import { createAppSettingsService } from "./services/app-settings-service.js";
-import { createCcrIntegrationService } from "./services/ccr-integration-service.js";
+import { createCodexBridgeIntegrationService } from "./services/codex-bridge-integration-service.js";
 import { createAutoMemoryService } from "./services/auto-memory-service.js";
 import { createArchitectRestartService } from "./services/architect-restart-service.js";
 import { createRoleStallDetectorService } from "./services/role-stall-detector-service.js";
@@ -88,7 +88,7 @@ export async function createServer(deps, options = {}) {
     registerDiagnosticsRoutes(app, { diagnosticsService: deps.diagnosticsService });
     registerAppSettingsRoutes(app, {
         appSettings: deps.appSettings,
-        ccrIntegration: deps.ccrIntegration
+        codexBridgeIntegration: deps.codexBridgeIntegration
     });
     registerClaudeHookRoutes(app, { claudeHookService: deps.claudeHookService });
     registerGateReviewRoutes(app, {
@@ -186,7 +186,7 @@ export async function createServer(deps, options = {}) {
         onManualInterrupt: (sessionId) => deps.terminalInterruptService.handleManualInterrupt(sessionId)
     });
     app.addHook("onReady", async () => {
-        await deps.ccrIntegration.initialize();
+        await deps.codexBridgeIntegration.initialize();
         await cleanupRecentTranslationRuntime(deps);
         deps.terminalProcessExitService.start();
         deps.runtimeCoordinator.start();
@@ -235,9 +235,9 @@ export function createDefaultServerDeps(options = {}) {
     const git = createGitAdapter(runner);
     const claude = createClaudeAdapter(runner);
     const appSettings = createAppSettingsService({ fs });
-    const ccrIntegration = createCcrIntegrationService({
+    const codexBridgeIntegration = createCodexBridgeIntegrationService({
         settings: appSettings,
-        gateway: createCcrGatewayAdapter()
+        bridge: createCodexBridgeAdapter()
     });
     const runtime = createNodePtyTerminalRuntime({ fs });
     const registry = createSessionRegistry();
@@ -255,7 +255,7 @@ export function createDefaultServerDeps(options = {}) {
         projectService,
         taskService,
         taskWorkflowService,
-        ccrIntegration,
+        codexBridgeIntegration,
         apiUrl: options.apiUrl
     });
     const harnessService = createHarnessService({
@@ -332,6 +332,7 @@ export function createDefaultServerDeps(options = {}) {
         appSettings,
         sessionService,
         roundService,
+        workflowControlService,
         onArchitecturePlanDisposition: ({ repoRoot, taskSlug, accepted }) => architectRestartService.recordArchitectureGateDisposition(repoRoot, taskSlug, accepted)
     });
     const translationWorkerService = createTranslationWorkerService({
@@ -416,7 +417,8 @@ export function createDefaultServerDeps(options = {}) {
         jobGuard: createJobGuardService(),
         translationWorkerService,
         architectRestartService,
-        roleStallDetector
+        roleStallDetector,
+        workflowControlService
     });
     const runtimeCoordinator = createRuntimeCoordinatorService({
         appSettings,
@@ -456,7 +458,7 @@ export function createDefaultServerDeps(options = {}) {
     });
     return {
         appSettings,
-        ccrIntegration,
+        codexBridgeIntegration,
         projectService,
         taskService,
         taskCloseService,