vibe-coding-master 0.7.16 → 0.7.18

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
@@ -270,7 +282,7 @@ not fall back to another model.
 
 ## Launch Template
 
-The launch template stores per-role defaults:
+The global launch template stores per-role defaults for the five workflow roles:
 
 - permission mode
 - model
@@ -281,7 +293,12 @@ One-click start launches the four core roles. If any Gate Review Gate is enabled
 it also launches Gate Reviewer.
 
 Translator and Harness Engineer are tool roles. They are controlled from their
-own panels, not from the main role tab bar.
+own panels, not from the main role tab bar or the one-click launch template.
+Their permission, model, and effort are stored as independent tool Session
+defaults only after an explicit Start or Restart succeeds. Selector changes,
+Resume, and backend automatic startup do not write these defaults. Without a
+saved value, both tools use `bypassPermissions`, the default model, and medium
+effort. An existing task Session keeps its own recorded values.
 
 ## Orchestration
 

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/harness-routes.js

@@ -1,4 +1,5 @@
 import { isOpenFileLimitError, VcmError } from "../errors.js";
+import { createDefaultToolSessionDefaults } from "../../shared/types/app-settings.js";
 export function registerHarnessRoutes(app, deps) {
     app.get("/api/projects/harness", async (request) => {
         const { task } = await requireHarnessTaskContext(deps, request.query.taskSlug);
@@ -68,13 +69,17 @@ export function registerHarnessRoutes(app, deps) {
         const { project, task } = await requireHarnessTaskContext(deps, request.body?.taskSlug);
         await deps.autoMemoryService.assertHarnessEngineerAvailable(task.worktreePath);
         await deps.harnessFeedbackService.assertHarnessEngineerAvailable(project.repoRoot);
-        return deps.harnessService.startHarnessBootstrap(project.repoRoot, task.worktreePath, request.body ?? {});
+        const result = await deps.harnessService.startHarnessBootstrap(project.repoRoot, task.worktreePath, request.body ?? {});
+        await persistHarnessEngineerDefaults(deps.appSettings, result.session);
+        return result;
     });
     app.post("/api/projects/harness/bootstrap/restart", async (request) => {
         const { project, task } = await requireHarnessTaskContext(deps, request.body?.taskSlug);
         await deps.autoMemoryService.assertHarnessEngineerAvailable(task.worktreePath);
         await deps.harnessFeedbackService.assertHarnessEngineerAvailable(project.repoRoot);
-        return deps.harnessService.restartHarnessBootstrap(project.repoRoot, task.worktreePath, request.body ?? {});
+        const result = await deps.harnessService.restartHarnessBootstrap(project.repoRoot, task.worktreePath, request.body ?? {});
+        await persistHarnessEngineerDefaults(deps.appSettings, result.session);
+        return result;
     });
     app.post("/api/projects/harness/bootstrap/stop", async (request) => {
         const { project, task } = await requireHarnessTaskContext(deps, request.body?.taskSlug);
@@ -111,7 +116,9 @@ export function registerHarnessRoutes(app, deps) {
         const taskSlug = requireTaskSlug(request.body?.taskSlug, "Harness Engineer");
         const task = await deps.taskService.loadTask(project.repoRoot, taskSlug);
         await deps.autoMemoryService.assertHarnessEngineerAvailable(task.worktreePath);
-        return deps.sessionService.startRoleSession(project.repoRoot, taskSlug, "harness-engineer", request.body);
+        const session = await deps.sessionService.startRoleSession(project.repoRoot, taskSlug, "harness-engineer", request.body);
+        await persistHarnessEngineerDefaults(deps.appSettings, session);
+        return session;
     });
     app.post("/api/projects/harness/engineer/session/resume", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
@@ -125,7 +132,9 @@ export function registerHarnessRoutes(app, deps) {
         const taskSlug = requireTaskSlug(request.body?.taskSlug, "Harness Engineer");
         const task = await deps.taskService.loadTask(project.repoRoot, taskSlug);
         await deps.autoMemoryService.assertHarnessEngineerAvailable(task.worktreePath);
-        return deps.sessionService.restartRoleSession(project.repoRoot, taskSlug, "harness-engineer", request.body);
+        const session = await deps.sessionService.restartRoleSession(project.repoRoot, taskSlug, "harness-engineer", request.body);
+        await persistHarnessEngineerDefaults(deps.appSettings, session);
+        return session;
     });
     app.post("/api/projects/harness/engineer/session/stop", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
@@ -201,6 +210,14 @@ export function registerHarnessRoutes(app, deps) {
         return deps.autoMemoryService.retryFailedReview(project.repoRoot, task.worktreePath);
     });
 }
+async function persistHarnessEngineerDefaults(appSettings, session) {
+    const defaults = createDefaultToolSessionDefaults()["harness-engineer"];
+    await appSettings.updateToolSessionDefaults("harness-engineer", {
+        permissionMode: session.permissionMode ?? defaults.permissionMode,
+        model: session.model ?? defaults.model,
+        effort: session.effort ?? defaults.effort
+    });
+}
 function requireTaskSlug(value, roleLabel) {
     const taskSlug = value?.trim();
     if (!taskSlug) {

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/translation-worker-routes.js

@@ -1,4 +1,5 @@
 import { VcmError } from "../errors.js";
+import { createDefaultToolSessionDefaults } from "../../shared/types/app-settings.js";
 export function registerTranslationWorkerRoutes(app, deps) {
     app.get("/api/translation/state", async () => {
         const project = await requireCurrentProject(deps.projectService);
@@ -29,7 +30,9 @@ export function registerTranslationWorkerRoutes(app, deps) {
     app.post("/api/translation/session/start", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const taskSlug = requireTaskSlug(request.body?.taskSlug, "Translator");
-        return deps.sessionService.startRoleSession(project.repoRoot, taskSlug, "translator", request.body);
+        const session = await deps.sessionService.startRoleSession(project.repoRoot, taskSlug, "translator", request.body);
+        await persistToolSessionDefaults(deps.appSettings, "translator", session);
+        return session;
     });
     app.post("/api/translation/session/resume", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
@@ -44,7 +47,9 @@ export function registerTranslationWorkerRoutes(app, deps) {
         if (existing) {
             await deps.translationService.stopSession(existing.id, { clearCache: true });
         }
-        return deps.sessionService.restartRoleSession(project.repoRoot, taskSlug, "translator", request.body);
+        const session = await deps.sessionService.restartRoleSession(project.repoRoot, taskSlug, "translator", request.body);
+        await persistToolSessionDefaults(deps.appSettings, "translator", session);
+        return session;
     });
     app.post("/api/translation/session/stop", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
@@ -90,6 +95,14 @@ export function registerTranslationWorkerRoutes(app, deps) {
         return deps.translationWorkerService.promoteFileJob(project.repoRoot, request.params.jobId, targetPath);
     });
 }
+async function persistToolSessionDefaults(appSettings, role, session) {
+    const defaults = createDefaultToolSessionDefaults().translator;
+    await appSettings.updateToolSessionDefaults(role, {
+        permissionMode: session.permissionMode,
+        model: session.model ?? defaults.model,
+        effort: session.effort ?? defaults.effort
+    });
+}
 function requireTaskSlug(value, roleLabel) {
     const taskSlug = value?.trim();
     if (!taskSlug) {

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, "../../..");
@@ -40,9 +42,9 @@ const LEGACY_CODEX_HARNESS_PATHS = [
     ".claude/skills/vcm-codex-review-gate",
     ".ai/tools/request-codex-review"
 ];
-const VCM_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --max-time 2 -X POST "\${VCM_API_URL}/api/hooks/claude-code" -H "content-type: application/json" --data-binary @- >/dev/null || true'`;
-const VCM_STOP_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --retry 2 --retry-delay 1 --retry-all-errors --connect-timeout 1 --max-time 2 -X POST "\${VCM_API_URL}/api/hooks/claude-code/stop" -H "content-type: application/json" --data-binary @- || true'`;
-const VCM_PERMISSION_REQUEST_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --max-time 5 -X POST "\${VCM_API_URL}/api/hooks/claude-code/permission-request" -H "content-type: application/json" --data-binary @- || true'`;
+const VCM_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,runtimeSessionToken:process.env.VCM_RUNTIME_SESSION_TOKEN,event}));});'"'"' | curl -fsS --max-time 2 -X POST "\${VCM_API_URL}/api/hooks/claude-code" -H "content-type: application/json" --data-binary @- >/dev/null || true'`;
+const VCM_STOP_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,runtimeSessionToken:process.env.VCM_RUNTIME_SESSION_TOKEN,event}));});'"'"' | curl -fsS --retry 2 --retry-delay 1 --retry-all-errors --connect-timeout 1 --max-time 2 -X POST "\${VCM_API_URL}/api/hooks/claude-code/stop" -H "content-type: application/json" --data-binary @- || true'`;
+const VCM_PERMISSION_REQUEST_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,runtimeSessionToken:process.env.VCM_RUNTIME_SESSION_TOKEN,event}));});'"'"' | curl -fsS --max-time 5 -X POST "\${VCM_API_URL}/api/hooks/claude-code/permission-request" -H "content-type: application/json" --data-binary @- || true'`;
 const VCM_BASH_GUARD_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ]; then exit 0; fi; guard=""; repo="$(git rev-parse --show-toplevel 2>/dev/null || true)"; if [ -n "$repo" ] && [ -f "$repo/.ai/tools/vcm-bash-guard" ]; then guard="$repo/.ai/tools/vcm-bash-guard"; else cwd="$(pwd -P 2>/dev/null || pwd)"; dir="$cwd"; while [ -n "$dir" ] && [ "$dir" != "/" ]; do if [ -f "$dir/.ai/tools/vcm-bash-guard" ]; then guard="$dir/.ai/tools/vcm-bash-guard"; break; fi; dir="$(dirname "$dir")"; done; if [ -z "$guard" ] && [ -n "\${CLAUDE_PROJECT_DIR:-}" ] && [ -f "\${CLAUDE_PROJECT_DIR}/.ai/tools/vcm-bash-guard" ]; then guard="\${CLAUDE_PROJECT_DIR}/.ai/tools/vcm-bash-guard"; fi; fi; [ -n "$guard" ] || exit 0; python3 "$guard" || exit 0'`;
 const VCM_BASH_DEFAULT_TIMEOUT_MS = "600000";
 const VCM_AUTO_MEMORY_ENABLED = false;
@@ -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/server.js

@@ -12,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";
@@ -42,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";
@@ -57,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";
@@ -90,6 +93,7 @@ export async function createServer(deps, options = {}) {
         gateReviewService: deps.gateReviewService
     });
     registerTranslationWorkerRoutes(app, {
+        appSettings: deps.appSettings,
         projectService: deps.projectService,
         translationWorkerService: deps.translationWorkerService,
         sessionService: deps.sessionService,
@@ -100,6 +104,7 @@ export async function createServer(deps, options = {}) {
         runtimeRecoveryService: deps.runtimeRecoveryService
     });
     registerHarnessRoutes(app, {
+        appSettings: deps.appSettings,
         projectService: deps.projectService,
         harnessService: deps.harnessService,
         harnessFeedbackService: deps.harnessFeedbackService,
@@ -132,7 +137,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,
@@ -155,6 +161,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,
@@ -264,12 +275,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,
@@ -312,6 +329,7 @@ export function createDefaultServerDeps(options = {}) {
         roundService,
         appSettings
     });
+    const usageAnalyticsService = createUsageAnalyticsService({ fs });
     const gatewayChannels = createGatewayChannelRegistry([
         createWeixinIlinkChannel(),
         createLarkChannel()
@@ -331,7 +349,8 @@ export function createDefaultServerDeps(options = {}) {
         translationService,
         roundService,
         projectService,
-        taskWorkflowService
+        taskWorkflowService,
+        architectRestartService
     });
     const gatewayService = createGatewayService({
         fs,
@@ -368,7 +387,8 @@ export function createDefaultServerDeps(options = {}) {
         autoMemoryService,
         gatewayService,
         jobGuard: createJobGuardService(),
-        translationWorkerService
+        translationWorkerService,
+        architectRestartService
     });
     const turnReconciler = createTurnReconcilerService({
         sessionService,
@@ -412,6 +432,7 @@ export function createDefaultServerDeps(options = {}) {
         taskService,
         taskCloseService,
         taskWorkflowService,
+        architectRestartService,
         sessionService,
         artifactService,
         harnessService,
@@ -431,7 +452,8 @@ export function createDefaultServerDeps(options = {}) {
         runtimeRecoveryService,
         terminalInterruptService,
         runtime,
-        diagnosticsService
+        diagnosticsService,
+        usageAnalyticsService
     };
 }
 export function getDefaultStaticDir() {

package/dist/backend/services/app-settings-service.js

@@ -2,7 +2,7 @@ import path from "node:path";
 import { createHash } from "node:crypto";
 import { VCM_ROLE_NAMES } from "../../shared/constants.js";
 import { GATE_REVIEW_GATES } from "../../shared/types/gate-review.js";
-import { createDefaultLaunchTemplate, DEFAULT_TRANSLATION_OUTPUT_MODE, DEFAULT_TRANSLATION_TARGET_LANGUAGE, TRANSLATION_OUTPUT_MODE_OPTIONS, TRANSLATION_TARGET_LANGUAGE_OPTIONS } from "../../shared/types/app-settings.js";
+import { createDefaultLaunchTemplate, createDefaultToolSessionDefaults, DEFAULT_TRANSLATION_OUTPUT_MODE, DEFAULT_TRANSLATION_TARGET_LANGUAGE, TRANSLATION_OUTPUT_MODE_OPTIONS, TRANSLATION_TARGET_LANGUAGE_OPTIONS } from "../../shared/types/app-settings.js";
 import { CLAUDE_MODEL_OPTIONS, CCR_GPT_SESSION_MODEL, SESSION_EFFORT_OPTIONS } from "../../shared/types/session.js";
 import { resolveVcmDataDir } from "../vcm-data-dir.js";
 const MAX_RECENT_REPOSITORIES = 5;
@@ -73,6 +73,21 @@ export function createAppSettingsService(deps) {
             });
             return preferences;
         },
+        async updateToolSessionDefaults(role, input) {
+            const current = await loadSettings();
+            const preferences = normalizePreferences({
+                ...current.preferences,
+                toolSessionDefaults: {
+                    ...current.preferences.toolSessionDefaults,
+                    [role]: input
+                }
+            });
+            await saveSettings({
+                ...current,
+                preferences
+            });
+            return preferences.toolSessionDefaults[role];
+        },
         async getRecentRepositoryPaths() {
             return (await loadSettings()).recentRepositoryPaths;
         },
@@ -274,7 +289,8 @@ function normalizePreferences(input) {
         translationAutoSendEnabled: candidate.translationAutoSendEnabled === true,
         translationTargetLanguage: normalizeTranslationTargetLanguage(candidate.translationTargetLanguage),
         translationOutputMode: normalizeTranslationOutputMode(candidate.translationOutputMode),
-        launchTemplate: normalizeLaunchTemplate(candidate.launchTemplate)
+        launchTemplate: normalizeLaunchTemplate(candidate.launchTemplate),
+        toolSessionDefaults: normalizeToolSessionDefaults(candidate.toolSessionDefaults)
     };
 }
 function normalizeThemeMode(input) {
@@ -313,6 +329,14 @@ function normalizeLaunchTemplate(input) {
         autoOrchestration: input.autoOrchestration !== false
     };
 }
+function normalizeToolSessionDefaults(input) {
+    const defaults = createDefaultToolSessionDefaults();
+    const candidate = isObject(input) ? input : {};
+    return {
+        translator: normalizeRoleLaunchTemplateEntry(candidate.translator, defaults.translator),
+        "harness-engineer": normalizeRoleLaunchTemplateEntry(candidate["harness-engineer"], defaults["harness-engineer"])
+    };
+}
 function normalizeRoleLaunchTemplateEntry(input, fallback) {
     const candidate = isObject(input) ? input : {};
     return {