vibe-coding-master 0.7.15 → 0.7.17

package/README.md

@@ -228,6 +228,18 @@ such as a Dev Container or VM.
 Model and effort can be selected before start/resume/restart. Changes affect the
 next launched process, not a currently running Claude Code process.
 
+## Usage Analytics
+
+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.
+
+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
 
 VCM can launch its normal Claude Code sessions with `GPT-5.6 Sol (CCR)` through
@@ -254,11 +266,17 @@ DevContainer, make the second endpoint reachable from the container. In the VCM
 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
-child-only `--settings` override; VCM removes inherited Anthropic token
-variables only from those child processes. VCM removes CCR-owned takeover
-entries from global Claude settings, so native Claude selections keep their
-normal launch and account authentication. If CCR is disabled, unreachable,
-rejects the key, or does not expose
+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.
 
@@ -324,7 +342,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:
 
@@ -428,9 +448,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/claude-adapter.js

@@ -18,7 +18,7 @@ export function createClaudeAdapter(runner) {
             }
             return result.stdout.trim();
         },
-        buildRoleStartCommand(role, command = "claude", permissionMode = "default", claudeSessionId, resume = false, model = "default", effort = "default", settingsOverride) {
+        buildRoleStartCommand(role, command = "claude", permissionMode = "default", claudeSessionId, resume = false, model = "default", effort = "default", settingsOverride, appendSystemPrompt) {
             const args = ["--agent", role];
             const sessionSettings = { ...settingsOverride };
             if (claudeSessionId) {
@@ -39,6 +39,9 @@ export function createClaudeAdapter(runner) {
             if (permissionMode !== "default") {
                 args.push("--permission-mode", permissionMode);
             }
+            if (appendSystemPrompt) {
+                args.push("--append-system-prompt", appendSystemPrompt);
+            }
             return {
                 command,
                 args,

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

@@ -10,6 +10,11 @@ export function registerSessionRoutes(app, deps) {
         const role = parseRole(request.params.role);
         return deps.sessionService.startRoleSession(project.repoRoot, request.params.taskSlug, role, request.body);
     });
+    app.post("/api/tasks/:taskSlug/sessions/architect/restart-after-planning", async (request, reply) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const result = await deps.architectRestartService.schedule(project.repoRoot, request.params.taskSlug);
+        return reply.code(202).send(result);
+    });
     app.post("/api/tasks/:taskSlug/sessions/:role/stop", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const role = parseRole(request.params.role);

package/dist/backend/api/usage-analytics-routes.js

@@ -0,0 +1,31 @@
+import { VcmError } from "../errors.js";
+import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
+export function registerUsageAnalyticsRoutes(app, deps) {
+    app.post("/api/telemetry/v1/logs", async (request) => {
+        const project = await deps.projectService.getCurrentProject();
+        if (!project) {
+            return {};
+        }
+        const tasks = await deps.taskService.listTasks(project.repoRoot);
+        const activeTask = tasks.find((task) => task.cleanupStatus !== "cleaned");
+        if (!activeTask) {
+            return {};
+        }
+        const config = await deps.projectService.loadConfig(project.repoRoot);
+        await deps.usageAnalyticsService.ingest(getTaskRuntimeRepoRoot(activeTask), config.stateRoot, request.body);
+        return {};
+    });
+    app.get("/api/tasks/:taskSlug/usage-analytics", async (request) => {
+        const project = await deps.projectService.getCurrentProject();
+        if (!project) {
+            throw new VcmError({
+                code: "PROJECT_NOT_CONNECTED",
+                message: "Connect a repository before loading task usage analytics.",
+                statusCode: 409
+            });
+        }
+        const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
+        const config = await deps.projectService.loadConfig(project.repoRoot);
+        return deps.usageAnalyticsService.getReport(getTaskRuntimeRepoRoot(task), config.stateRoot, task.taskSlug);
+    });
+}

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

@@ -7,6 +7,7 @@ import { fileURLToPath } from "node:url";
 import { renderArchitectHarnessRules } from "../templates/harness/architect-agent.js";
 import { renderCoderHarnessRules } from "../templates/harness/coder-agent.js";
 import { renderCoderWorkerHarnessRules } from "../templates/harness/coder-worker-agent.js";
+import { renderArchitectScaffoldWorkerHarnessRules } from "../templates/harness/architect-scaffold-worker-agent.js";
 import { renderGateReviewerAgentRules, renderRequestGateReviewTool, renderTranslatorAgentRules, renderVcmGateReviewSkillRules } from "../templates/harness/gate-review.js";
 import { renderHarnessEngineerHarnessRules } from "../templates/harness/harness-engineer-agent.js";
 import { renderRootClaudeHarnessRules } from "../templates/harness/claude-root.js";
@@ -27,6 +28,7 @@ import { renderVcmReportHarnessIssueSkillRules } from "../templates/harness/vcm-
 import { renderVcmRouteMessageSkillRules } from "../templates/harness/vcm-route-message-skill.js";
 import { renderUpdateTaskStateTool, renderVcmTaskStateSkillRules } from "../templates/harness/vcm-task-state-skill.js";
 import { renderCheckScaffoldLedgerTool } from "../templates/harness/check-scaffold-ledger.js";
+import { renderRequestArchitectRestartTool, renderRestartArchitectSkillRules } from "../templates/harness/restart-architect-skill.js";
 import { readVcmPackageVersion } from "../app-version.js";
 const CLI_DIR = path.dirname(fileURLToPath(import.meta.url));
 const APP_ROOT = path.resolve(CLI_DIR, "../../..");
@@ -59,7 +61,8 @@ const AGENT_FRONTMATTER = {
         description: "User-facing VCM orchestration role for task clarification, role routing, handoffs, acceptance, and PR preparation."
     },
     architect: {
-        description: "VCM architecture role for plans, module boundaries, public contracts, verifiable behavior, and docs sync."
+        description: "VCM architecture role for plans, module boundaries, public contracts, verifiable behavior, and docs sync.",
+        tools: "Read, Grep, Glob, Bash, Edit, Write, Agent"
     },
     coder: {
         description: "VCM implementation role for scoped code changes and focused tests.",
@@ -81,6 +84,11 @@ const AGENT_FRONTMATTER = {
     "vcm-coder-worker": {
         description: "Bounded VCM implementation worker for assigned modules, files, and VCM:CODE markers from Coder.",
         model: "inherit"
+    },
+    "vcm-architect-scaffold-worker": {
+        description: "Foreground Architect worker for exact scaffold execution and scaffold validation.",
+        model: "opus",
+        effort: "xhigh"
     }
 };
 const MANAGED_FILES = [
@@ -195,6 +203,14 @@ const MANAGED_FILES = [
         commentStyle: "html",
         category: "agent-coder-worker",
         content: renderCoderWorkerHarnessRules()
+    },
+    {
+        path: ".claude/agents/vcm-architect-scaffold-worker.md",
+        title: "VCM Architect Scaffold Worker Agent",
+        agentName: "vcm-architect-scaffold-worker",
+        commentStyle: "html",
+        category: "agent-architect-scaffold-worker",
+        content: renderArchitectScaffoldWorkerHarnessRules()
     }
 ];
 const DURABLE_DOC_TEMPLATES = [
@@ -284,6 +300,12 @@ const WHOLE_FILES = [
         mode: 0o644,
         content: renderSkillFile("VCM Propose Memory Skill", "vcm-propose-memory", "Use only when VCM requests a role memory proposal during Task Harness Review.", renderVcmProposeMemorySkillRules())
     },
+    {
+        path: ".claude/skills/restart-architect/SKILL.md",
+        category: "skill",
+        mode: 0o644,
+        content: renderSkillFile("Restart Architect Skill", "restart-architect", "Use after Architect completes and commits architecture planning and scaffold work.", renderRestartArchitectSkillRules())
+    },
     {
         path: ".ai/tools/request-gate-review",
         category: "runtime-tool",
@@ -302,6 +324,12 @@ const WHOLE_FILES = [
         mode: 0o755,
         content: renderCheckScaffoldLedgerTool()
     },
+    {
+        path: ".ai/tools/request-architect-restart",
+        category: "runtime-tool",
+        mode: 0o755,
+        content: renderRequestArchitectRestartTool()
+    },
     {
         path: ".ai/tools/run-long-check",
         category: "runtime-tool",
@@ -526,6 +554,7 @@ function fixedDirectories() {
         ".claude/skills/vcm-gate-review/",
         ".claude/skills/vcm-report-harness-issue/",
         ".claude/skills/vcm-propose-memory/",
+        ".claude/skills/restart-architect/",
         ".ai/vcm/translations/",
         ".ai/vcm/gate-reviews/",
         ".ai/tools/",
@@ -586,6 +615,9 @@ async function installManagedFile({ projectRoot, definition, dryRun, operations
     if (definition.memoryBlock) {
         nextContent = ensureVcmMemoryBlock(nextContent);
     }
+    if (definition.agentName === "architect") {
+        nextContent = ensureAgentTool(nextContent, "Agent");
+    }
     await writeIfChanged({
         targetPath,
         relativePath: definition.path,
@@ -627,10 +659,27 @@ function renderNewManagedFile(definition, block) {
         const frontmatter = AGENT_FRONTMATTER[definition.agentName];
         const tools = frontmatter.tools ?? "Read, Grep, Glob, Bash, Edit, Write";
         const model = frontmatter.model ? `\nmodel: ${frontmatter.model}` : "";
-        return `---\nname: ${definition.agentName}\ndescription: ${frontmatter.description}\ntools: ${tools}${model}\n---\n\n# ${definition.title}\n\n${block}${suffix ? `\n\n${suffix}` : ""}\n`;
+        const effort = frontmatter.effort ? `\neffort: ${frontmatter.effort}` : "";
+        return `---\nname: ${definition.agentName}\ndescription: ${frontmatter.description}\ntools: ${tools}${model}${effort}\n---\n\n# ${definition.title}\n\n${block}${suffix ? `\n\n${suffix}` : ""}\n`;
     }
     return `# ${definition.title}\n\n${block}${suffix ? `\n\n${suffix}` : ""}\n`;
 }
+function ensureAgentTool(content, requiredTool) {
+    const frontmatterMatch = content.match(/^---\r?\n[\s\S]*?\r?\n---/);
+    if (!frontmatterMatch) {
+        return content;
+    }
+    const toolsMatch = frontmatterMatch[0].match(/^tools:\s*(.*)$/m);
+    if (!toolsMatch) {
+        return content.replace(/^(---\r?\n[\s\S]*?)(\r?\n---)/, `$1\ntools: ${requiredTool}$2`);
+    }
+    const tools = toolsMatch[1].split(",").map((tool) => tool.trim()).filter(Boolean);
+    if (tools.includes(requiredTool)) {
+        return content;
+    }
+    const nextTools = [...tools, requiredTool].join(", ");
+    return content.replace(frontmatterMatch[0], frontmatterMatch[0].replace(toolsMatch[0], `tools: ${nextTools}`));
+}
 function migrateLegacyManagedFile(definition, currentContent, block) {
     const legacyContent = definition.legacyWholeFile?.trimEnd();
     if (!legacyContent) {

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/server.js

@@ -5,7 +5,6 @@ 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 { createClaudeSettingsAdapter } from "./adapters/claude-settings-adapter.js";
 import { createCommandRunner } from "./adapters/command-runner.js";
 import { createCommandDispatcher } from "./services/command-dispatcher.js";
 import { createClaudeHookService } from "./services/claude-hook-service.js";
@@ -13,6 +12,7 @@ import { createGitAdapter } from "./adapters/git-adapter.js";
 import { createAppSettingsService } from "./services/app-settings-service.js";
 import { createCcrIntegrationService } from "./services/ccr-integration-service.js";
 import { createAutoMemoryService } from "./services/auto-memory-service.js";
+import { createArchitectRestartService } from "./services/architect-restart-service.js";
 import { createClaudeTranscriptService } from "./services/claude-transcript-service.js";
 import { createGateReviewService } from "./services/gate-review-service.js";
 import { createHarnessFeedbackService } from "./services/harness-feedback-service.js";
@@ -43,6 +43,7 @@ import { createTaskWorkflowService } from "./services/task-workflow-service.js";
 import { createTaskLaunchService } from "./services/task-launch-service.js";
 import { createTerminalInterruptService } from "./services/terminal-interrupt-service.js";
 import { createTranslationService } from "./services/translation-service.js";
+import { createUsageAnalyticsService } from "./services/usage-analytics-service.js";
 import { createTurnReconcilerService } from "./services/turn-reconciler-service.js";
 import { createDiagnosticsService } from "./services/diagnostics-service.js";
 import { registerAppSettingsRoutes } from "./api/app-settings-routes.js";
@@ -58,6 +59,7 @@ import { registerRuntimeStateRoutes } from "./api/runtime-state-routes.js";
 import { registerSessionRoutes } from "./api/session-routes.js";
 import { registerTaskRoutes } from "./api/task-routes.js";
 import { registerTranslationRoutes } from "./api/translation-routes.js";
+import { registerUsageAnalyticsRoutes } from "./api/usage-analytics-routes.js";
 import { registerTerminalWs } from "./ws/terminal-ws.js";
 import { toVcmError } from "./errors.js";
 import { readVcmPackageVersion } from "./app-version.js";
@@ -133,7 +135,8 @@ export async function createServer(deps, options = {}) {
         sessionService: deps.sessionService,
         commandDispatcher: deps.commandDispatcher,
         translationService: deps.translationService,
-        roundService: deps.roundService
+        roundService: deps.roundService,
+        architectRestartService: deps.architectRestartService
     });
     registerArtifactRoutes(app, {
         projectService: deps.projectService,
@@ -156,6 +159,11 @@ export async function createServer(deps, options = {}) {
         sessionService: deps.sessionService,
         translationService: deps.translationService
     });
+    registerUsageAnalyticsRoutes(app, {
+        projectService: deps.projectService,
+        taskService: deps.taskService,
+        usageAnalyticsService: deps.usageAnalyticsService
+    });
     registerGatewayRoutes(app, { gatewayService: deps.gatewayService });
     registerTerminalWs(app, {
         runtime: deps.runtime,
@@ -209,11 +217,9 @@ export function createDefaultServerDeps(options = {}) {
     const git = createGitAdapter(runner);
     const claude = createClaudeAdapter(runner);
     const appSettings = createAppSettingsService({ fs });
-    const claudeSettings = createClaudeSettingsAdapter({ fs });
     const ccrIntegration = createCcrIntegrationService({
         settings: appSettings,
-        gateway: createCcrGatewayAdapter(),
-        restoreNativeClaudeSettings: () => claudeSettings.restoreNativeSettings()
+        gateway: createCcrGatewayAdapter()
     });
     const runtime = createNodePtyTerminalRuntime({ fs });
     const registry = createSessionRegistry();
@@ -267,12 +273,18 @@ export function createDefaultServerDeps(options = {}) {
         sessionService,
         artifactService
     });
+    const architectRestartService = createArchitectRestartService({
+        fs,
+        taskService,
+        sessionService
+    });
     const messageService = createMessageService({
         fs,
         runtime,
         sessionService,
         taskService,
-        taskWorkflowService
+        taskWorkflowService,
+        onRouteDelivered: ({ repoRoot, taskSlug, message }) => architectRestartService.recordRouteDelivered(repoRoot, taskSlug, message)
     });
     const taskLaunchService = createTaskLaunchService({
         projectService,
@@ -315,6 +327,7 @@ export function createDefaultServerDeps(options = {}) {
         roundService,
         appSettings
     });
+    const usageAnalyticsService = createUsageAnalyticsService({ fs });
     const gatewayChannels = createGatewayChannelRegistry([
         createWeixinIlinkChannel(),
         createLarkChannel()
@@ -334,7 +347,8 @@ export function createDefaultServerDeps(options = {}) {
         translationService,
         roundService,
         projectService,
-        taskWorkflowService
+        taskWorkflowService,
+        architectRestartService
     });
     const gatewayService = createGatewayService({
         fs,
@@ -371,7 +385,8 @@ export function createDefaultServerDeps(options = {}) {
         autoMemoryService,
         gatewayService,
         jobGuard: createJobGuardService(),
-        translationWorkerService
+        translationWorkerService,
+        architectRestartService
     });
     const turnReconciler = createTurnReconcilerService({
         sessionService,
@@ -415,6 +430,7 @@ export function createDefaultServerDeps(options = {}) {
         taskService,
         taskCloseService,
         taskWorkflowService,
+        architectRestartService,
         sessionService,
         artifactService,
         harnessService,
@@ -434,7 +450,8 @@ export function createDefaultServerDeps(options = {}) {
         runtimeRecoveryService,
         terminalInterruptService,
         runtime,
-        diagnosticsService
+        diagnosticsService,
+        usageAnalyticsService
     };
 }
 export function getDefaultStaticDir() {

package/dist/backend/services/architect-restart-service.js

@@ -0,0 +1,136 @@
+import path from "node:path";
+import { resolveRepoPath } from "../adapters/filesystem.js";
+import { VcmError } from "../errors.js";
+import { getTaskRuntimeRepoRoot } from "./task-service.js";
+const ARCHITECT_ROLE = "architect";
+const PM_ROLE = "project-manager";
+const COMPLETE_PLAN_PATTERN = /^Planning Result:\s*complete\s*$/im;
+export const ARCHITECT_RESTORE_PROMPT = `This Architect session continues the current task after completed architecture planning.
+
+Before performing any assigned work, read:
+- .ai/vcm/handoffs/architecture-brief.md
+- .ai/vcm/handoffs/architecture-evidence.md
+- .ai/vcm/handoffs/architecture-plan.md
+- the current scaffold commit and worktree state
+- the latest Gate Review report when present
+
+Treat the current artifacts and worktree as the source of truth. Do not repeat the completed interview or planning work unless current evidence contradicts them.`;
+export function createArchitectRestartService(deps) {
+    const pendingByTask = new Map();
+    return {
+        async schedule(repoRoot, taskSlug) {
+            const session = await requireRunningArchitect(repoRoot, taskSlug);
+            await requireCompletePlan(repoRoot, taskSlug);
+            const key = taskKey(repoRoot, taskSlug);
+            const existing = pendingByTask.get(key);
+            if (existing?.sessionId === session.id) {
+                return { taskSlug, sessionId: session.id, status: "scheduled" };
+            }
+            pendingByTask.set(key, {
+                repoRoot,
+                taskSlug,
+                sessionId: session.id,
+                stopped: false,
+                executing: false
+            });
+            return { taskSlug, sessionId: session.id, status: "scheduled" };
+        },
+        async recordArchitectStop(repoRoot, taskSlug, sessionId) {
+            const pending = pendingByTask.get(taskKey(repoRoot, taskSlug));
+            if (!pending || pending.sessionId !== sessionId) {
+                return;
+            }
+            pending.stopped = true;
+            await tryRestart(pending);
+        },
+        async recordRouteDelivered(repoRoot, taskSlug, message) {
+            if (!isArchitectToPm(message)) {
+                return;
+            }
+            const pending = pendingByTask.get(taskKey(repoRoot, taskSlug));
+            if (!pending) {
+                return;
+            }
+            pending.deliveredMessageId = message.id;
+            await tryRestart(pending);
+        },
+        async recordRouteAccepted(repoRoot, taskSlug, message) {
+            if (!isArchitectToPm(message)) {
+                return;
+            }
+            const pending = pendingByTask.get(taskKey(repoRoot, taskSlug));
+            if (!pending) {
+                return;
+            }
+            pending.acceptedMessageId = message.id;
+            await tryRestart(pending);
+        },
+        clear(repoRoot, taskSlug) {
+            pendingByTask.delete(taskKey(repoRoot, taskSlug));
+        }
+    };
+    async function requireRunningArchitect(repoRoot, taskSlug) {
+        const session = await deps.sessionService.getRoleSession(repoRoot, taskSlug, ARCHITECT_ROLE);
+        if (!session || session.status !== "running") {
+            throw new VcmError({
+                code: "ARCHITECT_SESSION_NOT_RUNNING",
+                message: "Architect session is not running.",
+                statusCode: 409
+            });
+        }
+        return session;
+    }
+    async function requireCompletePlan(repoRoot, taskSlug) {
+        const task = await deps.taskService.loadTask(repoRoot, taskSlug);
+        const planPath = resolveRepoPath(getTaskRuntimeRepoRoot(task), path.posix.join(task.handoffDir, "architecture-plan.md"));
+        if (!(await deps.fs.pathExists(planPath))) {
+            throw incompletePlanError("architecture-plan.md does not exist.");
+        }
+        const content = await deps.fs.readText(planPath);
+        if (!COMPLETE_PLAN_PATTERN.test(content)) {
+            throw incompletePlanError("architecture-plan.md is not marked complete.");
+        }
+    }
+    async function tryRestart(pending) {
+        if (pending.executing
+            || !pending.stopped
+            || !pending.deliveredMessageId
+            || pending.deliveredMessageId !== pending.acceptedMessageId) {
+            return;
+        }
+        const session = await deps.sessionService.getRoleSession(pending.repoRoot, pending.taskSlug, ARCHITECT_ROLE);
+        if (!session
+            || session.id !== pending.sessionId
+            || session.status !== "running"
+            || session.activityStatus !== "idle") {
+            return;
+        }
+        pending.executing = true;
+        try {
+            await requireCompletePlan(pending.repoRoot, pending.taskSlug);
+            await deps.sessionService.restartRoleSession(pending.repoRoot, pending.taskSlug, ARCHITECT_ROLE, {
+                permissionMode: session.permissionMode,
+                model: session.model,
+                effort: session.effort,
+                appendSystemPrompt: ARCHITECT_RESTORE_PROMPT
+            });
+            pendingByTask.delete(taskKey(pending.repoRoot, pending.taskSlug));
+        }
+        catch {
+            pending.executing = false;
+        }
+    }
+}
+function isArchitectToPm(message) {
+    return message.fromRole === ARCHITECT_ROLE && message.toRole === PM_ROLE;
+}
+function taskKey(repoRoot, taskSlug) {
+    return `${repoRoot}\0${taskSlug}`;
+}
+function incompletePlanError(reason) {
+    return new VcmError({
+        code: "ARCHITECT_PLAN_INCOMPLETE",
+        message: `Architect restart cannot be scheduled. ${reason}`,
+        statusCode: 409
+    });
+}

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

@@ -1,11 +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) {
@@ -67,9 +71,6 @@ export function createCcrIntegrationService(deps) {
     return {
         async initialize() {
             const settings = await deps.settings.getCcrIntegrationSettings();
-            if (settings.apiKey) {
-                await deps.restoreNativeClaudeSettings?.();
-            }
             if (settings.enabled) {
                 await probe(true);
             }
@@ -102,9 +103,6 @@ export function createCcrIntegrationService(deps) {
                 enabled: nextEnabled,
                 apiKey: nextApiKey
             });
-            if (nextApiKey) {
-                await deps.restoreNativeClaudeSettings?.();
-            }
             if (clearApiKey || !nextEnabled) {
                 cachedProbe = undefined;
                 return buildStatus();
@@ -130,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) {
@@ -164,15 +162,12 @@ 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) {
-            const settings = await deps.settings.getCcrIntegrationSettings();
-            if (settings.apiKey) {
-                await deps.restoreNativeClaudeSettings?.();
-            }
             if (!isCcrSessionModel(model)) {
                 return undefined;
             }
@@ -182,6 +177,70 @@ export function createCcrIntegrationService(deps) {
         }
     };
 }
+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.");