vibe-coding-master 0.8.13 → 0.9.0

package/README.md

@@ -20,7 +20,8 @@ orchestration, translation, harness setup, and mobile gateway control.
 - Node.js 20 LTS or 22+
 - npm
 - Git
-- Claude Code installed and available as `claude`
+- Claude Code installed and available as `claude` (verified with 2.1.310 or
+  newer; VCM shows a Repository warning when an older release is detected)
 - Claude Code authenticated in the same environment where VCM runs
 
 For Linux containers, make sure common native build/runtime tools are available:
@@ -306,7 +307,10 @@ Codex Bridge child processes use a hard context limit and auto-compaction window
 (about `232560` tokens), leaving headroom before the Codex API limit. Native
 Claude sessions receive no VCM-owned context override. Bridge-backed subagents
 inherit the selected GPT model. Native Architect evidence, scaffold, and
-validation workers use `opus` with `xhigh` effort.
+validation worker model and effort are set under `Architect workers` in the
+Harness panel (defaults: evidence `opus`/`high`, scaffold `sonnet`/`medium`,
+validation `sonnet`/`low`); apply the harness to write a change into the worker
+definitions.
 
 Resume keeps the provider recorded by the existing Session. Use Restart when
 switching between native Claude and Codex Bridge. If the Bridge is disabled,
@@ -464,7 +468,7 @@ Common commands:
 /role
 /role <pm|architect|coder|tester|reviewer>
 /projects
-/use-project <index-or-path>
+/use-project <index-or-listed-path>
 /pull-current
 /tasks
 /use-task <index-or-task-slug>

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

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 // @ts-nocheck
+import { createHash } from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
 import process from "node:process";
@@ -37,6 +38,8 @@ import { renderCheckScaffoldLedgerTool } from "../templates/harness/check-scaffo
 import { renderRequestArchitectRestartTool, renderRestartArchitectSkillRules } from "../templates/harness/restart-architect-skill.js";
 import { renderResolveDurableDocAssignmentTool } from "../templates/harness/resolve-durable-doc-assignment.js";
 import { readVcmPackageVersion } from "../app-version.js";
+import { DEFAULT_ARCHITECT_WORKER_SETTINGS, normalizeArchitectWorkerSettings } from "../../shared/types/app-settings.js";
+import { ARCHITECT_WORKER_AGENT_TYPES, applyArchitectWorkerSetting } from "../templates/harness/architect-worker-frontmatter.js";
 const CLI_DIR = path.dirname(fileURLToPath(import.meta.url));
 const APP_ROOT = path.resolve(CLI_DIR, "../../..");
 const VCM_PACKAGE_VERSION = readVcmPackageVersion(APP_ROOT);
@@ -54,8 +57,8 @@ const LEGACY_CODEX_HARNESS_PATHS = [
 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 --retry 2 --retry-delay 1 --retry-all-errors --connect-timeout 1 --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_SUBAGENT_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-subagent-guard" ]; then guard="$repo/.ai/tools/vcm-subagent-guard"; else cwd="$(pwd -P 2>/dev/null || pwd)"; dir="$cwd"; while [ -n "$dir" ] && [ "$dir" != "/" ]; do if [ -f "$dir/.ai/tools/vcm-subagent-guard" ]; then guard="$dir/.ai/tools/vcm-subagent-guard"; break; fi; dir="$(dirname "$dir")"; done; if [ -z "$guard" ] && [ -n "\${CLAUDE_PROJECT_DIR:-}" ] && [ -f "\${CLAUDE_PROJECT_DIR}/.ai/tools/vcm-subagent-guard" ]; then guard="\${CLAUDE_PROJECT_DIR}/.ai/tools/vcm-subagent-guard"; fi; fi; [ -n "$guard" ] || { printf "%s\\n" "{\\"hookSpecificOutput\\":{\\"hookEventName\\":\\"PreToolUse\\",\\"permissionDecision\\":\\"deny\\",\\"permissionDecisionReason\\":\\"VCM subagent policy is unavailable. Refresh the VCM Harness before invoking subagents.\\"}}"; exit 0; }; python3 "$guard"'`;
+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; node "$guard" || exit 0'`;
+const VCM_SUBAGENT_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-subagent-guard" ]; then guard="$repo/.ai/tools/vcm-subagent-guard"; else cwd="$(pwd -P 2>/dev/null || pwd)"; dir="$cwd"; while [ -n "$dir" ] && [ "$dir" != "/" ]; do if [ -f "$dir/.ai/tools/vcm-subagent-guard" ]; then guard="$dir/.ai/tools/vcm-subagent-guard"; break; fi; dir="$(dirname "$dir")"; done; if [ -z "$guard" ] && [ -n "\${CLAUDE_PROJECT_DIR:-}" ] && [ -f "\${CLAUDE_PROJECT_DIR}/.ai/tools/vcm-subagent-guard" ]; then guard="\${CLAUDE_PROJECT_DIR}/.ai/tools/vcm-subagent-guard"; fi; fi; [ -n "$guard" ] || { printf "%s\\n" "{\\"hookSpecificOutput\\":{\\"hookEventName\\":\\"PreToolUse\\",\\"permissionDecision\\":\\"deny\\",\\"permissionDecisionReason\\":\\"VCM subagent policy is unavailable. Refresh the VCM Harness before invoking subagents.\\"}}"; exit 0; }; node "$guard"'`;
 const VCM_BASH_DEFAULT_TIMEOUT_MS = "600000";
 const VCM_AUTO_MEMORY_ENABLED = false;
 const VCM_FAST_HOOK_COMMAND = VCM_HOOK_COMMAND.replace(" --retry 2 --retry-delay 1 --retry-all-errors --connect-timeout 1", "");
@@ -104,20 +107,14 @@ const AGENT_FRONTMATTER = {
     },
     "vcm-architect-evidence-worker": {
         description: "Foreground Architect worker for bounded project evidence collection.",
-        tools: "Read, Grep, Glob, Write",
-        model: "opus",
-        effort: "xhigh"
+        tools: "Read, Grep, Glob, Write"
     },
     "vcm-architect-scaffold-worker": {
-        description: "Foreground Architect worker for exact scaffold execution and scaffold validation.",
-        model: "opus",
-        effort: "xhigh"
+        description: "Foreground Architect worker for exact scaffold execution and scaffold validation."
     },
     "vcm-architect-validation-worker": {
         description: "Foreground Architect worker for exact assigned command execution and evidence capture.",
-        tools: "Read, Grep, Glob, Bash, Write",
-        model: "opus",
-        effort: "xhigh"
+        tools: "Read, Grep, Glob, Bash, Write"
     }
 };
 const REQUIRED_AGENT_DISALLOWED_TOOLS = {
@@ -289,21 +286,40 @@ const DURABLE_DOC_TEMPLATES = [
         content: "# Testing\n"
     },
 ];
+// upgradeableSha256 lists earlier VCM-shipped versions of a project-owned file;
+// an unmodified copy of one of them is upgraded instead of kept.
 const PROJECT_OWNED_FILES = [
     {
         path: ".ai/tools/generate-module-index",
         category: "generated-context-tool",
         mode: 0o755,
-        templatePath: "scripts/harness-tools/generate-module-index"
+        templatePath: "scripts/harness-tools/generate-module-index",
+        upgradeableSha256: [
+            "432fc89448bd26c9504b4bfee93ae2306d0cf01e8f00a946189c3c8148f615f7",
+            "96f5763d107e6d95cb605bb5b949e4c40b0715ba3e5bacd9554dfb7f98c332f3",
+            "06b9fcc6da0635f6a53a72f68e0ec1934b1bc4037df386e93d8190004c21b1bb",
+            "711753b3e4c9afa3198e0ae150d8b686dcb0b1110e4208c60686dcac249c5b6e"
+        ]
     },
     {
         path: ".ai/tools/generate-public-surface",
         category: "generated-context-tool",
         mode: 0o755,
-        templatePath: "scripts/harness-tools/generate-public-surface"
+        templatePath: "scripts/harness-tools/generate-public-surface",
+        upgradeableSha256: [
+            "08eb2f5a8df6e5db0bc7385f23f19a572ff586124623a985588842a77ce6ffa3",
+            "a4b177f780335962cfccab8de3254456351f9a97ff308d238b5725c7dcb5105e",
+            "f8d3a49b0b055302bc9f780b869fe9e8e04b67decdce79b92d0b62b1d911a15e"
+        ]
     }
 ];
 const WHOLE_FILES = [
+    {
+        path: ".ai/tools/package.json",
+        category: "runtime-tool",
+        mode: 0o644,
+        templatePath: "scripts/harness-tools/package.json"
+    },
     {
         path: ".ai/tools/check-durable-docs",
         category: "durable-docs-tool",
@@ -489,7 +505,7 @@ async function main() {
     await migrateReviewerAgent({ projectRoot, dryRun, operations });
     const manifest = await buildManifest(projectRoot);
     for (const definition of MANAGED_FILES) {
-        await installManagedFile({ projectRoot, definition, dryRun, operations });
+        await installManagedFile({ projectRoot, definition, dryRun, operations, workerSettings: args.architectWorkers });
     }
     for (const template of DURABLE_DOC_TEMPLATES) {
         await installDurableDocTemplate({ projectRoot, template, dryRun, operations });
@@ -545,7 +561,8 @@ function parseArgs(argv) {
     const args = {
         dryRun: false,
         help: false,
-        projectRoot: undefined
+        projectRoot: undefined,
+        architectWorkers: DEFAULT_ARCHITECT_WORKER_SETTINGS
     };
     for (let index = 0; index < argv.length; index += 1) {
         const arg = argv[index];
@@ -557,6 +574,20 @@ function parseArgs(argv) {
             args.dryRun = true;
             continue;
         }
+        if (arg === "--architect-workers") {
+            const value = argv[index + 1];
+            if (!value) {
+                fail("--architect-workers requires a JSON object.");
+            }
+            try {
+                args.architectWorkers = normalizeArchitectWorkerSettings(JSON.parse(value));
+            }
+            catch {
+                fail("--architect-workers must be valid JSON.");
+            }
+            index += 1;
+            continue;
+        }
         if (arg.startsWith("--")) {
             fail(`Unknown option: ${arg}`);
         }
@@ -571,6 +602,7 @@ function printUsage() {
     console.log(`Usage:
   node scripts/install-vcm-harness.mjs <project-root>
   node scripts/install-vcm-harness.mjs <project-root> --dry-run
+  node scripts/install-vcm-harness.mjs <project-root> --architect-workers '<json>'
 
 Installs only fixed VCM harness content.
 
@@ -740,7 +772,7 @@ async function installManifest({ projectRoot, manifest, dryRun, operations, forc
         action: "write fixed harness manifest"
     });
 }
-async function installManagedFile({ projectRoot, definition, dryRun, operations }) {
+async function installManagedFile({ projectRoot, definition, dryRun, operations, workerSettings = DEFAULT_ARCHITECT_WORKER_SETTINGS }) {
     const targetPath = resolveInside(projectRoot, definition.path);
     const block = renderManagedBlock(definition);
     const currentContent = await readOptionalText(targetPath);
@@ -774,6 +806,10 @@ async function installManagedFile({ projectRoot, definition, dryRun, operations
     for (const removedSkill of REMOVED_AGENT_SKILLS[definition.agentName] ?? []) {
         nextContent = removeAgentSkill(nextContent, removedSkill);
     }
+    const workerType = ARCHITECT_WORKER_AGENT_TYPES[definition.agentName];
+    if (workerType) {
+        nextContent = applyArchitectWorkerSetting(nextContent, workerSettings[workerType]);
+    }
     await writeIfChanged({
         targetPath,
         relativePath: definition.path,
@@ -1029,7 +1065,10 @@ async function installWholeFile({ projectRoot, file, dryRun, operations }) {
 }
 async function installProjectOwnedFile({ projectRoot, file, dryRun, operations }) {
     const targetPath = resolveInside(projectRoot, file.path);
-    if (await pathExists(targetPath)) {
+    const currentContent = await readOptionalText(targetPath);
+    const upgradeable = currentContent !== undefined
+        && (file.upgradeableSha256 ?? []).includes(createHash("sha256").update(currentContent).digest("hex"));
+    if (currentContent !== undefined && !upgradeable) {
         operations.push(skip(file.path, "exists; project-owned"));
         return;
     }
@@ -1041,7 +1080,7 @@ async function installProjectOwnedFile({ projectRoot, file, dryRun, operations }
         mode: file.mode,
         dryRun,
         operations,
-        action: "seed project-owned VCM file"
+        action: upgradeable ? "upgrade unmodified project-owned VCM file" : "seed project-owned VCM file"
     });
 }
 async function removeLegacyFlatSkillFiles({ projectRoot, dryRun, operations }) {

package/dist/backend/gateway/gateway-service.js

@@ -451,14 +451,16 @@ export function createGatewayService(deps) {
     async function useProject(selector) {
         const options = await listProjectOptions();
         const index = Number.parseInt(selector, 10);
+        // Gateway senders may select only projects already connected on the desktop.
         const repoPath = Number.isFinite(index) && String(index) === selector.trim()
             ? options[index - 1]
-            : selector.trim();
+            : options.find((option) => option === selector.trim());
         if (!repoPath) {
             throw new VcmError({
                 code: "PROJECT_SELECTION_INVALID",
                 message: `Project not found: ${selector}`,
-                statusCode: 404
+                statusCode: 404,
+                hint: "Use /projects and select a listed project. Connect new repositories from the desktop app."
             });
         }
         const project = await deps.projectService.connectProject({ repoPath });
@@ -1563,7 +1565,7 @@ function helpText(enabled) {
         "/role",
         "/role <pm|architect|coder|tester|reviewer>",
         "/projects",
-        "/use-project <index-or-path>",
+        "/use-project <index-or-listed-path>",
         "/pull-current",
         "/tasks",
         "/use-task <index-or-task-slug>",

package/dist/backend/runtime/terminal-submit.js

@@ -4,6 +4,7 @@ const DEFAULT_ENTER_DELAY_MS = 75;
 export async function submitTerminalInput(runtime, sessionId, text, options = {}) {
     runtime.write(sessionId, formatTerminalPaste(text));
     await delay(options.enterDelayMs ?? DEFAULT_ENTER_DELAY_MS);
+    await options.beforeSubmit?.();
     runtime.write(sessionId, "\r");
 }
 export function formatTerminalPaste(text) {

package/dist/backend/server.js

@@ -8,6 +8,7 @@ import { createCodexBridgeAdapter } from "./adapters/codex-bridge-adapter.js";
 import { createCommandRunner } from "./adapters/command-runner.js";
 import { createCommandDispatcher } from "./services/command-dispatcher.js";
 import { createClaudeHookService } from "./services/claude-hook-service.js";
+import { createClaudeVersionCheck } from "./services/claude-version-check.js";
 import { createGitAdapter } from "./adapters/git-adapter.js";
 import { createAppSettingsService } from "./services/app-settings-service.js";
 import { createCodexBridgeIntegrationService } from "./services/codex-bridge-integration-service.js";
@@ -248,7 +249,12 @@ export function createDefaultServerDeps(options = {}) {
         workflowControlService,
         getDurableDocAssignment: (taskRepoRoot, role) => autoMemoryService.getDurableDocAssignment(taskRepoRoot, role)
     });
-    const projectService = createProjectService({ fs, git, appSettings });
+    const projectService = createProjectService({
+        fs,
+        git,
+        appSettings,
+        claudeVersionCheck: createClaudeVersionCheck(claude)
+    });
     const taskService = createTaskService({ fs, git, artifactService, projectService });
     const taskWorkflowService = createTaskWorkflowService({ fs });
     const codeIntelligenceDetector = createHarnessCodeIntelligenceDetector(fs, { runner });
@@ -272,6 +278,7 @@ export function createDefaultServerDeps(options = {}) {
         runtime,
         harnessEngineerSessions: sessionService,
         runFixedInstaller: createScriptFixedHarnessInstaller(path.join(appRoot, "scripts/install-vcm-harness.mjs")),
+        getArchitectWorkerSettings: async () => (await appSettings.getPreferences()).architectWorkerSettings,
         vcmVersion
     });
     const autoMemoryService = createAutoMemoryService({
@@ -388,7 +395,8 @@ export function createDefaultServerDeps(options = {}) {
         projectService,
         taskWorkflowService,
         architectRestartService,
-        roleContextRestartService
+        roleContextRestartService,
+        gateReviewService
     });
     const gatewayService = createGatewayService({
         fs,
@@ -432,7 +440,8 @@ export function createDefaultServerDeps(options = {}) {
         translationWorkerService,
         architectRestartService,
         roleContextRestartService,
-        workflowControlService
+        workflowControlService,
+        gateReviewService
     });
     const runtimeCoordinator = createRuntimeCoordinatorService({
         appSettings,
@@ -461,7 +470,8 @@ export function createDefaultServerDeps(options = {}) {
         projectService,
         taskService,
         sessionService,
-        roundService
+        roundService,
+        gateReviewService
     });
     const diagnosticsService = createDiagnosticsService({
         appRoot,

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, createDefaultToolSessionDefaults, 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, normalizeArchitectWorkerSettings, DEFAULT_TRANSLATION_TARGET_LANGUAGE, TRANSLATION_OUTPUT_MODE_OPTIONS, TRANSLATION_TARGET_LANGUAGE_OPTIONS } from "../../shared/types/app-settings.js";
 import { CLAUDE_MODEL_OPTIONS, isCodexBridgeSessionModel, SESSION_EFFORT_OPTIONS } from "../../shared/types/session.js";
 import { resolveVcmDataDir } from "../vcm-data-dir.js";
 const MAX_RECENT_REPOSITORIES = 5;
@@ -290,7 +290,8 @@ function normalizePreferences(input) {
         translationTargetLanguage: normalizeTranslationTargetLanguage(candidate.translationTargetLanguage),
         translationOutputMode: normalizeTranslationOutputMode(candidate.translationOutputMode),
         launchTemplate: normalizeLaunchTemplate(candidate.launchTemplate),
-        toolSessionDefaults: normalizeToolSessionDefaults(candidate.toolSessionDefaults)
+        toolSessionDefaults: normalizeToolSessionDefaults(candidate.toolSessionDefaults),
+        architectWorkerSettings: normalizeArchitectWorkerSettings(candidate.architectWorkerSettings)
     };
 }
 function normalizeThemeMode(input) {

package/dist/backend/services/auto-memory-service.js

@@ -855,11 +855,12 @@ export function createAutoMemoryService(deps) {
         if (existing?.status === "running" && deps.runtime.getSession(existing.id)) {
             return existing;
         }
-        const preferences = await deps.appSettings.getPreferences();
-        const options = preferences.launchTemplate.roles[role];
         if (existing?.claudeSessionId) {
-            return deps.sessionService.resumeRoleSession(baseRepoRoot, taskSlug, role, options);
+            // Resume keeps the launch options recorded by the saved Session.
+            return deps.sessionService.resumeRoleSession(baseRepoRoot, taskSlug, role);
         }
+        const preferences = await deps.appSettings.getPreferences();
+        const options = preferences.launchTemplate.roles[role];
         return deps.sessionService.startRoleSession(baseRepoRoot, taskSlug, role, options);
     }
     async function snapshotArchitectPlanningCandidate(taskRepoRoot, runId) {

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

@@ -225,6 +225,9 @@ export function createClaudeHookService(deps) {
                 await deps.workflowControlService.resolveUserInput(createWorkflowControlContext(context));
             }
         }
+        if (isReviewerRoleName(input.role)) {
+            deps.gateReviewService?.recordReviewerPromptSubmitted(context.taskSlug, prompt);
+        }
         const session = await deps.sessionService.recordClaudeHookEvent(context.project.repoRoot, {
             taskSlug: context.taskSlug,
             role: input.role,
@@ -508,6 +511,9 @@ export function createClaudeHookService(deps) {
         if (!session) {
             return completedHookResult(input, eventName);
         }
+        if (isReviewerRoleName(input.role)) {
+            deps.gateReviewService?.recordReviewerTurnEnded(context.taskSlug, "turn-end");
+        }
         const boundToTask = await isHookSessionBoundToTask(context, input.role);
         if (boundToTask) {
             await deps.roundService.recordClaudeHookEvent({

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

@@ -210,10 +210,8 @@ export function resolveExistingClaudeTranscriptPath(session) {
     if (sessionPath) {
         return sessionPath;
     }
-    const cwdPath = existingFile(claudeTranscriptPath(session.cwd, session.claudeSessionId, session.claudeConfigDir));
-    if (cwdPath) {
-        return cwdPath;
-    }
+    // Without a hook-reported path, locate the transcript by session id instead of
+    // reproducing Claude Code's undocumented project-directory encoding.
     return findClaudeTranscriptPathBySessionId(session.claudeSessionId, session.claudeConfigDir);
 }
 function transcriptPathMatchesSession(transcriptPath, claudeSessionId) {
@@ -263,15 +261,6 @@ function existingFile(candidate) {
 export function claudeProjectsRoot(configDir) {
     return join(configDir ?? join(homedir(), ".claude"), "projects");
 }
-export function projectHash(projectDir) {
-    return projectDir.replace(/[\/\s]+/g, "-");
-}
-export function projectsTranscriptDir(projectDir, configDir) {
-    return join(claudeProjectsRoot(configDir), projectHash(projectDir));
-}
-export function claudeTranscriptPath(projectDir, claudeSessionId, configDir) {
-    return join(projectsTranscriptDir(projectDir, configDir), `${claudeSessionId}.jsonl`);
-}
 export function parseAssistantContent(line) {
     let obj;
     try {

package/dist/backend/services/claude-version-check.js

@@ -0,0 +1,46 @@
+// The oldest Claude Code release VCM has been verified against. Raise it after
+// verifying a newer release; older releases may lack hooks or flags VCM uses.
+export const MIN_CLAUDE_CODE_VERSION = "2.1.310";
+const VERSION_CACHE_TTL_MS = 10 * 60 * 1000;
+export function createClaudeVersionCheck(claude, now = Date.now) {
+    const cache = new Map();
+    return {
+        async getWarning(command, options = {}) {
+            const cached = cache.get(command);
+            if (cached && !options.refresh && now() - cached.checkedAt < VERSION_CACHE_TTL_MS) {
+                return cached.warning;
+            }
+            const warning = await probe(command);
+            cache.set(command, { warning, checkedAt: now() });
+            return warning;
+        }
+    };
+    async function probe(command) {
+        let output;
+        try {
+            output = await claude.getVersion(command);
+        }
+        catch (error) {
+            return `Claude Code version could not be checked: ${error instanceof Error ? error.message : String(error)}`;
+        }
+        const version = parseClaudeCodeVersion(output);
+        if (!version) {
+            return `Claude Code version could not be parsed from "${output}". VCM is verified with ${MIN_CLAUDE_CODE_VERSION} or newer.`;
+        }
+        return compareVersions(version, parseClaudeCodeVersion(MIN_CLAUDE_CODE_VERSION)) < 0
+            ? `Claude Code ${version.join(".")} is older than the minimum verified version ${MIN_CLAUDE_CODE_VERSION}. Upgrade Claude Code; older releases may lack hooks or flags VCM relies on.`
+            : undefined;
+    }
+}
+export function parseClaudeCodeVersion(output) {
+    const match = /(\d+)\.(\d+)\.(\d+)/.exec(output);
+    return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : undefined;
+}
+function compareVersions(left, right) {
+    for (let index = 0; index < 3; index += 1) {
+        if (left[index] !== right[index]) {
+            return left[index] - right[index];
+        }
+    }
+    return 0;
+}

package/dist/backend/services/gate-review-service.js

@@ -496,7 +496,8 @@ export function createGateReviewService(deps) {
             return;
         }
         const controller = new AbortController();
-        activeRuns.set(runKey, controller);
+        const run = { controller, taskSlug: context.taskSlug, requestId, promptAccepted: false };
+        activeRuns.set(runKey, run);
         try {
             const timestamp = now();
             if (!(await markGateRunStarted(context, gate, requestId, timestamp))) {
@@ -530,7 +531,7 @@ export function createGateReviewService(deps) {
                 role: REVIEWER_ROLE,
                 eventName: "UserPromptSubmit"
             });
-            const parsed = await waitForGateReport(deps.fs, context.taskRepoRoot, gate, requestId, now(), reportPollIntervalMs, controller.signal);
+            const parsed = await waitForGateReport(deps.fs, context.taskRepoRoot, gate, requestId, now(), reportPollIntervalMs, controller.signal, () => run.reviewerEnded);
             const completedRecord = await completeGateRun(context, gate, requestId, parsed);
             if (!completedRecord) {
                 return;
@@ -551,7 +552,7 @@ export function createGateReviewService(deps) {
             await callbackProjectManager(context, gate, "failed", undefined, reportPathForRequest(requestId), message, requestId, failedRecord.inputHash);
         }
         finally {
-            if (activeRuns.get(runKey) === controller) {
+            if (activeRuns.get(runKey) === run) {
                 activeRuns.delete(runKey);
             }
         }
@@ -644,20 +645,21 @@ export function createGateReviewService(deps) {
         }
         if (existing?.claudeSessionId) {
             try {
+                // Resume keeps the launch options recorded by the saved Reviewer Session.
                 return await deps.sessionService.resumeRoleSession(context.repoRoot, context.taskSlug, REVIEWER_ROLE, {
                     cols: 100,
-                    rows: 28,
-                    model: "default"
+                    rows: 28
                 });
             }
             catch {
                 // Fall through to a fresh Reviewer terminal if the saved session cannot be resumed.
             }
         }
+        const template = (await deps.appSettings.getPreferences?.())?.launchTemplate.roles[REVIEWER_ROLE];
         return deps.sessionService.startRoleSession(context.repoRoot, context.taskSlug, REVIEWER_ROLE, {
             cols: 100,
             rows: 28,
-            model: "default"
+            ...template
         });
     }
     async function callbackProjectManager(context, gate, status, decision, reportPath, error, requestId, inputHash) {
@@ -818,7 +820,7 @@ export function createGateReviewService(deps) {
                         hint: "Refresh Gate Review state before cancelling the current request."
                     });
                 }
-                activeRuns.get(gateRunKey(context, gate, input.requestId))?.abort();
+                activeRuns.get(gateRunKey(context, gate, input.requestId))?.controller.abort();
                 await deps.sessionService.restartRoleSession(context.repoRoot, context.taskSlug, REVIEWER_ROLE);
                 await updateRequestStatus(deps.fs, context, input.requestId, "cancelled", {
                     completedAt: timestamp,
@@ -925,9 +927,36 @@ export function createGateReviewService(deps) {
         async readReport(repoRoot, taskSlug, gate) {
             const context = await getContext(repoRoot, taskSlug);
             return parseGateReport(deps.fs, context.taskRepoRoot, gate, undefined, now(), reportPathForGate(gate));
+        },
+        recordReviewerPromptSubmitted(taskSlug, prompt) {
+            for (const run of activeRunsForTask(taskSlug)) {
+                if (prompt?.includes(run.requestId)) {
+                    run.promptAccepted = true;
+                }
+            }
+        },
+        recordReviewerTurnEnded(taskSlug, reason) {
+            for (const run of activeRunsForTask(taskSlug)) {
+                // A turn end only counts once the Reviewer accepted this request's prompt,
+                // so a late Stop from an earlier turn cannot fail a newer request.
+                if (reason === "process-exit") {
+                    run.reviewerEnded = "Reviewer process exited before completing the review.";
+                }
+                else if (run.promptAccepted) {
+                    run.reviewerEnded = "Reviewer ended its turn without submitting the report.";
+                }
+            }
+        },
+        stopTask(taskSlug) {
+            for (const run of activeRunsForTask(taskSlug)) {
+                run.controller.abort();
+            }
         }
     };
 }
+function activeRunsForTask(taskSlug) {
+    return [...activeRuns.values()].filter((run) => run.taskSlug === taskSlug);
+}
 export function isGateReviewGate(value) {
     return GATE_REVIEW_GATES.includes(value);
 }
@@ -1529,10 +1558,13 @@ function isTaskEvidencePath(sourcePath) {
     return sourcePath.startsWith(".ai/vcm/handoffs/")
         || sourcePath.startsWith(".ai/vcm/gate-reviews/");
 }
-async function waitForGateReport(fs, taskRepoRoot, gate, requestId, timestamp, intervalMs, signal) {
+async function waitForGateReport(fs, taskRepoRoot, gate, requestId, timestamp, intervalMs, signal, reviewerEnded) {
     const reportPath = reportPathForRequest(requestId);
     while (true) {
         throwIfGateRunCancelled(signal);
+        // Read the end signal before the report so a report written just before the
+        // Reviewer stopped is still accepted.
+        const ended = reviewerEnded();
         try {
             return await parseGateReport(fs, taskRepoRoot, gate, requestId, timestamp, reportPath);
         }
@@ -1540,6 +1572,13 @@ async function waitForGateReport(fs, taskRepoRoot, gate, requestId, timestamp, i
             if (!isPendingReportError(error)) {
                 throw error;
             }
+            if (ended) {
+                throw new VcmError({
+                    code: "GATE_REVIEW_REPORT_NOT_WRITTEN",
+                    message: `${ended} Gate review report was not written: ${reportPath}`,
+                    statusCode: 500
+                });
+            }
         }
         await delay(intervalMs);
     }