vibe-coding-master 0.8.13 → 0.9.1

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/adapters/claude-adapter.js

@@ -8,7 +8,8 @@ export function createClaudeAdapter(runner) {
             return result.exitCode === 0;
         },
         async getVersion(command = "claude") {
-            const result = await runner.run(command, ["--version"]);
+            // Bounded so a stalled CLI cannot leave a probe process behind.
+            const result = await runner.run(command, ["--version"], { timeoutMs: 10_000 });
             if (result.exitCode !== 0) {
                 throw new VcmError({
                     code: "CLAUDE_UNAVAILABLE",

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";
@@ -36,7 +37,10 @@ import { renderVcmWorkflowReviewSkillRules } from "../templates/harness/vcm-work
 import { renderCheckScaffoldLedgerTool } from "../templates/harness/check-scaffold-ledger.js";
 import { renderRequestArchitectRestartTool, renderRestartArchitectSkillRules } from "../templates/harness/restart-architect-skill.js";
 import { renderResolveDurableDocAssignmentTool } from "../templates/harness/resolve-durable-doc-assignment.js";
+import { PROJECT_OWNED_SHIPPED_SHA256 } from "../templates/harness/project-owned-history.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 +58,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 +108,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,6 +287,8 @@ const DURABLE_DOC_TEMPLATES = [
         content: "# Testing\n"
     },
 ];
+// An installed copy that still matches a VCM-shipped version is upgraded
+// instead of kept as project-modified.
 const PROJECT_OWNED_FILES = [
     {
         path: ".ai/tools/generate-module-index",
@@ -304,6 +304,15 @@ const PROJECT_OWNED_FILES = [
     }
 ];
 const WHOLE_FILES = [
+    {
+        // Makes the extensionless tools load as CommonJS inside ESM projects. A
+        // project's own package.json here is kept rather than replaced.
+        path: ".ai/tools/package.json",
+        category: "runtime-tool",
+        mode: 0o644,
+        templatePath: "scripts/harness-tools/package.json",
+        preserveExisting: true
+    },
     {
         path: ".ai/tools/check-durable-docs",
         category: "durable-docs-tool",
@@ -489,7 +498,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 +554,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 +567,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 +595,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 +765,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 +799,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,
@@ -1017,6 +1046,15 @@ async function ensureDirectory({ projectRoot, relativePath, dryRun, operations }
 }
 async function installWholeFile({ projectRoot, file, dryRun, operations }) {
     const content = await wholeFileContent(file);
+    if (file.preserveExisting) {
+        const currentContent = await readOptionalText(resolveInside(projectRoot, file.path));
+        if (currentContent !== undefined && currentContent !== ensureTrailingNewline(content)) {
+            operations.push(skip(file.path, isCommonJsPackage(currentContent)
+                ? "exists; project-owned"
+                : "exists; project-owned, but harness tools need \"type\": \"commonjs\" here"));
+            return;
+        }
+    }
     await writeIfChanged({
         targetPath: resolveInside(projectRoot, file.path),
         relativePath: file.path,
@@ -1029,7 +1067,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
+        && (PROJECT_OWNED_SHIPPED_SHA256[file.path] ?? []).includes(createHash("sha256").update(currentContent).digest("hex"));
+    if (currentContent !== undefined && !upgradeable) {
         operations.push(skip(file.path, "exists; project-owned"));
         return;
     }
@@ -1041,7 +1082,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 }) {
@@ -1085,6 +1126,15 @@ async function removeLegacyCodexHarnessPaths({ projectRoot, dryRun, operations }
         operations.push(done(relativePath, "deleted legacy Codex harness path"));
     }
 }
+function isCommonJsPackage(content) {
+    try {
+        const parsed = JSON.parse(content);
+        return parsed?.type === undefined || parsed.type === "commonjs";
+    }
+    catch {
+        return false;
+    }
+}
 function stripSkillFrontmatter(content) {
     return content.replace(/^---\n[\s\S]*?\n---\n\n/, "");
 }

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,87 @@
+// 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;
+// A failed probe is retried sooner so a fixed installation clears the warning.
+const FAILED_PROBE_TTL_MS = 30 * 1000;
+export const VERSION_PROBE_TIMEOUT_MS = 10 * 1000;
+export function createClaudeVersionCheck(claude, now = Date.now, timeoutMs = VERSION_PROBE_TIMEOUT_MS) {
+    const cache = new Map();
+    const inFlight = new Map();
+    return {
+        async getWarning(command, options = {}) {
+            const cached = cache.get(command);
+            if (!cached || options.refresh) {
+                return probeOnce(command);
+            }
+            const ttl = cached.failed ? FAILED_PROBE_TTL_MS : VERSION_CACHE_TTL_MS;
+            if (now() - cached.checkedAt >= ttl) {
+                void probeOnce(command);
+            }
+            return cached.warning;
+        }
+    };
+    // Concurrent callers share one probe per command.
+    function probeOnce(command) {
+        const running = inFlight.get(command);
+        if (running) {
+            return running;
+        }
+        const probe = (async () => {
+            try {
+                const result = await probeVersion(command);
+                cache.set(command, { ...result, checkedAt: now() });
+                return result.warning;
+            }
+            finally {
+                inFlight.delete(command);
+            }
+        })();
+        inFlight.set(command, probe);
+        return probe;
+    }
+    async function probeVersion(command) {
+        let output;
+        try {
+            output = await withTimeout(claude.getVersion(command), timeoutMs);
+        }
+        catch (error) {
+            return {
+                warning: `Claude Code version could not be checked: ${error instanceof Error ? error.message : String(error)}`,
+                failed: true
+            };
+        }
+        const version = parseClaudeCodeVersion(output);
+        if (!version) {
+            return {
+                warning: `Claude Code version could not be parsed from "${output}". VCM is verified with ${MIN_CLAUDE_CODE_VERSION} or newer.`,
+                failed: true
+            };
+        }
+        return {
+            warning: 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,
+            failed: false
+        };
+    }
+}
+function withTimeout(promise, timeoutMs) {
+    let timer;
+    const timeout = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new Error(`claude --version did not respond within ${timeoutMs}ms`)), timeoutMs);
+    });
+    return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+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, gateTurnActive: 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,35 @@ 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)) {
+                run.gateTurnActive = Boolean(prompt?.includes(run.requestId));
+            }
+        },
+        recordReviewerTurnEnded(taskSlug, reason) {
+            for (const run of activeRunsForTask(taskSlug)) {
+                // Only the end of the turn that ran this request's prompt counts: a late
+                // Stop from an earlier turn, or a turn the user started in the Reviewer
+                // terminal, must not fail the review.
+                if (reason === "process-exit") {
+                    run.reviewerEnded = "Reviewer process exited before completing the review.";
+                }
+                else if (run.gateTurnActive) {
+                    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 +1557,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 +1571,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);
     }