vibe-coding-master 0.7.15 → 0.7.17

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

@@ -227,6 +227,9 @@ export function createClaudeHookService(deps) {
             role: input.role,
             prompt: stringOrUndefined(input.event.prompt)
         });
+        if (submitted) {
+            await deps.architectRestartService?.recordRouteAccepted(context.project.repoRoot, context.taskSlug, submitted);
+        }
         return {
             ok: true,
             eventName,
@@ -437,6 +440,9 @@ export function createClaudeHookService(deps) {
                 occurredAt: session.lastTurnEndedAt ?? session.updatedAt
             });
         }
+        if (eventName === "Stop" && input.role === "architect" && session) {
+            await deps.architectRestartService?.recordArchitectStop(context.project.repoRoot, context.taskSlug, session.id);
+        }
         if (options.notifyGateway && session && input.role === "project-manager") {
             void deps.gatewayService?.handlePmStop({
                 repoRoot: context.project.repoRoot,

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/gate-review-service.js

@@ -56,6 +56,7 @@ const CODE_DIFF_ANALYSIS_FIELDS = [
 const SOURCE_ARTIFACTS = {
     "architecture-plan": [
         ".ai/vcm/handoffs/architecture-brief.md",
+        ".ai/vcm/handoffs/architecture-evidence.md",
         ".ai/vcm/handoffs/architecture-plan.md"
     ],
     "validation-adequacy": [
@@ -228,6 +229,30 @@ export function createGateReviewService(deps) {
                     message: architectureBriefError
                 };
             }
+            const architectureEvidenceError = await readArchitectureEvidenceError(deps.fs, context.taskRepoRoot);
+            if (architectureEvidenceError) {
+                index = applyGateState(index, gate, {
+                    status: "failed",
+                    decision: undefined,
+                    error: architectureEvidenceError,
+                    exceptionReason: undefined,
+                    requestId: undefined,
+                    requestPath: undefined,
+                    inputHash: undefined,
+                    requestedAt: undefined,
+                    startedAt: undefined,
+                    completedAt: now(),
+                    callbackStatus: "not_sent",
+                    callbackError: undefined
+                }, now(), true);
+                await saveIndex(deps.fs, context.taskRepoRoot, index);
+                return {
+                    status: "failed_to_start",
+                    gate,
+                    record: index.gates[gate],
+                    message: architectureEvidenceError
+                };
+            }
         }
         const coreInput = await readCoreInputArtifact(deps.fs, context.taskRepoRoot, gate);
         if (coreInput && coreInput.status !== "ready") {
@@ -961,6 +986,21 @@ async function readArchitectureBriefError(fs, taskRepoRoot) {
     }
     return undefined;
 }
+async function readArchitectureEvidenceError(fs, taskRepoRoot) {
+    const relativePath = ".ai/vcm/handoffs/architecture-evidence.md";
+    const absolutePath = resolveRepoPath(taskRepoRoot, relativePath);
+    if (!await fs.pathExists(absolutePath)) {
+        return `${relativePath} is missing. Complete architecture evidence before requesting architecture-plan review.`;
+    }
+    const content = await fs.readText(absolutePath);
+    if (content.trim().length === 0) {
+        return `${relativePath} is empty. Complete architecture evidence before requesting architecture-plan review.`;
+    }
+    if (!/^\s*Architecture Evidence Status\s*:\s*complete\s*$/im.test(content)) {
+        return `${relativePath} is incomplete. Finish current-worktree evidence before requesting architecture-plan review.`;
+    }
+    return undefined;
+}
 async function commandStdout(runner, cwd, args) {
     const result = await runner.run("git", args, { cwd });
     return result.exitCode === 0 ? result.stdout : "";

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

@@ -4,6 +4,7 @@ import { promisify } from "node:util";
 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";
@@ -24,6 +25,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 { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { VcmError } from "../errors.js";
 import { bumpHarnessRevision, readHarnessRevisionState } from "./harness-revision.js";
@@ -172,6 +174,14 @@ const HARNESS_FILES = [
         ownership: "whole-file",
         renderRules: renderVcmProposeMemorySkillRules
     },
+    {
+        kind: "skill-restart-architect",
+        path: ".claude/skills/restart-architect/SKILL.md",
+        title: "Restart Architect Skill",
+        frontmatter: renderSkillFrontmatter("restart-architect", "Use after Architect completes and commits architecture planning and scaffold work."),
+        ownership: "whole-file",
+        renderRules: renderRestartArchitectSkillRules
+    },
     {
         kind: "agent-gate-reviewer",
         path: ".claude/agents/gate-reviewer.md",
@@ -202,6 +212,13 @@ const HARNESS_FILES = [
         frontmatter: renderAgentFrontmatter("vcm-coder-worker", "Bounded VCM implementation worker for assigned modules, files, and VCM:CODE markers from Coder.", { model: "inherit" }),
         renderRules: renderCoderWorkerHarnessRules
     },
+    {
+        kind: "agent-architect-scaffold-worker",
+        path: ".claude/agents/vcm-architect-scaffold-worker.md",
+        title: "VCM Architect Scaffold Worker Agent",
+        frontmatter: renderAgentFrontmatter("vcm-architect-scaffold-worker", "Foreground Architect worker for exact scaffold execution and scaffold validation.", { model: "opus", effort: "xhigh" }),
+        renderRules: renderArchitectScaffoldWorkerHarnessRules
+    },
     {
         kind: "tool-request-gate-review",
         path: ".ai/tools/request-gate-review",
@@ -223,6 +240,13 @@ const HARNESS_FILES = [
         ownership: "raw-file",
         renderRules: renderCheckScaffoldLedgerTool
     },
+    {
+        kind: "tool-request-architect-restart",
+        path: ".ai/tools/request-architect-restart",
+        title: "Request Architect Restart Tool",
+        ownership: "raw-file",
+        renderRules: renderRequestArchitectRestartTool
+    },
     {
         kind: "agent-project-manager",
         path: ".claude/agents/project-manager.md",
@@ -237,7 +261,7 @@ const HARNESS_FILES = [
         title: "Architect Agent",
         memoryBlock: true,
         blankLineBeforeEnd: true,
-        frontmatter: renderAgentFrontmatter("architect", "VCM architecture role for plans, module boundaries, public contracts, verifiable behavior, and docs sync."),
+        frontmatter: renderAgentFrontmatter("architect", "VCM architecture role for plans, module boundaries, public contracts, verifiable behavior, and docs sync.", { tools: "Read, Grep, Glob, Bash, Edit, Write, Agent" }),
         renderRules: renderArchitectHarnessRules
     },
     {
@@ -1192,6 +1216,9 @@ async function analyzeHarnessFile(fs, repoRoot, definition) {
             };
         }
         const insertedContent = `${currentContent.trimEnd()}\n\n${expectedBlock}\n`;
+        const nextContent = definition.kind === "agent-architect"
+            ? ensureAgentTool(insertedContent, "Agent")
+            : insertedContent;
         return {
             definition,
             status: {
@@ -1206,13 +1233,16 @@ async function analyzeHarnessFile(fs, repoRoot, definition) {
                 action: "insert",
                 reason: "File exists but does not contain VCM managed rules."
             },
-            nextContent: definition.memoryBlock ? ensureVcmMemoryBlock(insertedContent) : insertedContent
+            nextContent: definition.memoryBlock ? ensureVcmMemoryBlock(nextContent) : nextContent
         };
     }
     const managedVersion = match[1] ? Number(match[1]) : undefined;
     const currentBlock = match[0];
     const blockUpdatedContent = currentContent.replace(managedBlockPattern, expectedBlock);
-    const nextContent = definition.memoryBlock ? ensureVcmMemoryBlock(blockUpdatedContent) : blockUpdatedContent;
+    const memoryUpdatedContent = definition.memoryBlock ? ensureVcmMemoryBlock(blockUpdatedContent) : blockUpdatedContent;
+    const nextContent = definition.kind === "agent-architect"
+        ? ensureAgentTool(memoryUpdatedContent, "Agent")
+        : memoryUpdatedContent;
     const action = currentContent === nextContent ? "ok" : "update";
     return {
         definition,
@@ -1323,6 +1353,22 @@ function renderNewHarnessFile(definition, block, contentAfterBlock = definition.
     const suffix = contentAfterBlock?.trim();
     return `${frontmatter}# ${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 migrateLegacyHarnessFile(definition, currentContent, block) {
     const legacyContent = definition.legacyWholeFile?.trimEnd();
     if (!legacyContent) {
@@ -1454,7 +1500,8 @@ function isPlainObject(value) {
 function renderAgentFrontmatter(name, description, options = {}) {
     const tools = options.tools ?? "Read, Grep, Glob, Bash, Edit, Write";
     const model = options.model ? `\nmodel: ${options.model}` : "";
-    return `---\nname: ${name}\ndescription: ${description}\ntools: ${tools}${model}\n---`;
+    const effort = options.effort ? `\neffort: ${options.effort}` : "";
+    return `---\nname: ${name}\ndescription: ${description}\ntools: ${tools}${model}${effort}\n---`;
 }
 function renderSkillFrontmatter(name, description) {
     return `---\nname: ${name}\ndescription: ${description}\n---`;

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

@@ -130,6 +130,11 @@ export function createMessageService(deps) {
             }).catch(() => undefined);
         }
         scheduleDispatchConfirmation(input, delivered, session.id);
+        await deps.onRouteDelivered?.({
+            repoRoot: input.repoRoot,
+            taskSlug: input.taskSlug,
+            message: delivered
+        });
         return {
             message: delivered,
             delivered: true,

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

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import path from "node:path";
 import { ROLE_NAMES, isDispatchableRole } from "../../shared/constants.js";
 import { CCR_GPT_SESSION_MODEL, isCcrSessionModel } from "../../shared/types/session.js";
@@ -55,6 +56,9 @@ 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);
+        if (launchMode === "resume" && persisted) {
+            assertResumeProviderCompatible(persisted, model);
+        }
         const [modelEnvironment, modelSettingsOverride] = await Promise.all([
             getModelLaunchEnvironment(model),
             getModelLaunchSettingsOverride(model)
@@ -74,10 +78,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, modelSettingsOverride),
+            ...deps.claude.buildRoleStartCommand(role, config.claudeCommand, permissionMode, resumeClaudeSessionId, launchMode === "resume", model, effort, modelSettingsOverride, input.appendSystemPrompt),
             cwd: taskRepoRoot
         };
         const runtimeSession = await deps.runtime.createSession({
@@ -94,7 +98,7 @@ export function createSessionService(deps) {
                 VCM_TASK_SLUG: taskSlug,
                 VCM_ROLE: role,
                 VCM_SESSION_ID: claudeSessionId || undefined
-            }, modelEnvironment),
+            }, modelEnvironment, buildUsageTelemetryEnvironment(deps.apiUrl, role, model)),
             cols: input.cols,
             rows: input.rows
         });
@@ -113,6 +117,7 @@ export function createSessionService(deps) {
             model,
             effort,
             cwd: startCommand.cwd,
+            claudeConfigDir: readClaudeConfigDir(modelEnvironment),
             terminalBackend: "node-pty",
             pid: runtimeSession.pid,
             roleCommandPath: isDispatchableRole(role)
@@ -163,6 +168,9 @@ 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");
+        if (launchMode === "resume" && persisted) {
+            assertResumeProviderCompatible(persisted, model);
+        }
         const [modelEnvironment, modelSettingsOverride] = await Promise.all([
             getModelLaunchEnvironment(model),
             getModelLaunchSettingsOverride(model)
@@ -194,7 +202,7 @@ 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, modelSettingsOverride),
@@ -217,7 +225,7 @@ export function createSessionService(deps) {
                 VCM_TASK_SLUG: PROJECT_TRANSLATOR_SCOPE,
                 VCM_ROLE: TRANSLATOR_ROLE,
                 VCM_SESSION_ID: claudeSessionId || undefined
-            }, modelEnvironment),
+            }, modelEnvironment, buildUsageTelemetryEnvironment(deps.apiUrl, TRANSLATOR_ROLE, model)),
             cols: input.cols,
             rows: input.rows
         });
@@ -236,6 +244,7 @@ export function createSessionService(deps) {
             model,
             effort,
             cwd: sessionCwd,
+            claudeConfigDir: readClaudeConfigDir(modelEnvironment),
             terminalBackend: "node-pty",
             pid: runtimeSession.pid,
             startedAt: runtimeSession.startedAt,
@@ -276,6 +285,9 @@ 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");
+        if (launchMode === "resume" && persisted) {
+            assertResumeProviderCompatible(persisted, model);
+        }
         const [modelEnvironment, modelSettingsOverride] = await Promise.all([
             getModelLaunchEnvironment(model),
             getModelLaunchSettingsOverride(model)
@@ -303,7 +315,7 @@ 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, modelSettingsOverride),
@@ -326,7 +338,7 @@ export function createSessionService(deps) {
                 VCM_TASK_SLUG: PROJECT_HARNESS_ENGINEER_SCOPE,
                 VCM_ROLE: HARNESS_ENGINEER_ROLE,
                 VCM_SESSION_ID: claudeSessionId || undefined
-            }, modelEnvironment),
+            }, modelEnvironment, buildUsageTelemetryEnvironment(deps.apiUrl, HARNESS_ENGINEER_ROLE, model)),
             cols: input.cols,
             rows: input.rows
         });
@@ -345,6 +357,7 @@ export function createSessionService(deps) {
             model,
             effort,
             cwd: sessionCwd,
+            claudeConfigDir: readClaudeConfigDir(modelEnvironment),
             terminalBackend: "node-pty",
             pid: runtimeSession.pid,
             startedAt: runtimeSession.startedAt,
@@ -489,6 +502,7 @@ export function createSessionService(deps) {
         const permissionMode = normalizeClaudePermissionMode(session.permissionMode);
         const model = normalizeClaudeModel(session.model);
         const effort = normalizeClaudeEffort(session.effort);
+        assertResumeProviderCompatible(session, model);
         const [modelEnvironment, modelSettingsOverride] = await Promise.all([
             getModelLaunchEnvironment(model),
             getModelLaunchSettingsOverride(model)
@@ -516,7 +530,7 @@ export function createSessionService(deps) {
                 VCM_TASK_SLUG: normalizeProjectScopedRecordForPersistence(session).taskSlug,
                 VCM_ROLE: session.role,
                 VCM_SESSION_ID: session.claudeSessionId
-            }, modelEnvironment)
+            }, modelEnvironment, buildUsageTelemetryEnvironment(deps.apiUrl, session.role, model))
         });
         if ((await waitForSessionInputReady(runtimeSession.id)) === "exited") {
             deps.registry.remove(runtimeSession.id);
@@ -546,13 +560,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));
@@ -560,16 +575,16 @@ 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);
     }
@@ -1490,6 +1505,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
@@ -1500,13 +1537,40 @@ function formatClaudeCdCommand(targetCwd) {
 function isExitedStatus(status) {
     return status === "exited" || status === "crashed" || status === "missing";
 }
-function withClaudeCodeRuntimeEnv(env, modelEnvironment = {}) {
+function withClaudeCodeRuntimeEnv(env, modelEnvironment = {}, telemetryEnvironment = {}) {
     return {
         ...env,
         ...modelEnvironment,
+        ...telemetryEnvironment,
         CLAUDE_CODE_DISABLE_AUTO_MEMORY
     };
 }
+function buildUsageTelemetryEnvironment(apiUrl, role, model) {
+    const disabled = {
+        CLAUDE_CODE_ENABLE_TELEMETRY: undefined,
+        OTEL_LOGS_EXPORTER: "none",
+        OTEL_METRICS_EXPORTER: "none",
+        OTEL_TRACES_EXPORTER: "none",
+        OTEL_EXPORTER_OTLP_LOGS_PROTOCOL: undefined,
+        OTEL_EXPORTER_OTLP_LOGS_ENDPOINT: undefined,
+        OTEL_RESOURCE_ATTRIBUTES: undefined,
+        OTEL_LOG_USER_PROMPTS: "0",
+        OTEL_LOG_ASSISTANT_RESPONSES: "0",
+        OTEL_LOG_TOOL_DETAILS: "0",
+        OTEL_LOG_RAW_API_BODIES: "0"
+    };
+    if (!apiUrl || isCcrSessionModel(model)) {
+        return disabled;
+    }
+    return {
+        ...disabled,
+        CLAUDE_CODE_ENABLE_TELEMETRY: "1",
+        OTEL_LOGS_EXPORTER: "otlp",
+        OTEL_EXPORTER_OTLP_LOGS_PROTOCOL: "http/json",
+        OTEL_EXPORTER_OTLP_LOGS_ENDPOINT: `${apiUrl.replace(/\/+$/, "")}/api/telemetry/v1/logs`,
+        OTEL_RESOURCE_ATTRIBUTES: `vcm.role=${role},vcm.launch_id=${randomUUID()}`
+    };
+}
 function delay(ms) {
     if (ms <= 0) {
         return Promise.resolve();

package/dist/backend/services/task-close-service.js

@@ -5,6 +5,7 @@ export function createTaskCloseService(deps) {
         async closeTask(repoRoot, taskSlug) {
             const task = await deps.taskService.markTaskCleaned(repoRoot, taskSlug);
             const warnings = [];
+            deps.architectRestartService?.clear(repoRoot, taskSlug);
             await stopTaskRoleSessions(repoRoot, taskSlug, warnings);
             await bestEffort("Unable to stop task translation runtime", () => deps.translationService.stopTask(getTaskRuntimeRepoRoot(task), taskSlug, { clearCache: true }), warnings);
             await bestEffort("Unable to clear task round runtime", () => deps.roundService.stopTask(taskSlug), warnings);