vibe-coding-master 0.7.14 → 0.7.16

package/README.md

@@ -235,14 +235,16 @@ a host-running [Claude Code Router](https://github.com/musistudio/claude-code-ro
 CCR must already be installed, authenticated, configured, and running on the
 host. VCM does not manage the CCR process.
 
-VCM uses this fixed Dev Container endpoint:
+VCM automatically checks the local-host and DevContainer endpoints:
 
 ```text
+http://127.0.0.1:3456
 http://host.docker.internal:3456
 ```
 
-Configure CCR to listen on port `3456` with an API key and make it reachable
-from the container. In the VCM `Settings` section:
+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:
 
 1. enter and save the CCR API key;
 2. enable `CCR GPT models`;
@@ -250,13 +252,21 @@ from the container. In the VCM `Settings` section:
 4. select `GPT-5.6 Sol (CCR)` in any Session model control.
 
 The key is stored in global VCM state (`~/.vcm/settings.json`) with owner-only
-permissions, is used only to check CCR and discover models, and is never
-returned by the settings API. GPT sessions use the CCR-managed Claude Code
-`apiKeyHelper`; VCM removes inherited Anthropic token variables only from those
-child processes. Native Claude selections retain their existing launch and
-authentication behavior. 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.
+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
+child-only `--settings` override and use the isolated Claude configuration root
+`~/.vcm/claude/ccr`. 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.
+
+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.
 
 ## Launch Template
 
@@ -320,7 +330,9 @@ Conversation translation is controlled from the sidebar `Translation` section.
 
 VCM uses a task-scoped Translator role and Claude transcript JSONL files, not
 raw terminal text. Translation memory and completed file translations remain
-project-level durable data.
+project-level durable data. When translation is enabled and the active task's
+Harness is initialized, the backend automatically starts a fresh Translator for
+the task or resumes its saved Session.
 
 Common controls:
 
@@ -424,9 +436,10 @@ Use it to:
 - merge task harness commits back to the connected repository branch when
   appropriate
 
-Harness Engineer is task-scoped and runs from the active task worktree. A new
-task receives its own Harness Engineer session. Durable memory is versioned with
-the project harness files.
+Harness Engineer is task-scoped and runs from the active task worktree. The
+backend automatically starts a fresh Harness Engineer for each active task or
+resumes its saved Session. Durable memory is versioned with the project harness
+files.
 
 ### Auto Memory
 

package/dist/backend/adapters/ccr-gateway-adapter.js

@@ -1,62 +1,84 @@
-import { CCR_GATEWAY_BASE_URL, CCR_GPT_MODEL_ID } from "../../shared/types/session.js";
+import { CCR_GATEWAY_BASE_URLS, CCR_GPT_MODEL_ID } from "../../shared/types/session.js";
 const DEFAULT_TIMEOUT_MS = 3_000;
 const CCR_ENCODED_MODEL_PREFIX = "anthropic/claude-ccr-h";
 export function createCcrGatewayAdapter(deps = {}) {
-    const baseUrl = (deps.baseUrl ?? CCR_GATEWAY_BASE_URL).replace(/\/+$/, "");
+    const baseUrls = (deps.baseUrl ? [deps.baseUrl] : CCR_GATEWAY_BASE_URLS)
+        .map((baseUrl) => baseUrl.replace(/\/+$/, ""));
     const fetchImpl = deps.fetch ?? globalThis.fetch;
     const timeoutMs = deps.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     return {
         async probe(apiKey) {
-            try {
-                const root = await requestJson(fetchImpl, `${baseUrl}/`, timeoutMs);
-                if (!root.response.ok) {
-                    return invalidResponse(`CCR gateway root returned HTTP ${root.response.status}.`);
+            const failures = [];
+            for (const baseUrl of baseUrls) {
+                const result = await probeEndpoint(fetchImpl, baseUrl, apiKey, timeoutMs);
+                if (result.baseUrl) {
+                    return result;
                 }
-                if (!isCcrGateway(root.payload)) {
-                    return {
-                        connectionState: "not-ccr",
-                        modelAvailable: false,
-                        error: `The fixed CCR endpoint ${baseUrl} did not identify a Claude Code Router gateway.`
-                    };
-                }
-                const models = await requestJson(fetchImpl, `${baseUrl}/v1/models`, timeoutMs, {
-                    authorization: `Bearer ${apiKey}`,
-                    "user-agent": "Claude Code"
-                });
-                if (models.response.status === 401 || models.response.status === 403) {
-                    return {
-                        connectionState: "unauthorized",
-                        modelAvailable: false,
-                        error: "CCR rejected the configured API key."
-                    };
-                }
-                if (!models.response.ok) {
-                    return invalidResponse(`CCR model discovery returned HTTP ${models.response.status}.`);
-                }
-                const modelDescriptors = readModelDescriptors(models.payload);
-                if (!modelDescriptors) {
-                    return invalidResponse("CCR returned an invalid /v1/models response.");
-                }
-                const modelAvailable = modelDescriptors.some(isRequiredModel);
-                return {
-                    connectionState: "available",
-                    modelAvailable,
-                    ...(modelAvailable
-                        ? {}
-                        : { error: `CCR does not expose the required model ${CCR_GPT_MODEL_ID}.` })
-                };
-            }
-            catch (error) {
-                const timedOut = isAbortError(error);
-                return {
-                    connectionState: "unreachable",
-                    modelAvailable: false,
-                    error: timedOut
-                        ? `CCR connection timed out after ${timeoutMs} ms at ${baseUrl}.`
-                        : `CCR could not be reached from the VCM container backend at ${baseUrl}. Reason: ${errorMessage(error)}`
-                };
+                failures.push(result);
             }
+            return combineProbeFailures(baseUrls, failures);
+        }
+    };
+}
+async function probeEndpoint(fetchImpl, baseUrl, apiKey, timeoutMs) {
+    try {
+        const root = await requestJson(fetchImpl, `${baseUrl}/`, timeoutMs);
+        if (!root.response.ok) {
+            return invalidResponse(`Gateway root at ${baseUrl} returned HTTP ${root.response.status}.`);
+        }
+        if (!isCcrGateway(root.payload)) {
+            return {
+                connectionState: "not-ccr",
+                modelAvailable: false,
+                error: `${baseUrl} did not identify a Claude Code Router gateway.`
+            };
         }
+        const models = await requestJson(fetchImpl, `${baseUrl}/v1/models`, timeoutMs, {
+            authorization: `Bearer ${apiKey}`,
+            "user-agent": "Claude Code"
+        });
+        if (models.response.status === 401 || models.response.status === 403) {
+            return {
+                connectionState: "unauthorized",
+                modelAvailable: false,
+                baseUrl,
+                error: "CCR rejected the configured API key."
+            };
+        }
+        if (!models.response.ok) {
+            return invalidResponse(`CCR model discovery at ${baseUrl} returned HTTP ${models.response.status}.`, baseUrl);
+        }
+        const modelDescriptors = readModelDescriptors(models.payload);
+        if (!modelDescriptors) {
+            return invalidResponse("CCR returned an invalid /v1/models response.", baseUrl);
+        }
+        const modelAvailable = modelDescriptors.some(isRequiredModel);
+        return {
+            connectionState: "available",
+            modelAvailable,
+            baseUrl,
+            ...(modelAvailable
+                ? {}
+                : { error: `CCR does not expose the required model ${CCR_GPT_MODEL_ID}.` })
+        };
+    }
+    catch (error) {
+        const timedOut = isAbortError(error);
+        return {
+            connectionState: "unreachable",
+            modelAvailable: false,
+            error: timedOut
+                ? `CCR connection timed out after ${timeoutMs} ms at ${baseUrl}.`
+                : `CCR 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,
+        error: `CCR was not found at ${baseUrls.join(" or ")}. ${failures.map((failure) => failure.error).filter(Boolean).join(" ")}`.trim()
     };
 }
 async function requestJson(fetchImpl, url, timeoutMs, headers = {}) {
@@ -131,10 +153,11 @@ function decodeCcrModelId(modelId) {
 function normalizeModelName(value) {
     return (value ?? "").toLowerCase().replace(/[^a-z0-9]+/g, "");
 }
-function invalidResponse(error) {
+function invalidResponse(error, baseUrl) {
     return {
         connectionState: "invalid-response",
         modelAvailable: false,
+        ...(baseUrl ? { baseUrl } : {}),
         error
     };
 }

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

@@ -18,8 +18,9 @@ export function createClaudeAdapter(runner) {
             }
             return result.stdout.trim();
         },
-        buildRoleStartCommand(role, command = "claude", permissionMode = "default", claudeSessionId, resume = false, model = "default", effort = "default") {
+        buildRoleStartCommand(role, command = "claude", permissionMode = "default", claudeSessionId, resume = false, model = "default", effort = "default", settingsOverride) {
             const args = ["--agent", role];
+            const sessionSettings = { ...settingsOverride };
             if (claudeSessionId) {
                 args.push(resume ? "--resume" : "--session-id", claudeSessionId);
             }
@@ -27,11 +28,14 @@ export function createClaudeAdapter(runner) {
                 args.push("--model", model);
             }
             if (effort === "ultracode") {
-                args.push("--settings", JSON.stringify({ ultracode: true }));
+                sessionSettings.ultracode = true;
             }
             else if (effort !== "default") {
                 args.push("--effort", effort);
             }
+            if (Object.keys(sessionSettings).length > 0) {
+                args.push("--settings", JSON.stringify(sessionSettings));
+            }
             if (permissionMode !== "default") {
                 args.push("--permission-mode", permissionMode);
             }

package/dist/backend/runtime/session-registry.js

@@ -2,6 +2,13 @@ export function createSessionRegistry() {
     const sessions = new Map();
     return {
         upsert(session) {
+            for (const [sessionId, candidate] of sessions) {
+                if (sessionId !== session.id
+                    && candidate.taskSlug === session.taskSlug
+                    && candidate.role === session.role) {
+                    sessions.delete(sessionId);
+                }
+            }
             sessions.set(session.id, session);
         },
         get(sessionId) {

package/dist/backend/services/ccr-integration-service.js

@@ -1,9 +1,15 @@
 import { CCR_GATEWAY_BASE_URL, CCR_GPT_MODEL_ID, createSessionModelOptions, isCcrSessionModel } from "../../shared/types/session.js";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 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 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");
     let cachedProbe;
     let inFlight;
     async function probe(force = false) {
@@ -122,7 +128,7 @@ export function createCcrIntegrationService(deps) {
         },
         async getLaunchEnvironment(model) {
             if (!isCcrSessionModel(model)) {
-                return {};
+                return buildNativeLaunchEnvironment(baseEnv);
             }
             const settings = await deps.settings.getCcrIntegrationSettings();
             if (!settings.enabled) {
@@ -142,11 +148,13 @@ export function createCcrIntegrationService(deps) {
                     hint: "Check that host CCR is running on port 3456 and exposes GPT-5.6 Sol."
                 });
             }
-            const noProxy = mergeNoProxy(deps.baseEnv?.NO_PROXY ?? deps.baseEnv?.no_proxy ?? process.env.NO_PROXY ?? process.env.no_proxy, "host.docker.internal");
+            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);
             return {
-                ANTHROPIC_BASE_URL: CCR_GATEWAY_BASE_URL,
-                ANTHROPIC_API_BASE_URL: CCR_GATEWAY_BASE_URL,
-                CLAUDE_AGENT_API_BASE_URL: CCR_GATEWAY_BASE_URL,
+                ANTHROPIC_BASE_URL: gatewayBaseUrl,
+                ANTHROPIC_API_BASE_URL: gatewayBaseUrl,
+                CLAUDE_AGENT_API_BASE_URL: gatewayBaseUrl,
                 ANTHROPIC_AUTH_TOKEN: undefined,
                 ANTHROPIC_API_KEY: undefined,
                 ANTHROPIC_MODEL: CCR_GPT_MODEL_ID,
@@ -154,12 +162,85 @@ export function createCcrIntegrationService(deps) {
                 CODEXL_CLAUDE_CODE_MODEL: CCR_GPT_MODEL_ID,
                 ANTHROPIC_SMALL_FAST_MODEL: CCR_GPT_MODEL_ID,
                 CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: "1",
+                CLAUDE_CONFIG_DIR: configDir,
                 NO_PROXY: noProxy,
                 no_proxy: noProxy
             };
+        },
+        async getLaunchSettingsOverride(model) {
+            if (!isCcrSessionModel(model)) {
+                return undefined;
+            }
+            return {
+                apiKeyHelper: buildApiKeyHelperCommand(deps.apiKeyHelperPath ?? DEFAULT_API_KEY_HELPER_PATH)
+            };
         }
     };
 }
+const CCR_BASE_URL_KEYS = [
+    "ANTHROPIC_BASE_URL",
+    "ANTHROPIC_API_BASE_URL",
+    "CLAUDE_AGENT_API_BASE_URL"
+];
+const CCR_MODEL_KEYS = [
+    "ANTHROPIC_MODEL",
+    "ANTHROPIC_SMALL_FAST_MODEL"
+];
+const CCR_ONLY_ENV_KEYS = [
+    "CCR_CLAUDE_CODE_MODEL",
+    "CODEXL_CLAUDE_CODE_MODEL",
+    "CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY"
+];
+export function buildNativeLaunchEnvironment(baseEnv) {
+    const environment = {};
+    let inheritedCcrTakeover = 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])) {
+            environment[key] = undefined;
+            inheritedCcrTakeover = true;
+        }
+    }
+    for (const key of CCR_MODEL_KEYS) {
+        if (isCcrModelName(baseEnv[key])) {
+            environment[key] = undefined;
+            inheritedCcrTakeover = true;
+        }
+    }
+    for (const key of CCR_ONLY_ENV_KEYS) {
+        if (baseEnv[key] !== undefined) {
+            environment[key] = undefined;
+            inheritedCcrTakeover = true;
+        }
+    }
+    if (inheritedCcrTakeover) {
+        environment.ANTHROPIC_AUTH_TOKEN = undefined;
+        environment.ANTHROPIC_API_KEY = undefined;
+    }
+    return environment;
+}
+function isCcrGatewayUrl(value) {
+    if (!value) {
+        return false;
+    }
+    try {
+        const url = new URL(value);
+        return url.port === "3456"
+            && ["127.0.0.1", "localhost", "host.docker.internal"].includes(url.hostname);
+    }
+    catch {
+        return false;
+    }
+}
+function isCcrModelName(value) {
+    if (!value) {
+        return false;
+    }
+    return value === CCR_GPT_MODEL_ID
+        || value.startsWith("anthropic/claude-ccr-h");
+}
 function createStatus(input) {
     const reason = input.error
         ?? (input.enabled ? "CCR GPT-5.6 Sol is unavailable." : "Enable CCR GPT models in Settings.");
@@ -193,3 +274,12 @@ export function mergeNoProxy(current, host) {
     }
     return values.join(",");
 }
+export function buildApiKeyHelperCommand(helperPath) {
+    if (process.platform === "win32") {
+        return `${JSON.stringify(process.execPath)} ${JSON.stringify(helperPath)}`;
+    }
+    return `${quotePosixShell(process.execPath)} ${quotePosixShell(helperPath)}`;
+}
+function quotePosixShell(value) {
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}

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

@@ -208,14 +208,14 @@ export function resolveExistingClaudeTranscriptPath(session) {
     if (sessionPath) {
         return sessionPath;
     }
-    const cwdPath = existingFile(claudeTranscriptPath(session.cwd, session.claudeSessionId));
+    const cwdPath = existingFile(claudeTranscriptPath(session.cwd, session.claudeSessionId, session.claudeConfigDir));
     if (cwdPath) {
         return cwdPath;
     }
-    return findClaudeTranscriptPathBySessionId(session.claudeSessionId);
+    return findClaudeTranscriptPathBySessionId(session.claudeSessionId, session.claudeConfigDir);
 }
-export function findClaudeTranscriptPathBySessionId(claudeSessionId) {
-    const root = claudeProjectsRoot();
+export function findClaudeTranscriptPathBySessionId(claudeSessionId, configDir) {
+    const root = claudeProjectsRoot(configDir);
     let projectDirs;
     try {
         projectDirs = readdirSync(root, { withFileTypes: true });
@@ -253,17 +253,17 @@ function existingFile(candidate) {
         return undefined;
     }
 }
-export function claudeProjectsRoot() {
-    return join(homedir(), ".claude", "projects");
+export function claudeProjectsRoot(configDir) {
+    return join(configDir ?? join(homedir(), ".claude"), "projects");
 }
 export function projectHash(projectDir) {
     return projectDir.replace(/[\/\s]+/g, "-");
 }
-export function projectsTranscriptDir(projectDir) {
-    return join(claudeProjectsRoot(), projectHash(projectDir));
+export function projectsTranscriptDir(projectDir, configDir) {
+    return join(claudeProjectsRoot(configDir), projectHash(projectDir));
 }
-export function claudeTranscriptPath(projectDir, claudeSessionId) {
-    return join(projectsTranscriptDir(projectDir), `${claudeSessionId}.jsonl`);
+export function claudeTranscriptPath(projectDir, claudeSessionId, configDir) {
+    return join(projectsTranscriptDir(projectDir, configDir), `${claudeSessionId}.jsonl`);
 }
 export function parseAssistantContent(line) {
     let obj;

package/dist/backend/services/runtime-coordinator-service.js

@@ -34,6 +34,40 @@ export function createRuntimeCoordinatorService(deps) {
             }
         }
     }
+    function reconcileProject(repoRoot, input = {}) {
+        return withRepoLock(repoRoot, async () => {
+            const [activeTask, gatewayStatus] = await Promise.all([
+                resolveActiveTask(repoRoot, input.taskSlug),
+                deps.gatewayService.getStatus().catch(() => null)
+            ]);
+            const preferences = await deps.appSettings.getPreferences();
+            if (!activeTask) {
+                return { activeTask: null, gatewayStatus };
+            }
+            const taskRepoRoot = getTaskRuntimeRepoRoot(activeTask);
+            const stateRoot = await deps.getStateRoot(repoRoot);
+            await deps.turnReconciler.reconcileTask(repoRoot, activeTask, stateRoot);
+            const harnessInitialized = await deps.harnessService.getHarnessStatus(taskRepoRoot)
+                .then((status) => status.initialized)
+                .catch(() => false);
+            await Promise.all([
+                reconcileHarnessEngineer(repoRoot, activeTask),
+                reconcileTranslator(repoRoot, activeTask, preferences.translationEnabled && harnessInitialized)
+            ]);
+            if (preferences.translationEnabled && harnessInitialized) {
+                await startConversationTranslationListeners(repoRoot, activeTask);
+            }
+            else {
+                await deps.translationService.stopTask(taskRepoRoot, activeTask.taskSlug).catch(() => undefined);
+            }
+            await reconcileAutoMemory(repoRoot, activeTask, preferences.autoTaskHarnessReviewEnabled ? "auto" : undefined);
+            const memoryReadiness = await getTaskRetrospectiveMemoryReadiness(repoRoot, activeTask);
+            if ((preferences.autoTaskHarnessReviewEnabled || memoryReadiness.trigger) && memoryReadiness.ready) {
+                await maybeStartTaskHarnessRetrospective(repoRoot, activeTask, memoryReadiness.trigger ?? "auto");
+            }
+            return { activeTask, gatewayStatus };
+        });
+    }
     return {
         start() {
             if (reconcileTimer !== undefined) {
@@ -51,53 +85,14 @@ export function createRuntimeCoordinatorService(deps) {
             clearTimer(reconcileTimer);
             reconcileTimer = undefined;
         },
-        reconcileProject(repoRoot, input = {}) {
-            return withRepoLock(repoRoot, async () => {
-                const [activeTask, gatewayStatus] = await Promise.all([
-                    resolveActiveTask(repoRoot, input.taskSlug),
-                    deps.gatewayService.getStatus().catch(() => null)
-                ]);
-                const preferences = await deps.appSettings.getPreferences();
-                if (!activeTask) {
-                    return { activeTask: null, gatewayStatus };
-                }
-                const taskRepoRoot = getTaskRuntimeRepoRoot(activeTask);
-                const stateRoot = await deps.getStateRoot(repoRoot);
-                await deps.turnReconciler.reconcileTask(repoRoot, activeTask, stateRoot);
-                const harnessInitialized = await deps.harnessService.getHarnessStatus(taskRepoRoot)
-                    .then((status) => status.initialized)
-                    .catch(() => false);
-                await Promise.all([
-                    reconcileHarnessEngineer(repoRoot, activeTask),
-                    reconcileTranslator(repoRoot, activeTask, preferences.translationEnabled && harnessInitialized)
-                ]);
-                if (preferences.translationEnabled && harnessInitialized) {
-                    await startConversationTranslationListeners(repoRoot, activeTask);
-                }
-                else {
-                    await deps.translationService.stopTask(taskRepoRoot, activeTask.taskSlug).catch(() => undefined);
-                }
-                await reconcileAutoMemory(repoRoot, activeTask, preferences.autoTaskHarnessReviewEnabled ? "auto" : undefined);
-                const memoryReadiness = await getTaskRetrospectiveMemoryReadiness(repoRoot, activeTask);
-                if ((preferences.autoTaskHarnessReviewEnabled || memoryReadiness.trigger) && memoryReadiness.ready) {
-                    await maybeStartTaskHarnessRetrospective(repoRoot, activeTask, memoryReadiness.trigger ?? "auto");
-                }
-                return { activeTask, gatewayStatus };
-            });
-        }
+        reconcileProject
     };
     async function reconcileCurrentProject() {
         const project = await deps.projectService.getCurrentProject();
         if (!project) {
             return;
         }
-        await withRepoLock(project.repoRoot, async () => {
-            const activeTask = await resolveActiveTask(project.repoRoot);
-            if (activeTask) {
-                await deps.turnReconciler.reconcileTask(project.repoRoot, activeTask, await deps.getStateRoot(project.repoRoot));
-            }
-            return { activeTask, gatewayStatus: null };
-        });
+        await reconcileProject(project.repoRoot);
     }
     async function resolveActiveTask(repoRoot, requestedTaskSlug) {
         const tasks = await deps.taskService.listTasks(repoRoot);
@@ -136,7 +131,7 @@ export function createRuntimeCoordinatorService(deps) {
         });
     }
     function shouldAutoEnsureTaskToolSession(session) {
-        return Boolean(session && (session.status === "running" || session.claudeSessionId));
+        return !session || session.status === "running" || Boolean(session.claudeSessionId);
     }
     async function ensureTaskToolRoleSession(repoRoot, taskSlug, role, input) {
         const existing = await deps.sessionService.getRoleSession(repoRoot, taskSlug, role);

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

@@ -55,7 +55,13 @@ export function createSessionService(deps) {
         const permissionMode = normalizeClaudePermissionMode(input.permissionMode ?? persisted?.permissionMode);
         const model = normalizeClaudeModel(input.model ?? persisted?.model);
         const effort = normalizeClaudeEffort(input.effort ?? persisted?.effort);
-        const modelEnvironment = await getModelLaunchEnvironment(model);
+        if (launchMode === "resume" && persisted) {
+            assertResumeProviderCompatible(persisted, model);
+        }
+        const [modelEnvironment, modelSettingsOverride] = await Promise.all([
+            getModelLaunchEnvironment(model),
+            getModelLaunchSettingsOverride(model)
+        ]);
         const resumeClaudeSessionId = launchMode === "resume"
             ? persisted?.claudeSessionId
             : undefined;
@@ -71,10 +77,10 @@ export function createSessionService(deps) {
         const transcriptPath = launchMode === "resume" && persisted?.transcriptPath
             ? persisted.transcriptPath
             : resumeClaudeSessionId
-                ? claudeTranscriptPath(taskRepoRoot, resumeClaudeSessionId)
+                ? claudeTranscriptPath(taskRepoRoot, resumeClaudeSessionId, persisted?.claudeConfigDir)
                 : undefined;
         const startCommand = {
-            ...deps.claude.buildRoleStartCommand(role, config.claudeCommand, permissionMode, resumeClaudeSessionId, launchMode === "resume", model, effort),
+            ...deps.claude.buildRoleStartCommand(role, config.claudeCommand, permissionMode, resumeClaudeSessionId, launchMode === "resume", model, effort, modelSettingsOverride),
             cwd: taskRepoRoot
         };
         const runtimeSession = await deps.runtime.createSession({
@@ -110,6 +116,7 @@ export function createSessionService(deps) {
             model,
             effort,
             cwd: startCommand.cwd,
+            claudeConfigDir: readClaudeConfigDir(modelEnvironment),
             terminalBackend: "node-pty",
             pid: runtimeSession.pid,
             roleCommandPath: isDispatchableRole(role)
@@ -160,7 +167,13 @@ export function createSessionService(deps) {
         const permissionMode = normalizeClaudePermissionMode(input.permissionMode ?? persisted?.permissionMode);
         const model = normalizeClaudeModel(input.model ?? persisted?.model);
         const effort = normalizeClaudeEffort(input.effort ?? persisted?.effort ?? "medium");
-        const modelEnvironment = await getModelLaunchEnvironment(model);
+        if (launchMode === "resume" && persisted) {
+            assertResumeProviderCompatible(persisted, model);
+        }
+        const [modelEnvironment, modelSettingsOverride] = await Promise.all([
+            getModelLaunchEnvironment(model),
+            getModelLaunchSettingsOverride(model)
+        ]);
         const resumeClaudeSessionId = launchMode === "resume"
             ? persisted?.claudeSessionId
             : undefined;
@@ -188,10 +201,10 @@ export function createSessionService(deps) {
         const sessionCwd = launchMode === "resume" ? persisted?.cwd ?? launchCwd : launchCwd;
         const claudeSessionId = resumeClaudeSessionId ?? "";
         const transcriptPath = resumeClaudeSessionId
-            ? claudeTranscriptPath(repoRoot, resumeClaudeSessionId)
+            ? claudeTranscriptPath(repoRoot, resumeClaudeSessionId, persisted?.claudeConfigDir)
             : undefined;
         const startCommand = {
-            ...deps.claude.buildRoleStartCommand(TRANSLATOR_ROLE, config.claudeCommand, permissionMode, resumeClaudeSessionId, launchMode === "resume", model, effort),
+            ...deps.claude.buildRoleStartCommand(TRANSLATOR_ROLE, config.claudeCommand, permissionMode, resumeClaudeSessionId, launchMode === "resume", model, effort, modelSettingsOverride),
             cwd: launchCwd
         };
         const runtimeSession = await deps.runtime.createSession({
@@ -230,6 +243,7 @@ export function createSessionService(deps) {
             model,
             effort,
             cwd: sessionCwd,
+            claudeConfigDir: readClaudeConfigDir(modelEnvironment),
             terminalBackend: "node-pty",
             pid: runtimeSession.pid,
             startedAt: runtimeSession.startedAt,
@@ -270,7 +284,13 @@ export function createSessionService(deps) {
         const permissionMode = normalizeClaudePermissionMode(input.permissionMode ?? persisted?.permissionMode);
         const model = normalizeClaudeModel(input.model ?? persisted?.model);
         const effort = normalizeClaudeEffort(input.effort ?? persisted?.effort ?? "medium");
-        const modelEnvironment = await getModelLaunchEnvironment(model);
+        if (launchMode === "resume" && persisted) {
+            assertResumeProviderCompatible(persisted, model);
+        }
+        const [modelEnvironment, modelSettingsOverride] = await Promise.all([
+            getModelLaunchEnvironment(model),
+            getModelLaunchSettingsOverride(model)
+        ]);
         const resumeClaudeSessionId = launchMode === "resume"
             ? persisted?.claudeSessionId
             : undefined;
@@ -294,10 +314,10 @@ export function createSessionService(deps) {
         const sessionCwd = launchMode === "resume" ? persisted?.cwd ?? launchCwd : launchCwd;
         const claudeSessionId = resumeClaudeSessionId ?? "";
         const transcriptPath = resumeClaudeSessionId
-            ? claudeTranscriptPath(repoRoot, resumeClaudeSessionId)
+            ? claudeTranscriptPath(repoRoot, resumeClaudeSessionId, persisted?.claudeConfigDir)
             : undefined;
         const startCommand = {
-            ...deps.claude.buildRoleStartCommand(HARNESS_ENGINEER_ROLE, config.claudeCommand, permissionMode, resumeClaudeSessionId, launchMode === "resume", model, effort),
+            ...deps.claude.buildRoleStartCommand(HARNESS_ENGINEER_ROLE, config.claudeCommand, permissionMode, resumeClaudeSessionId, launchMode === "resume", model, effort, modelSettingsOverride),
             cwd: launchCwd
         };
         const runtimeSession = await deps.runtime.createSession({
@@ -336,6 +356,7 @@ export function createSessionService(deps) {
             model,
             effort,
             cwd: sessionCwd,
+            claudeConfigDir: readClaudeConfigDir(modelEnvironment),
             terminalBackend: "node-pty",
             pid: runtimeSession.pid,
             startedAt: runtimeSession.startedAt,
@@ -480,14 +501,18 @@ export function createSessionService(deps) {
         const permissionMode = normalizeClaudePermissionMode(session.permissionMode);
         const model = normalizeClaudeModel(session.model);
         const effort = normalizeClaudeEffort(session.effort);
-        const modelEnvironment = await getModelLaunchEnvironment(model);
+        assertResumeProviderCompatible(session, model);
+        const [modelEnvironment, modelSettingsOverride] = await Promise.all([
+            getModelLaunchEnvironment(model),
+            getModelLaunchSettingsOverride(model)
+        ]);
         // Spawn (`claude --resume`) always anchors at the base repoRoot so resume works
         // even if the persisted task cwd was deleted. `--resume` then restores the
         // session's own last cwd (tracked on `session.cwd`), so the `/cd` migrate below
         // fires only when that restored cwd differs from the target worktree.
         const launchCwd = repoRoot;
         const startCommand = {
-            ...deps.claude.buildRoleStartCommand(session.role, config.claudeCommand, permissionMode, session.claudeSessionId, true, model, effort),
+            ...deps.claude.buildRoleStartCommand(session.role, config.claudeCommand, permissionMode, session.claudeSessionId, true, model, effort, modelSettingsOverride),
             cwd: launchCwd
         };
         const runtimeSession = await deps.runtime.createSession({
@@ -534,13 +559,14 @@ export function createSessionService(deps) {
             permissionMode,
             model,
             effort,
+            claudeConfigDir: readClaudeConfigDir(modelEnvironment),
             pid: runtimeSession.pid,
             startedAt: runtimeSession.startedAt,
             updatedAt: timestamp,
             lastOutputAt: runtimeSession.lastOutputAt,
             exitCode: runtimeSession.exitCode,
             transcriptPath: session.claudeSessionId
-                ? claudeTranscriptPath(repoRoot, session.claudeSessionId)
+                ? claudeTranscriptPath(repoRoot, session.claudeSessionId, session.claudeConfigDir)
                 : session.transcriptPath
         };
         deps.registry.upsert(normalizeProjectScopedRecordForPersistence(resumed));
@@ -548,19 +574,22 @@ export function createSessionService(deps) {
         return migrateRunningProjectToolSessionCwd(repoRoot, resumed, targetCwd);
     }
     async function getModelLaunchEnvironment(model) {
-        if (!isCcrSessionModel(model)) {
-            return {};
-        }
         if (!deps.ccrIntegration) {
-            throw new VcmError({
-                code: "CCR_UNAVAILABLE",
-                message: "CCR integration is not available in this VCM runtime.",
-                statusCode: 409,
-                hint: "Enable and configure CCR GPT models before starting this session."
-            });
+            if (isCcrSessionModel(model)) {
+                throw new VcmError({
+                    code: "CCR_UNAVAILABLE",
+                    message: "CCR integration is not available in this VCM runtime.",
+                    statusCode: 409,
+                    hint: "Enable and configure CCR GPT models before starting this session."
+                });
+            }
+            return {};
         }
         return deps.ccrIntegration.getLaunchEnvironment(model);
     }
+    async function getModelLaunchSettingsOverride(model) {
+        return deps.ccrIntegration?.getLaunchSettingsOverride(model);
+    }
     function isRuntimeSessionAlive(session) {
         if (!session || isExitedStatus(session.status) || session.pid === undefined) {
             return false;
@@ -1475,6 +1504,28 @@ function normalizeClaudeEffort(value) {
     }
     return "default";
 }
+function assertResumeProviderCompatible(session, requestedModel) {
+    const persistedModel = normalizeClaudeModel(session.model);
+    if (isCcrSessionModel(persistedModel) !== isCcrSessionModel(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."
+        });
+    }
+    if (isCcrSessionModel(requestedModel) && !session.claudeConfigDir) {
+        throw new VcmError({
+            code: "CCR_SESSION_CONFIG_MISSING",
+            message: `${session.role} was created before isolated CCR session storage was enabled.`,
+            statusCode: 409,
+            hint: "Restart this role once to create an isolated CCR session."
+        });
+    }
+}
+function readClaudeConfigDir(environment) {
+    return environment.CLAUDE_CONFIG_DIR?.trim() || undefined;
+}
 function formatClaudeCdCommand(targetCwd) {
     // Claude Code's `/cd` slash command takes the literal remainder of the line as
     // the path, so the target must NOT be wrapped in quotes (quotes are taken as part

package/dist/shared/types/session.js

@@ -45,7 +45,13 @@ export const CLAUDE_MODEL_OPTIONS = [
         available: true
     }
 ];
-export const CCR_GATEWAY_BASE_URL = "http://host.docker.internal:3456";
+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 CCR_GPT_MODEL_ID = "Codex API/gpt-5.6-sol";
 export const CCR_GPT_SESSION_MODEL = `ccr:${CCR_GPT_MODEL_ID}`;
 export function isCcrSessionModel(model) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibe-coding-master",
-  "version": "0.7.14",
+  "version": "0.7.16",
   "description": "Local GUI session cockpit for Claude Code role sessions.",
   "type": "module",
   "files": [

package/scripts/ccr-api-key-helper.mjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+
+const dataDir = process.env.VCM_DATA_DIR?.trim()
+  ? path.resolve(process.env.VCM_DATA_DIR)
+  : path.join(homedir(), ".vcm");
+
+try {
+  const settings = JSON.parse(await readFile(path.join(dataDir, "settings.json"), "utf8"));
+  const apiKey = settings?.ccr?.apiKey;
+  if (typeof apiKey !== "string" || !apiKey.trim()) {
+    process.exitCode = 1;
+  } else {
+    process.stdout.write(`${apiKey.trim()}\n`);
+  }
+} catch {
+  process.exitCode = 1;
+}