vibe-coding-master 0.8.13 → 0.9.1

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

@@ -1,6 +1,8 @@
 import { execFile } from "node:child_process";
 import path from "node:path";
 import { promisify } from "node:util";
+import { DEFAULT_ARCHITECT_WORKER_SETTINGS, normalizeArchitectWorkerSettings } from "../../shared/types/app-settings.js";
+import { applyArchitectWorkerSetting } from "../templates/harness/architect-worker-frontmatter.js";
 import { renderArchitectHarnessRules } from "../templates/harness/architect-agent.js";
 import { CODE_ROLE_DISALLOWED_TOOLS, REVIEWER_DISALLOWED_TOOLS } from "../role-tool-policy.js";
 import { renderCoderHarnessRules } from "../templates/harness/coder-agent.js";
@@ -55,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", "");
@@ -256,21 +258,24 @@ const HARNESS_FILES = [
         kind: "agent-architect-evidence-worker",
         path: ".claude/agents/vcm-architect-evidence-worker.md",
         title: "VCM Architect Evidence Worker Agent",
-        frontmatter: renderAgentFrontmatter("vcm-architect-evidence-worker", "Foreground Architect worker for bounded project evidence collection.", { tools: "Read, Grep, Glob, Write", model: "opus", effort: "xhigh" }),
+        frontmatter: renderAgentFrontmatter("vcm-architect-evidence-worker", "Foreground Architect worker for bounded project evidence collection.", { tools: "Read, Grep, Glob, Write" }),
+        architectWorkerType: "evidence",
         renderRules: renderArchitectEvidenceWorkerHarnessRules
     },
     {
         kind: "agent-architect-scaffold-worker",
         path: ".claude/agents/vcm-architect-scaffold-worker.md",
         title: "VCM Architect Scaffold Worker Agent",
-        frontmatter: renderAgentFrontmatter("vcm-architect-scaffold-worker", "Foreground Architect worker for exact scaffold execution and scaffold validation.", { model: "opus", effort: "xhigh" }),
+        frontmatter: renderAgentFrontmatter("vcm-architect-scaffold-worker", "Foreground Architect worker for exact scaffold execution and scaffold validation."),
+        architectWorkerType: "scaffold",
         renderRules: renderArchitectScaffoldWorkerHarnessRules
     },
     {
         kind: "agent-architect-validation-worker",
         path: ".claude/agents/vcm-architect-validation-worker.md",
         title: "VCM Architect Validation Worker Agent",
-        frontmatter: renderAgentFrontmatter("vcm-architect-validation-worker", "Foreground Architect worker for exact assigned command execution and evidence capture.", { tools: "Read, Grep, Glob, Bash, Write", model: "opus", effort: "xhigh" }),
+        frontmatter: renderAgentFrontmatter("vcm-architect-validation-worker", "Foreground Architect worker for exact assigned command execution and evidence capture.", { tools: "Read, Grep, Glob, Bash, Write" }),
+        architectWorkerType: "validation",
         renderRules: renderArchitectValidationWorkerHarnessRules
     },
     {
@@ -358,13 +363,18 @@ const HARNESS_FILES = [
 export function createHarnessService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     const vcmVersion = deps.vcmVersion ?? "unknown";
+    async function resolveArchitectWorkerSettings() {
+        return deps.getArchitectWorkerSettings
+            ? normalizeArchitectWorkerSettings(await deps.getArchitectWorkerSettings())
+            : DEFAULT_ARCHITECT_WORKER_SETTINGS;
+    }
     const codeIntelligenceDetector = createHarnessCodeIntelligenceDetector(deps.fs, {
         runner: deps.commandRunner
     });
     return {
         async getHarnessStatus(repoRoot) {
             const [analyses, codeIntelligence] = await Promise.all([
-                analyzeHarnessFiles(deps.fs, repoRoot),
+                analyzeHarnessFiles(deps.fs, repoRoot, await resolveArchitectWorkerSettings()),
                 codeIntelligenceDetector.detect(repoRoot)
             ]);
             const legacyChanges = await analyzeLegacyCodexHarnessPaths(deps.fs, repoRoot);
@@ -401,7 +411,7 @@ export function createHarnessService(deps) {
             }
             const file = await readHarnessFileContent(deps.fs, repoRoot, definition.path);
             const [analyses, codeIntelligence] = await Promise.all([
-                analyzeHarnessFiles(deps.fs, repoRoot),
+                analyzeHarnessFiles(deps.fs, repoRoot, await resolveArchitectWorkerSettings()),
                 codeIntelligenceDetector.detect(repoRoot)
             ]);
             const legacyChanges = await analyzeLegacyCodexHarnessPaths(deps.fs, repoRoot);
@@ -417,7 +427,9 @@ export function createHarnessService(deps) {
         async applyHarness(repoRoot) {
             await assertHarnessWorktreeClean(deps.git, repoRoot);
             if (deps.runFixedInstaller) {
-                const result = await deps.runFixedInstaller(repoRoot);
+                const result = await deps.runFixedInstaller(repoRoot, {
+                    architectWorkers: await resolveArchitectWorkerSettings()
+                });
                 if (result.changedFiles.length > 0) {
                     await bumpHarnessRevision(deps.fs, repoRoot, now());
                 }
@@ -429,7 +441,7 @@ export function createHarnessService(deps) {
                     message: formatHarnessApplyMessage(committed.harnessCommit, result.changedFiles.length > 0)
                 };
             }
-            const analyses = await analyzeHarnessFiles(deps.fs, repoRoot);
+            const analyses = await analyzeHarnessFiles(deps.fs, repoRoot, await resolveArchitectWorkerSettings());
             const changedFiles = [];
             for (const analysis of analyses) {
                 if (analysis.status.action === "ok" || !analysis.nextContent) {
@@ -1191,15 +1203,15 @@ function extractManagedBlock(definition, content) {
     }
     return content.match(getManagedBlockPattern(definition))?.[0];
 }
-async function analyzeHarnessFiles(fs, repoRoot) {
+async function analyzeHarnessFiles(fs, repoRoot, workerSettings = DEFAULT_ARCHITECT_WORKER_SETTINGS) {
     const analyses = [];
     for (const definition of HARNESS_FILES) {
-        analyses.push(await analyzeHarnessFile(fs, repoRoot, definition));
+        analyses.push(await analyzeHarnessFile(fs, repoRoot, definition, workerSettings));
     }
     analyses.push(await analyzeClaudeSettingsFile(fs, repoRoot));
     return analyses;
 }
-async function analyzeHarnessFile(fs, repoRoot, definition) {
+async function analyzeHarnessFile(fs, repoRoot, definition, workerSettings) {
     const absolutePath = resolveHarnessPath(repoRoot, definition.path);
     if (definition.ownership === "project-file") {
         const exists = await fs.pathExists(absolutePath);
@@ -1233,7 +1245,7 @@ async function analyzeHarnessFile(fs, repoRoot, definition) {
         : getManagedBlockPattern(definition);
     const exists = await fs.pathExists(absolutePath);
     if (!exists) {
-        const newContent = expectedContent ?? renderNewHarnessFile(definition, expectedBlock ?? "");
+        const newContent = expectedContent ?? applyWorkerSetting(renderNewHarnessFile(definition, expectedBlock ?? ""), definition, workerSettings);
         return {
             definition,
             status: {
@@ -1281,7 +1293,7 @@ async function analyzeHarnessFile(fs, repoRoot, definition) {
         const migratedContent = migrateLegacyHarnessFile(definition, currentContent, expectedBlock);
         if (migratedContent) {
             const memoryUpdatedContent = definition.memoryBlock ? ensureVcmMemoryBlock(migratedContent) : migratedContent;
-            const nextContent = normalizeAgentFrontmatter(memoryUpdatedContent, definition);
+            const nextContent = normalizeAgentFrontmatter(memoryUpdatedContent, definition, workerSettings);
             return {
                 definition,
                 status: {
@@ -1300,7 +1312,7 @@ async function analyzeHarnessFile(fs, repoRoot, definition) {
             };
         }
         const insertedContent = `${currentContent.trimEnd()}\n\n${expectedBlock}\n`;
-        const nextContent = normalizeAgentFrontmatter(insertedContent, definition);
+        const nextContent = normalizeAgentFrontmatter(insertedContent, definition, workerSettings);
         return {
             definition,
             status: {
@@ -1322,7 +1334,7 @@ async function analyzeHarnessFile(fs, repoRoot, definition) {
     const currentBlock = match[0];
     const blockUpdatedContent = currentContent.replace(managedBlockPattern, expectedBlock);
     const memoryUpdatedContent = definition.memoryBlock ? ensureVcmMemoryBlock(blockUpdatedContent) : blockUpdatedContent;
-    const nextContent = normalizeAgentFrontmatter(memoryUpdatedContent, definition);
+    const nextContent = normalizeAgentFrontmatter(memoryUpdatedContent, definition, workerSettings);
     const action = currentContent === nextContent ? "ok" : "update";
     return {
         definition,
@@ -1488,11 +1500,17 @@ function ensureAgentAllowedTool(content, requiredTool) {
         : frontmatter.replace(/^disallowedTools:\s*.*\r?\n?/m, "");
     return content.replace(frontmatter, nextFrontmatter);
 }
-function normalizeAgentFrontmatter(content, definition) {
+function normalizeAgentFrontmatter(content, definition, workerSettings) {
     const allowedToolsUpdated = (definition.requiredTools ?? []).reduce(ensureAgentAllowedTool, content);
     const disallowedToolsUpdated = ensureAgentDisallowedTools(allowedToolsUpdated, definition.requiredDisallowedTools);
     const skillsUpdated = (definition.requiredSkills ?? []).reduce(ensureAgentSkill, disallowedToolsUpdated);
-    return (definition.removedSkills ?? []).reduce(removeAgentSkill, skillsUpdated);
+    const removedSkillsUpdated = (definition.removedSkills ?? []).reduce(removeAgentSkill, skillsUpdated);
+    return applyWorkerSetting(removedSkillsUpdated, definition, workerSettings);
+}
+function applyWorkerSetting(content, definition, workerSettings) {
+    return definition.architectWorkerType
+        ? applyArchitectWorkerSetting(content, workerSettings[definition.architectWorkerType])
+        : content;
 }
 function ensureAgentSkill(content, requiredSkill) {
     const frontmatterMatch = content.match(/^---\r?\n[\s\S]*?\r?\n---/);
@@ -2088,9 +2106,12 @@ Summarize files reviewed, files updated, generated artifacts, durable-doc audit
 [/VCM HARNESS BOOTSTRAP]`;
 }
 export function createScriptFixedHarnessInstaller(scriptPath = path.resolve(process.cwd(), "scripts/install-vcm-harness.mjs")) {
-    return async (repoRoot) => {
+    return async (repoRoot, options = {}) => {
         try {
-            const { stdout, stderr } = await execFileAsync(process.execPath, [scriptPath, repoRoot], {
+            const args = options.architectWorkers
+                ? [scriptPath, repoRoot, "--architect-workers", JSON.stringify(options.architectWorkers)]
+                : [scriptPath, repoRoot];
+            const { stdout, stderr } = await execFileAsync(process.execPath, args, {
                 cwd: process.cwd(),
                 maxBuffer: 10 * 1024 * 1024
             });

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

@@ -47,11 +47,9 @@ export function createMessageService(deps) {
         const candidates = selectDispatchCandidates(pendingFiles, input.stoppedRole);
         const results = [];
         for (const routeFile of candidates) {
+            // dispatchRouteFile persists its own message snapshots.
             const result = await dispatchRouteFile(input, routeFile, state, timestamp);
             results.push(result);
-            if (result.message) {
-                await appendMessageSnapshot(deps.fs, input, result.message);
-            }
             if (result.delivered) {
                 break;
             }
@@ -136,12 +134,25 @@ export function createMessageService(deps) {
             ...message,
             deliveredAt: timestamp
         };
+        let deliveryRecorded = false;
         try {
             await submitTerminalInput(deps.runtime, session.id, renderMessageEnvelope(delivered), {
-                enterDelayMs: autoDispatchEnterDelayMs
+                enterDelayMs: autoDispatchEnterDelayMs,
+                // Record delivery before Enter: a restart after this point must treat the
+                // dispatch as possibly executed instead of delivering it again.
+                beforeSubmit: async () => {
+                    await appendMessageSnapshot(deps.fs, input, delivered);
+                    deliveryRecorded = true;
+                }
             });
         }
         catch (error) {
+            if (deliveryRecorded) {
+                await appendMessageSnapshot(deps.fs, input, {
+                    ...message,
+                    failureReason: `Terminal submission failed: ${errorMessage(error)}`
+                });
+            }
             if (routeFile.fromRole === PM_ROLE) {
                 await deps.workflowControlService?.releaseDispatch(toWorkflowContext(input), messageId);
             }
@@ -523,11 +534,24 @@ async function readLatestMessages(fs, messagesPath) {
     const latest = new Map();
     const lines = (await fs.readText(messagesPath)).split(/\r?\n/).filter(Boolean);
     for (const line of lines) {
-        const message = JSON.parse(line);
-        latest.set(message.id, message);
+        const message = parseMessageLine(line);
+        // A line truncated by a crash or full disk must not block every later read;
+        // runtime recovery removes it and reports a warning.
+        if (message) {
+            latest.set(message.id, message);
+        }
     }
     return [...latest.values()].sort((left, right) => left.createdAt.localeCompare(right.createdAt));
 }
+export function parseMessageLine(line) {
+    try {
+        const message = JSON.parse(line);
+        return message && typeof message.id === "string" ? message : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 async function appendMessageSnapshot(fs, input, message) {
     await fs.appendText(getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug), `${JSON.stringify(message)}\n`);
 }

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

@@ -33,7 +33,7 @@ export function createProjectService(deps) {
             await deps.fs.ensureDir(path.join(this.getProjectDataRoot(repoRoot), "tasks"));
             await deps.fs.ensureDir(path.join(repoRoot, ".claude", "worktrees"));
             await this.saveConfig(config, true);
-            currentProject = await readConnectedProjectSummary(repoRoot, config);
+            currentProject = await readConnectedProjectSummary(repoRoot, config, { refreshClaudeVersion: true });
             await deps.appSettings.recordRecentRepositoryPath(repoRoot);
             return currentProject;
         },
@@ -97,8 +97,14 @@ export function createProjectService(deps) {
             return path.dirname(deps.appSettings.getProjectConfigPath(repoRoot));
         }
     };
-    async function readConnectedProjectSummary(repoRoot, config) {
+    async function readConnectedProjectSummary(repoRoot, config, options = {}) {
         const warnings = [];
+        const claudeVersionWarning = await deps.claudeVersionCheck?.getWarning(config.claudeCommand, {
+            refresh: options.refreshClaudeVersion
+        });
+        if (claudeVersionWarning) {
+            warnings.push(claudeVersionWarning);
+        }
         let branch = "unknown";
         let isDirty = false;
         let headCommit = "unknown";

package/dist/backend/services/runtime-recovery-service.js

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { GATE_REVIEW_GATES } from "../../shared/types/gate-review.js";
+import { parseMessageLine } from "./message-service.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
 const TRANSLATOR_SESSION_PATH = ".ai/vcm/translations/session.json";
 const HARNESS_ENGINEER_SESSION_PATH = ".ai/vcm/harness-engineer/session.json";
@@ -29,10 +30,16 @@ export function createRuntimeRecoveryService(deps) {
             }
             for (const task of tasks.filter((candidate) => candidate.cleanupStatus !== "cleaned")) {
                 const taskRepoRoot = getTaskRuntimeRepoRoot(task);
-                await runStep(context, `recover task ${task.taskSlug}`, async () => {
-                    await recoverTaskSessions(taskRepoRoot, config.stateRoot, task.taskSlug, recoveredAt, context);
-                    const roundRecovered = await recoverRound(taskRepoRoot, config.stateRoot, task.taskSlug, recoveredAt, context);
-                    await recoverMessages(taskRepoRoot, config.stateRoot, task.taskSlug, recoveredAt, context);
+                const label = `recover task ${task.taskSlug}`;
+                // Each step runs independently so one failing record cannot skip the
+                // remaining recovery for the task.
+                await runStep(context, `${label} sessions`, () => recoverTaskSessions(taskRepoRoot, config.stateRoot, task.taskSlug, recoveredAt, context));
+                let roundRecovered = false;
+                await runStep(context, `${label} round`, async () => {
+                    roundRecovered = await recoverRound(taskRepoRoot, config.stateRoot, task.taskSlug, recoveredAt, context);
+                });
+                await runStep(context, `${label} messages`, () => recoverMessages(taskRepoRoot, config.stateRoot, task.taskSlug, recoveredAt, context));
+                await runStep(context, `${label} workflow`, async () => {
                     const workflowRecovered = await deps.workflowControlService?.recoverTask({
                         taskRepoRoot,
                         stateRoot: config.stateRoot,
@@ -42,10 +49,16 @@ export function createRuntimeRecoveryService(deps) {
                     if (workflowRecovered) {
                         context.changedPaths.add(path.join(config.stateRoot, "workflow-control.json"));
                     }
-                    await recoverGateReview(taskRepoRoot, recoveredAt, context);
-                    await recoverCoderWorkers(taskRepoRoot, task.taskSlug, context);
+                });
+                await runStep(context, `${label} gate review`, () => recoverGateReview(taskRepoRoot, recoveredAt, context));
+                await runStep(context, `${label} coder workers`, () => recoverCoderWorkers(taskRepoRoot, task.taskSlug, context));
+                await runStep(context, `${label} architect restart`, async () => {
                     await deps.architectRestartService?.recoverTask(repoRoot, task.taskSlug);
+                });
+                await runStep(context, `${label} restart with context`, async () => {
                     await deps.roleContextRestartService?.recoverTask(repoRoot, task.taskSlug);
+                });
+                await runStep(context, `${label} status`, async () => {
                     if ((roundRecovered || task.status === "running") && !hasLiveTaskSession(task.taskSlug)) {
                         await deps.taskService.updateTaskStatus(repoRoot, task.taskSlug, "stopped");
                     }
@@ -188,8 +201,17 @@ export function createRuntimeRecoveryService(deps) {
         }
         const lines = (await deps.fs.readText(absolutePath)).split(/\r?\n/).filter((line) => line.trim());
         let changed = false;
-        const messages = lines.map((line) => {
-            const message = JSON.parse(line);
+        const parsed = [];
+        for (const [index, line] of lines.entries()) {
+            const message = parseMessageLine(line);
+            if (message) {
+                parsed.push(message);
+                continue;
+            }
+            changed = true;
+            context.warnings.push(`${relativePath}: removed unparsable message log line ${index + 1}.`);
+        }
+        const messages = parsed.map((message) => {
             if (message.dispatchingAt && !message.acceptedAt) {
                 const next = {
                     ...message,
@@ -208,7 +230,12 @@ export function createRuntimeRecoveryService(deps) {
             return;
         }
         const content = messages.length ? `${messages.map((message) => JSON.stringify(message)).join("\n")}\n` : "";
-        await deps.fs.writeText(absolutePath, content);
+        if (deps.fs.writeTextAtomic) {
+            await deps.fs.writeTextAtomic(absolutePath, content);
+        }
+        else {
+            await deps.fs.writeText(absolutePath, content);
+        }
         context.changedPaths.add(relativePath);
         void timestamp;
     }

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

@@ -5,7 +5,6 @@ import { isCodexBridgeSessionModel } from "../../shared/types/session.js";
 import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
-import { claudeTranscriptPath } from "./claude-transcript-service.js";
 import { readHarnessRevisionState } from "./harness-revision.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
 import { roleUsesLsp, prepareTaskLspPlugin, renderArchitectLspNotice, VCM_LSP_PLUGIN_DIR } from "./lsp-plugin.js";
@@ -77,11 +76,9 @@ export function createSessionService(deps) {
             });
         }
         const claudeSessionId = resumeClaudeSessionId ?? "";
-        const transcriptPath = launchMode === "resume" && persisted?.transcriptPath
-            ? persisted.transcriptPath
-            : resumeClaudeSessionId
-                ? claudeTranscriptPath(taskRepoRoot, resumeClaudeSessionId, persisted?.claudeConfigDir)
-                : undefined;
+        // Transcript paths come from Claude Code hook payloads; VCM does not derive
+        // them from Claude Code's project-directory encoding.
+        const transcriptPath = launchMode === "resume" ? persisted?.transcriptPath : undefined;
         const lspStatus = roleUsesLsp(role) && deps.codeIntelligenceDetector
             ? await deps.codeIntelligenceDetector.detect(taskRepoRoot, { refresh: true })
             : undefined;
@@ -222,9 +219,7 @@ export function createSessionService(deps) {
         // session genuinely starts at repoRoot.
         const sessionCwd = launchMode === "resume" ? persisted?.cwd ?? launchCwd : launchCwd;
         const claudeSessionId = resumeClaudeSessionId ?? "";
-        const transcriptPath = resumeClaudeSessionId
-            ? claudeTranscriptPath(repoRoot, resumeClaudeSessionId, persisted?.claudeConfigDir)
-            : undefined;
+        const transcriptPath = launchMode === "resume" ? persisted?.transcriptPath : undefined;
         const startCommand = {
             ...deps.claude.buildRoleStartCommand(TRANSLATOR_ROLE, config.claudeCommand, permissionMode, resumeClaudeSessionId, launchMode === "resume", model, effort, modelSettingsOverride),
             cwd: launchCwd
@@ -338,9 +333,7 @@ export function createSessionService(deps) {
         // restored cwd so the `/cd` migrate below fires only on an actual switch.
         const sessionCwd = launchMode === "resume" ? persisted?.cwd ?? launchCwd : launchCwd;
         const claudeSessionId = resumeClaudeSessionId ?? "";
-        const transcriptPath = resumeClaudeSessionId
-            ? claudeTranscriptPath(repoRoot, resumeClaudeSessionId, persisted?.claudeConfigDir)
-            : undefined;
+        const transcriptPath = launchMode === "resume" ? persisted?.transcriptPath : undefined;
         const startCommand = {
             ...deps.claude.buildRoleStartCommand(HARNESS_ENGINEER_ROLE, config.claudeCommand, permissionMode, resumeClaudeSessionId, launchMode === "resume", model, effort, modelSettingsOverride),
             cwd: launchCwd
@@ -597,9 +590,7 @@ export function createSessionService(deps) {
             updatedAt: timestamp,
             lastOutputAt: runtimeSession.lastOutputAt,
             exitCode: runtimeSession.exitCode,
-            transcriptPath: session.claudeSessionId
-                ? claudeTranscriptPath(repoRoot, session.claudeSessionId, session.claudeConfigDir)
-                : session.transcriptPath
+            transcriptPath: session.transcriptPath
         };
         deps.registry.upsert(normalizeProjectScopedRecordForPersistence(resumed));
         await persistProjectScopedToolSession(repoRoot, resumed);
@@ -1275,6 +1266,10 @@ function toRoleSessionRecordView(record, runtime) {
     };
 }
 export function matchesRoleHookSession(record, input) {
+    if (record.runtimeSessionToken
+        && record.runtimeSessionToken !== input.runtimeSessionToken) {
+        return false;
+    }
     if (input.runtimeSessionId) {
         return record.id === input.runtimeSessionId;
     }
@@ -1283,10 +1278,6 @@ export function matchesRoleHookSession(record, input) {
         && input.eventName !== "UserPromptSubmit") {
         return false;
     }
-    if (record.runtimeSessionToken
-        && record.runtimeSessionToken !== input.runtimeSessionToken) {
-        return false;
-    }
     if (!record.claudeSessionId && !record.transcriptPath) {
         return input.eventName === "UserPromptSubmit";
     }

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

@@ -5,6 +5,7 @@ export function createTaskCloseService(deps) {
         async closeTask(repoRoot, taskSlug) {
             const task = await deps.taskService.markTaskCleaned(repoRoot, taskSlug);
             const warnings = [];
+            deps.gateReviewService?.stopTask(taskSlug);
             if (deps.architectRestartService) {
                 await bestEffort("Unable to clear Architect restart state", () => deps.architectRestartService.clear(repoRoot, taskSlug), warnings);
             }

package/dist/backend/services/terminal-process-exit-service.js

@@ -1,4 +1,4 @@
-import { isVcmRoleName } from "../../shared/constants.js";
+import { isReviewerRoleName, isVcmRoleName } from "../../shared/constants.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
 export function createTerminalProcessExitService(deps) {
     let unsubscribe;
@@ -12,6 +12,9 @@ export function createTerminalProcessExitService(deps) {
             status: event.session.status === "crashed" ? "crashed" : "exited",
             exitCode: event.exitCode
         });
+        if (recorded && isReviewerRoleName(recorded.record.role)) {
+            deps.gateReviewService?.recordReviewerTurnEnded(recorded.record.taskSlug, "process-exit");
+        }
         if (!recorded?.turnWasRunning || !isVcmRoleName(recorded.record.role)) {
             return;
         }

package/dist/backend/services/workflow-control-service.js

@@ -26,13 +26,46 @@ export function createWorkflowControlService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     const id = deps.id ?? (() => `wfauth_${randomUUID()}`);
     const locks = new Map();
-    async function getState(input) {
+    // Locked callers only: replays the commit journal and persists the template or
+    // reconstructed runtime state.
+    function getState(input) {
+        return loadState(input, true);
+    }
+    // Unlocked public reads: computes the same view without writing any file.
+    function readStateView(input) {
+        return loadState(input, false);
+    }
+    async function readProgressView(input) {
+        const pending = await readPendingCommitJournal(input);
+        if (pending)
+            return parseWorkflowProgress(pending.progressContent, input.taskSlug);
+        if (!(await deps.fs.pathExists(progressPath(input)))) {
+            return parseWorkflowProgress(renderWorkflowProgressTemplate(input.taskSlug), input.taskSlug);
+        }
+        return readProgress(deps.fs, input);
+    }
+    async function loadState(input, persist) {
         try {
-            await recoverCommitJournal(input);
+            if (persist) {
+                await recoverCommitJournal(input);
+            }
+            else {
+                const pending = await readPendingCommitJournal(input);
+                if (pending) {
+                    const state = normalizeState(pending.state, input.taskSlug, now());
+                    const progress = parseWorkflowProgress(pending.progressContent, input.taskSlug);
+                    return {
+                        ...state,
+                        warnings: [...state.warnings, ...stateProgressConsistencyWarnings(state, progress)]
+                    };
+                }
+            }
             const hasProgress = await deps.fs.pathExists(progressPath(input));
             const hasState = await deps.fs.pathExists(statePath(input));
             if (!hasProgress && !hasState) {
-                await writeAtomic(deps.fs, progressPath(input), renderWorkflowProgressTemplate(input.taskSlug));
+                if (persist) {
+                    await writeAtomic(deps.fs, progressPath(input), renderWorkflowProgressTemplate(input.taskSlug));
+                }
                 return emptyState(input.taskSlug, now());
             }
             if (!hasProgress) {
@@ -51,7 +84,9 @@ export function createWorkflowControlService(deps) {
                 }
                 if (!progress.proposal && progress.history.length > 0) {
                     const recovered = await reconstructStateFromProgress(input, progress);
-                    await saveState(input, recovered);
+                    if (persist) {
+                        await saveState(input, recovered);
+                    }
                     return recovered;
                 }
                 return {
@@ -357,18 +392,17 @@ export function createWorkflowControlService(deps) {
             return true;
         });
     }
+    // Public reads never write; journal replay and state persistence happen only
+    // inside locked operations.
     return {
-        getState,
-        getProgress: async (input) => {
-            await getState(input);
-            return readProgress(deps.fs, input);
-        },
+        getState: readStateView,
+        getProgress: readProgressView,
         requestUserInput,
         resolveUserInput,
         runWhileNotAwaitingUser,
         submitProgress,
-        assertDocsArtifactAllowed,
-        assertRouteAuthorized,
+        assertDocsArtifactAllowed: (input, kind, role) => withLock(statePath(input), () => assertDocsArtifactAllowed(input, kind, role)),
+        assertRouteAuthorized: (input) => withLock(statePath(input), () => assertRouteAuthorized(input)),
         claimDispatch,
         releaseDispatch,
         markDispatchUnconfirmed,
@@ -485,6 +519,16 @@ export function createWorkflowControlService(deps) {
         await deps.fs.writeJsonAtomic(transactionPath(input), { ...journal, status: "committed" });
         await removeTransactionJournal(transactionPath(input));
     }
+    async function readPendingCommitJournal(input) {
+        const target = transactionPath(input);
+        if (!(await deps.fs.pathExists(target)))
+            return undefined;
+        const journal = await deps.fs.readJson(target);
+        if (journal.version !== 1 || journal.taskSlug !== input.taskSlug) {
+            throw new Error("Workflow commit journal does not match the active task.");
+        }
+        return journal.status === "pending" ? journal : undefined;
+    }
     async function recoverCommitJournal(input) {
         const target = transactionPath(input);
         if (!(await deps.fs.pathExists(target)))

package/dist/backend/templates/harness/architect-worker-frontmatter.js

@@ -0,0 +1,33 @@
+// Agent names of the Architect workers whose model and effort follow the
+// architect worker settings. Shared by the fixed installer and harness status.
+export const ARCHITECT_WORKER_AGENT_TYPES = {
+    "vcm-architect-evidence-worker": "evidence",
+    "vcm-architect-scaffold-worker": "scaffold",
+    "vcm-architect-validation-worker": "validation"
+};
+export function applyArchitectWorkerSetting(content, setting) {
+    const withModel = setAgentFrontmatterField(content, "model", setting.model, /^(?:tools|disallowedTools):.*$/m);
+    return setAgentFrontmatterField(withModel, "effort", setting.effort === "default" ? undefined : setting.effort, /^model:.*$/m);
+}
+function setAgentFrontmatterField(content, field, value, insertAfter) {
+    const frontmatterMatch = content.match(/^---\r?\n[\s\S]*?\r?\n---/);
+    if (!frontmatterMatch) {
+        return content;
+    }
+    const frontmatter = frontmatterMatch[0];
+    const fieldLine = new RegExp(`^${field}:.*$`, "m");
+    let next;
+    if (value === undefined) {
+        next = frontmatter.replace(new RegExp(`^${field}:.*(?:\\r?\\n)?`, "m"), "");
+    }
+    else if (fieldLine.test(frontmatter)) {
+        next = frontmatter.replace(fieldLine, `${field}: ${value}`);
+    }
+    else {
+        const anchor = frontmatter.match(insertAfter);
+        next = anchor
+            ? frontmatter.replace(anchor[0], `${anchor[0]}\n${field}: ${value}`)
+            : frontmatter.replace(/\r?\n---$/, `\n${field}: ${value}\n---`);
+    }
+    return content.replace(frontmatter, next);
+}