vibe-coding-master 0.9.1 → 0.9.3

package/README.md

@@ -211,10 +211,11 @@ Typical flow:
 
 ```text
 Project Manager
-  -> Architect
+  -> Architect (plan, scaffold, and architecture docs)
   -> Coder
   -> Tester
-  -> Architect docs sync
+  -> validation-adequacy Gate Review
+  -> code-diff Gate Review (code and docs)
   -> Project Manager final acceptance
 ```
 
@@ -510,15 +511,20 @@ Use it to:
 - merge task harness commits back to the connected repository branch when
   appropriate
 
-VCM bundles the Claude Code LSP bridge and loads it only for Architect sessions,
-including Codex Bridge launches. The project environment must still
+VCM bundles the Claude Code LSP bridge and loads it for Architect and Reviewer
+sessions, including Codex Bridge launches; Architect's evidence worker can use it
+too. While a language server is still indexing, VCM holds LSP queries until it
+is ready and fails them explicitly if indexing does not finish, instead of
+returning partial results. The project environment must still
 provide the language server for each detected language: `rust-analyzer`,
 `typescript-language-server`, `pyright-langserver`, `gopls`, `clangd`, or
 `jdtls`. Architect preloads `vcm-code-navigation` and uses LSP for semantic
 relationships. Accessors, backing fields, trait items, implementations, wrappers,
 and aliases are queried as separate symbols; a bounded source-text fallback may
 only locate candidates after the correct LSP query is demonstrably partial.
-Other roles use generated context and ordinary source reads. Harness Studio
+At the architecture-plan gate, Reviewer checks that every decision-bearing
+relationship cites its evidence source and re-queries it with LSP. Other roles
+use generated context and ordinary source reads. Harness Studio
 reports whether the server executable and plugin can run; the role Session
 performs the real workspace indexing and semantic query retries.
 

package/dist/backend/adapters/command-runner.js

@@ -7,6 +7,7 @@ export function createCommandRunner() {
                     cwd: options.cwd,
                     env: options.env,
                     timeout: options.timeoutMs,
+                    input: options.input,
                     reject: false
                 });
                 return {

package/dist/backend/adapters/filesystem.js

@@ -70,13 +70,16 @@ export function createNodeFileSystemAdapter() {
         async readJson(targetPath) {
             let attempt = 0;
             for (;;) {
-                const content = await runFileOperation(() => fs.readFile(targetPath, "utf8"));
                 try {
+                    const content = await runFileOperation(() => fs.readFile(targetPath, "utf8"));
                     return JSON.parse(content);
                 }
                 catch (error) {
+                    // A concurrent rename-over can leave the target briefly missing on
+                    // some shared mounts, so ENOENT gets the same short retry as a
+                    // partially written file. A file that stays missing still throws.
                     const delayMs = JSON_READ_RETRY_DELAYS_MS[attempt];
-                    if (!(error instanceof SyntaxError) || delayMs === undefined) {
+                    if (!(error instanceof SyntaxError || getErrorCode(error) === "ENOENT") || delayMs === undefined) {
                         throw error;
                     }
                     attempt += 1;

package/dist/backend/api/artifact-routes.js

@@ -147,9 +147,6 @@ function artifactNameToPath(paths, artifactName) {
     if (artifactName === "docs-update-report.md") {
         return paths.docsUpdateReportPath;
     }
-    if (artifactName === "docs-sync-report.md") {
-        return paths.docsSyncReportPath;
-    }
     if (artifactName === "workflow-progress.md") {
         return paths.workflowProgressPath;
     }

package/dist/backend/api/task-routes.js

@@ -226,7 +226,6 @@ function degradedArtifactSummary(handoffDir) {
             architectureDiagnosisPath: `${handoffDir}/architecture-diagnosis.md`,
             testReportPath: `${handoffDir}/test-report.md`,
             docsUpdateReportPath: `${handoffDir}/docs-update-report.md`,
-            docsSyncReportPath: `${handoffDir}/docs-sync-report.md`,
             workflowProgressPath: `${handoffDir}/workflow-progress.md`,
             finalAcceptancePath: `${handoffDir}/final-acceptance.md`
         },

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

@@ -6,7 +6,7 @@ import path from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
 import { renderArchitectHarnessRules } from "../templates/harness/architect-agent.js";
-import { CODE_ROLE_DISALLOWED_TOOLS, REVIEWER_DISALLOWED_TOOLS } from "../role-tool-policy.js";
+import { CODE_ROLE_DISALLOWED_TOOLS, EVIDENCE_WORKER_DISALLOWED_TOOLS, REVIEWER_DISALLOWED_TOOLS } from "../role-tool-policy.js";
 import { renderCoderHarnessRules } from "../templates/harness/coder-agent.js";
 import { renderCoderWorkerHarnessRules } from "../templates/harness/coder-worker-agent.js";
 import { renderArchitectEvidenceWorkerHarnessRules } from "../templates/harness/architect-evidence-worker-agent.js";
@@ -108,7 +108,7 @@ const AGENT_FRONTMATTER = {
     },
     "vcm-architect-evidence-worker": {
         description: "Foreground Architect worker for bounded project evidence collection.",
-        tools: "Read, Grep, Glob, Write"
+        disallowedTools: EVIDENCE_WORKER_DISALLOWED_TOOLS.join(", ")
     },
     "vcm-architect-scaffold-worker": {
         description: "Foreground Architect worker for exact scaffold execution and scaffold validation."
@@ -119,6 +119,7 @@ const AGENT_FRONTMATTER = {
     }
 };
 const REQUIRED_AGENT_DISALLOWED_TOOLS = {
+    "vcm-architect-evidence-worker": EVIDENCE_WORKER_DISALLOWED_TOOLS,
     architect: CODE_ROLE_DISALLOWED_TOOLS,
     coder: CODE_ROLE_DISALLOWED_TOOLS,
     reviewer: REVIEWER_DISALLOWED_TOOLS
@@ -319,6 +320,12 @@ const WHOLE_FILES = [
         mode: 0o755,
         templatePath: "scripts/harness-tools/check-durable-docs"
     },
+    {
+        path: ".ai/tools/check-docs-sync",
+        category: "durable-docs-tool",
+        mode: 0o755,
+        templatePath: "scripts/harness-tools/check-docs-sync"
+    },
     {
         path: ".claude/skills/vcm-architecture-interview/SKILL.md",
         category: "skill",

package/dist/backend/role-tool-policy.js

@@ -38,13 +38,22 @@ export const REVIEWER_DISALLOWED_TOOLS = [
     "Edit",
     ...LSP_FRONTMATTER_DISALLOWED_TOOLS
 ];
+// The evidence worker reads and queries LSP but never runs commands, edits code,
+// or delegates. A deny list keeps the parent session's LSP tool available.
+export const EVIDENCE_WORKER_DISALLOWED_TOOLS = [
+    "Agent",
+    "Bash",
+    "Edit",
+    ...LSP_FRONTMATTER_DISALLOWED_TOOLS
+];
 export const CODE_ROLE_RUNTIME_DISALLOWED_TOOLS = [...NON_VCM_ROLE_RUNTIME_TOOLS];
 export const REVIEWER_RUNTIME_DISALLOWED_TOOLS = [
     "Agent",
     "Edit",
     ...NON_VCM_ROLE_RUNTIME_TOOLS
 ];
-const LSP_ROLE_NAMES = new Set(["architect"]);
+// Architect makes semantic code claims; Reviewer verifies them at Gate Review.
+const LSP_ROLE_NAMES = new Set(["architect", "reviewer"]);
 export function roleUsesLsp(role) {
     return LSP_ROLE_NAMES.has(role);
 }

package/dist/backend/server.js

@@ -2,6 +2,7 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import Fastify from "fastify";
 import fastifyStatic from "@fastify/static";
+import { createDocsCoverageCheck } from "./services/docs-sync-check.js";
 import { createArtifactService } from "./services/artifact-service.js";
 import { createClaudeAdapter } from "./adapters/claude-adapter.js";
 import { createCodexBridgeAdapter } from "./adapters/codex-bridge-adapter.js";
@@ -354,6 +355,7 @@ export function createDefaultServerDeps(options = {}) {
         sessionService,
         roundService,
         workflowControlService,
+        checkDocsCoverage: createDocsCoverageCheck(runner),
         onArchitecturePlanDisposition: ({ repoRoot, taskSlug, accepted }) => architectRestartService.recordArchitectureGateDisposition(repoRoot, taskSlug, accepted)
     });
     const translationWorkerService = createTranslationWorkerService({

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

@@ -4,7 +4,7 @@ import { checkMarkdownArtifact, readArtifactSectionValue } from "../../shared/va
 import { getManagedArtifactDefinition, isArtifactKind, isManagedArtifactKind } from "../../shared/validation/artifact-registry.js";
 import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
-import { renderArchitectureBriefTemplate, renderArchitectureDiagnosisTemplate, renderArchitectureEvidenceTemplate, renderArchitecturePlanTemplate, renderArchitectDebugTemplate, renderCoderCompletionTemplate, renderDocsUpdateReportTemplate, renderDocsSyncReportTemplate, renderFinalAcceptanceTemplate, renderKnownIssuesTemplate, renderPlanningProgressTemplate, renderMessageRouteTemplate, renderTestReportTemplate, renderWorkflowProgressTemplate } from "../templates/handoff.js";
+import { renderArchitectureBriefTemplate, renderArchitectureDiagnosisTemplate, renderArchitectureEvidenceTemplate, renderArchitecturePlanTemplate, renderArchitectDebugTemplate, renderCoderCompletionTemplate, renderDocsUpdateReportTemplate, renderFinalAcceptanceTemplate, renderKnownIssuesTemplate, renderPlanningProgressTemplate, renderMessageRouteTemplate, renderTestReportTemplate, renderWorkflowProgressTemplate } from "../templates/handoff.js";
 import { renderRoleCommandTemplate } from "../templates/role-command.js";
 import { isMemoryProposalSubmissionPath } from "./memory-review-paths.js";
 import { validateManagedArtifactContent } from "./managed-artifact-validation.js";
@@ -19,7 +19,6 @@ const ARTIFACT_PATH_KEYS = [
     ["architecture-diagnosis", "architectureDiagnosisPath"],
     ["test-report", "testReportPath"],
     ["docs-update-report", "docsUpdateReportPath"],
-    ["docs-sync-report", "docsSyncReportPath"],
     ["workflow-progress", "workflowProgressPath"],
     ["final-acceptance", "finalAcceptancePath"]
 ];
@@ -57,7 +56,6 @@ export function createArtifactService(fs, deps = {}) {
                 architectureDiagnosisPath: path.posix.join(handoffDir, "architecture-diagnosis.md"),
                 testReportPath: path.posix.join(handoffDir, "test-report.md"),
                 docsUpdateReportPath: path.posix.join(handoffDir, "docs-update-report.md"),
-                docsSyncReportPath: path.posix.join(handoffDir, "docs-sync-report.md"),
                 workflowProgressPath: path.posix.join(handoffDir, "workflow-progress.md"),
                 finalAcceptancePath: path.posix.join(handoffDir, "final-acceptance.md")
             };
@@ -88,7 +86,6 @@ export function createArtifactService(fs, deps = {}) {
                 [paths.architectureDiagnosisPath, renderArchitectureDiagnosisTemplate(input.taskSlug)],
                 [paths.testReportPath, renderTestReportTemplate(input.taskSlug)],
                 [paths.docsUpdateReportPath, renderDocsUpdateReportTemplate(input.taskSlug)],
-                [paths.docsSyncReportPath, renderDocsSyncReportTemplate(input.taskSlug)],
                 [paths.workflowProgressPath, renderWorkflowProgressTemplate(input.taskSlug)],
                 [paths.finalAcceptancePath, renderFinalAcceptanceTemplate(input.taskSlug)],
                 ...Object.values(paths.messageRoutePaths).map((messagePath) => [
@@ -230,18 +227,6 @@ export function createArtifactService(fs, deps = {}) {
                 if (validation.errors.length > 0) {
                     throw artifactRejected(input.kind, validation.errors);
                 }
-                if ((input.kind === "docs-update-report" || input.kind === "docs-sync-report")
-                    && deps.workflowControlService) {
-                    // Memory-owned documentation work is independent of PM's active dispatch.
-                    if (!assignment) {
-                        await deps.workflowControlService.assertDocsArtifactAllowed({
-                            taskRepoRoot: input.repoRoot,
-                            stateRoot: input.stateRoot ?? ".ai/vcm",
-                            handoffDir: input.handoffDir,
-                            taskSlug: input.taskSlug
-                        }, input.kind, input.role);
-                    }
-                }
                 if (input.kind === "workflow-progress") {
                     if (input.mode !== "final") {
                         throw artifactRejected(input.kind, ["Workflow Progress must be submitted in final mode."]);

package/dist/backend/services/docs-sync-check.js

@@ -0,0 +1,32 @@
+import fs from "node:fs";
+import path from "node:path";
+const DOCS_SYNC_TOOL = ".ai/tools/check-docs-sync";
+const DOCS_SYNC_TIMEOUT_MS = 60_000;
+// Runs the task worktree's check-docs-sync, which compares the task's commits
+// with the architecture plan's Docs Impact, and returns one error per finding.
+// A worktree whose harness predates the tool is not checked.
+export function createDocsCoverageCheck(runner) {
+    return async (taskRepoRoot) => {
+        const tool = path.join(taskRepoRoot, DOCS_SYNC_TOOL);
+        if (!fs.existsSync(tool)) {
+            return [];
+        }
+        const result = await runner.run(process.execPath, [tool, "--json"], {
+            cwd: taskRepoRoot,
+            timeoutMs: DOCS_SYNC_TIMEOUT_MS
+        });
+        if (result.exitCode === 0) {
+            return [];
+        }
+        try {
+            const parsed = JSON.parse(result.stdout);
+            if (result.exitCode === 1 && Array.isArray(parsed.findings) && parsed.findings.length > 0) {
+                return parsed.findings.map((finding) => `${finding.code} ${finding.subject}: ${finding.message}`);
+            }
+        }
+        catch {
+            // Fall through to the raw tool error below.
+        }
+        return [`${DOCS_SYNC_TOOL} could not check the task: ${(result.stderr || result.stdout).trim() || `exit ${result.exitCode}`}`];
+    };
+}

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

@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
 import path from "node:path";
-import { CODE_DIFF_FINDING_SCOPES, CODE_DIFF_SOURCES, GATE_REVIEW_GATES } from "../../shared/types/gate-review.js";
+import { CODE_DIFF_DOCS_COVERAGE_ERROR_PREFIX, CODE_DIFF_FINDING_SCOPES, CODE_DIFF_SOURCES, GATE_REVIEW_GATES } from "../../shared/types/gate-review.js";
 import { checkMarkdownArtifact, readArtifactSectionValue } from "../../shared/validation/artifact-check.js";
 import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
@@ -379,6 +379,14 @@ export function createGateReviewService(deps) {
                     message: prerequisiteError
                 };
             }
+            const coverageFindings = deps.checkDocsCoverage
+                ? await deps.checkDocsCoverage(context.taskRepoRoot)
+                : [];
+            if (coverageFindings.length > 0) {
+                const message = `${CODE_DIFF_DOCS_COVERAGE_ERROR_PREFIX} ${coverageFindings.join(" ")}`;
+                index = await recordCodeDiffStartFailure(index, context, gate, codeDiffSource, message, codeDiffInput);
+                return { status: "failed_to_start", gate, record: index.gates[gate], message };
+            }
         }
         async function recordCodeDiffStartFailure(currentIndex, currentContext, currentGate, currentSource, message, currentCodeDiffInput) {
             const failedIndex = applyGateState(currentIndex, currentGate, {
@@ -1293,7 +1301,7 @@ async function computeInputHash(deps, taskRepoRoot, gate, codeDiffInput, codeDif
         }
     }
     if (gate === "validation-adequacy") {
-        const evidencePathspec = ["--", ".", ":(exclude).ai/vcm/**", ":(exclude)docs/**"];
+        const evidencePathspec = ["--", ".", ":(exclude).ai/vcm/**", ":(exclude)docs/**", ":(exclude,glob)**/ARCHITECTURE.md", ":(exclude).ai/generated/**"];
         digest.update("trackedEvidence");
         digest.update(await commandStdout(deps.runner, taskRepoRoot, ["ls-files", "-s", ...evidencePathspec]));
         digest.update("workingEvidence");

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

@@ -4,7 +4,7 @@ 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 { CODE_ROLE_DISALLOWED_TOOLS, EVIDENCE_WORKER_DISALLOWED_TOOLS, REVIEWER_DISALLOWED_TOOLS } from "../role-tool-policy.js";
 import { renderCoderHarnessRules } from "../templates/harness/coder-agent.js";
 import { renderCoderWorkerHarnessRules } from "../templates/harness/coder-worker-agent.js";
 import { renderArchitectEvidenceWorkerHarnessRules } from "../templates/harness/architect-evidence-worker-agent.js";
@@ -258,7 +258,8 @@ 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" }),
+        frontmatter: renderAgentFrontmatter("vcm-architect-evidence-worker", "Foreground Architect worker for bounded project evidence collection.", { disallowedTools: EVIDENCE_WORKER_DISALLOWED_TOOLS.join(", ") }),
+        requiredDisallowedTools: EVIDENCE_WORKER_DISALLOWED_TOOLS,
         architectWorkerType: "evidence",
         renderRules: renderArchitectEvidenceWorkerHarnessRules
     },

package/dist/backend/services/lsp-plugin.js

@@ -4,19 +4,31 @@ export { roleUsesLsp } from "../role-tool-policy.js";
 export const VCM_LSP_PLUGIN_NAME = "vcm-lsp-bridge";
 export const VCM_LSP_PLUGIN_DIR = fileURLToPath(new URL("../../../scripts/claude-plugins/vcm-lsp-bridge", import.meta.url));
 export const VCM_LSP_PLUGIN_MANIFEST = path.join(VCM_LSP_PLUGIN_DIR, ".claude-plugin", "plugin.json");
+export const VCM_LSP_PROXY_PATH = path.join(VCM_LSP_PLUGIN_DIR, "vcm-lsp-proxy.mjs");
 export async function prepareTaskLspPlugin(fs, taskRepoRoot, status) {
     const runnable = status.languages.filter((language) => language.state === "server_runnable");
     if (runnable.length === 0)
         return [];
     const manifest = await fs.readJson(VCM_LSP_PLUGIN_MANIFEST);
     const commands = new Set(runnable.map((language) => language.serverCommand));
-    const lspServers = Object.fromEntries(Object.entries(manifest.lspServers).filter(([, server]) => commands.has(server.command)));
+    const lspServers = Object.fromEntries(Object.entries(manifest.lspServers)
+        .filter(([, server]) => commands.has(server.command))
+        .map(([name, server]) => [name, withReadinessProxy(server)]));
     const pluginDir = path.join(taskRepoRoot, ".ai/vcm/lsp-plugin");
     const pluginManifestPath = path.join(pluginDir, ".claude-plugin/plugin.json");
     await fs.ensureDir(path.dirname(pluginManifestPath));
     await fs.writeJsonAtomic(pluginManifestPath, { ...manifest, lspServers });
     return [pluginDir];
 }
+// Runs the server behind vcm-lsp-proxy so navigation queries wait for indexing
+// to finish, or fail explicitly, instead of returning partial or empty results.
+function withReadinessProxy(server) {
+    return {
+        ...server,
+        command: process.execPath,
+        args: [VCM_LSP_PROXY_PATH, "--", server.command, ...(server.args ?? [])]
+    };
+}
 export function lspUnavailableWarning(language) {
     const installCommands = {
         "rust-analyzer": "rustup component add rust-analyzer",
@@ -27,19 +39,26 @@ export function lspUnavailableWarning(language) {
     const recovery = language.state === "plugin_missing"
         ? "Refresh the VCM Harness to restore the LSP plugin."
         : `Install or repair ${language.serverCommand} in the environment running the VCM backend${installCommands[language.serverCommand] ? ` (${installCommands[language.serverCommand]})` : ""} and ensure it is executable on PATH.`;
-    return `Architect LSP for ${language.label} is unavailable: ${language.error ?? `${language.serverCommand} is not runnable.`} ${recovery} Restart Architect after fixing the environment so VCM can detect and register the server again.`;
+    return `LSP for ${language.label} is unavailable: ${language.error ?? `${language.serverCommand} is not runnable.`} ${recovery} Restart the LSP roles (Architect, Reviewer) after fixing the environment so VCM can detect and register the server again.`;
 }
-export function renderArchitectLspNotice(status) {
+// Architect stops semantic work in an unavailable language; Reviewer completes
+// the review and records those relationships as not LSP-verified.
+export function renderLspNotice(status, role = "architect") {
     if (status.languages.length === 0)
         return undefined;
     const available = status.languages.filter((language) => language.state === "server_runnable");
     const unavailable = status.languages.filter((language) => language.state !== "server_runnable");
     return [
-        "[VCM Architect LSP Availability]",
+        "[VCM LSP Availability]",
         `Registered language servers: ${available.map((language) => `${language.label} (${language.serverCommand})`).join(", ") || "none"}.`,
+        ...(available.length > 0 ? [
+            "While a server is still indexing, VCM holds LSP queries until it is ready. A query that fails with \"Language server is still indexing\" did not return a result: retry it later or record the relationship as unresolved; never read the failure as an empty result."
+        ] : []),
         ...unavailable.map(lspUnavailableWarning),
         ...(unavailable.length > 0 ? [
-            "If your assignment requires a semantic query in an unavailable language, stop that work and report the environment prerequisite through the current communication channel. Do not substitute source text search or claim the relationship is verified. Continue only after the server is available."
+            role === "reviewer"
+                ? "For relationships in an unavailable language, complete the review by reading the complete candidate code, record each such relationship as not LSP-verified in the report, and name the missing server. Do not stop the review or treat text matches as verified relationships."
+                : "If your assignment requires a semantic query in an unavailable language, stop that work and report the environment prerequisite through the current communication channel. Do not substitute source text search or claim the relationship is verified. Continue only after the server is available."
         ] : [])
     ].join("\n");
 }

package/dist/backend/services/managed-artifact-validation.js

@@ -25,6 +25,8 @@ export const GATE_ANALYSIS_FIELDS = {
         "Code Reality",
         "Invalidated Assumptions",
         "Existing-Class Completeness",
+        "Relationship Evidence",
+        "Architecture Docs",
         "Ownership",
         "Data Flow",
         "Lifecycle",
@@ -59,7 +61,7 @@ export const GATE_ANALYSIS_FIELDS = {
         "State Lifecycle And Failure Paths",
         "Coding Standards",
         "Baseline Test Integrity",
-        "Generated Context And Durable Docs",
+        "Documentation Fit",
         "Code Readiness"
     ]
 };

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

@@ -7,7 +7,7 @@ import { resolveRepoPath } from "../adapters/filesystem.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.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";
+import { roleUsesLsp, prepareTaskLspPlugin, renderLspNotice, VCM_LSP_PLUGIN_DIR } from "./lsp-plugin.js";
 const TRANSLATOR_ROLE = "translator";
 const HARNESS_ENGINEER_ROLE = "harness-engineer";
 const TRANSLATION_DIR = ".ai/vcm/translations";
@@ -85,7 +85,7 @@ export function createSessionService(deps) {
         const lspPluginDirs = roleUsesLsp(role)
             ? lspStatus ? await prepareTaskLspPlugin(deps.fs, taskRepoRoot, lspStatus) : [VCM_LSP_PLUGIN_DIR]
             : [];
-        const appendSystemPrompt = [input.appendSystemPrompt, lspStatus && renderArchitectLspNotice(lspStatus)]
+        const appendSystemPrompt = [input.appendSystemPrompt, lspStatus && renderLspNotice(lspStatus, role)]
             .filter(Boolean).join("\n\n") || undefined;
         const startCommand = {
             ...deps.claude.buildRoleStartCommand(role, config.claudeCommand, permissionMode, resumeClaudeSessionId, launchMode === "resume", model, effort, modelSettingsOverride, appendSystemPrompt, lspPluginDirs),

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

@@ -60,7 +60,6 @@ function degradedArtifactSummary(handoffDir) {
             architectureDiagnosisPath: `${handoffDir}/architecture-diagnosis.md`,
             testReportPath: `${handoffDir}/test-report.md`,
             docsUpdateReportPath: `${handoffDir}/docs-update-report.md`,
-            docsSyncReportPath: `${handoffDir}/docs-sync-report.md`,
             workflowProgressPath: `${handoffDir}/workflow-progress.md`,
             finalAcceptancePath: `${handoffDir}/final-acceptance.md`
         },

package/dist/backend/services/translation-worker-service.js

@@ -22,6 +22,7 @@ const MEMORY_TOTAL_LIMIT_BYTES = 80 * 1024;
 const MEMORY_INITIALIZED_MIN_FILES = 2;
 const MEMORY_FILE_NAMES = ["glossary.md", "style-guide.md", "project-context.md", "decisions.md"];
 const TRANSLATOR_ROLE = "translator";
+const QUEUE_HOOK_EVENTS = new Set(["UserPromptSubmit", "Stop", "StopFailure"]);
 const FILE_BROWSER_DEFAULT_LIMIT = 200;
 const FILE_BROWSER_MAX_LIMIT = 500;
 const FILE_BROWSER_SEARCH_MAX_DEPTH = 6;
@@ -99,6 +100,26 @@ const BINARY_LIKE_EXTENSIONS = new Set([
 export function createTranslationWorkerService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     const createId = deps.id ?? (() => randomUUID());
+    const queueLocks = new Map();
+    // Every queue and index access happens in this process. Serializing them per
+    // repository keeps concurrent load-modify-save cycles from dropping each
+    // other's updates and keeps readers out of an in-flight rename.
+    function withQueueLock(repoRoot, operation) {
+        const key = path.resolve(repoRoot);
+        const previous = queueLocks.get(key) ?? Promise.resolve();
+        const result = previous.then(operation);
+        const settled = result.then(() => undefined, () => undefined);
+        queueLocks.set(key, settled);
+        void settled.then(() => {
+            if (queueLocks.get(key) === settled) {
+                queueLocks.delete(key);
+            }
+        });
+        return result;
+    }
+    function scheduleDispatch(repoRoot) {
+        void withQueueLock(repoRoot, () => dispatchNext(repoRoot)).catch(() => undefined);
+    }
     async function ensureLayout(repoRoot) {
         await Promise.all([
             deps.fs.ensureDir(resolveRepoPath(repoRoot, MEMORY_DIR)),
@@ -917,7 +938,7 @@ export function createTranslationWorkerService(deps) {
         queue.updatedAt = now();
         await saveQueue(repoRoot, queue);
     }
-    return {
+    const service = {
         async cleanupStartupRuntime(repoRoot) {
             await removeRepoPath(repoRoot, TRANSLATIONS_RUNTIME_DIR, true);
             await cleanupStartupFileIndex(repoRoot);
@@ -1006,7 +1027,7 @@ export function createTranslationWorkerService(deps) {
             const activeExisting = (await loadRuntimeFileJobs(repoRoot)).find((job) => fileTranslationReplacementKey(job) === replacementKey &&
                 isActiveFileTranslationJobStatus(job.status));
             if (activeExisting) {
-                void dispatchNext(repoRoot);
+                scheduleDispatch(repoRoot);
                 return activeExisting;
             }
             const timestamp = now();
@@ -1106,7 +1127,7 @@ export function createTranslationWorkerService(deps) {
                 lastUpdatedAt: timestamp
             });
             await deps.fs.writeText(resolveRepoPath(repoRoot, job.reportPath), `# Translation Report\n\nStatus: queued\nJob: ${jobId}\n`);
-            void dispatchNext(repoRoot);
+            scheduleDispatch(repoRoot);
             return job;
         },
         async createBootstrapRun(repoRoot, input) {
@@ -1165,7 +1186,7 @@ export function createTranslationWorkerService(deps) {
             index.runs = [run, ...index.runs];
             index.updatedAt = timestamp;
             await saveBootstrapIndex(repoRoot, index);
-            void dispatchNext(repoRoot);
+            scheduleDispatch(repoRoot);
             return run;
         },
         async createMemoryUpdate(repoRoot, input) {
@@ -1223,7 +1244,7 @@ export function createTranslationWorkerService(deps) {
                     "Delete or merge stale, duplicate, temporary, and task-local content."
                 ]
             });
-            void dispatchNext(repoRoot);
+            scheduleDispatch(repoRoot);
             return queueItem;
         },
         async readFileJobOutput(repoRoot, jobId) {
@@ -1297,7 +1318,7 @@ export function createTranslationWorkerService(deps) {
             });
             job.queueItemId = queueItem.id;
             if (!input.deferDispatch) {
-                void dispatchNext(repoRoot);
+                scheduleDispatch(repoRoot);
             }
             return job;
         },
@@ -1410,6 +1431,23 @@ export function createTranslationWorkerService(deps) {
             });
         }
     };
+    return {
+        ...service,
+        cleanupStartupRuntime: (repoRoot) => withQueueLock(repoRoot, () => service.cleanupStartupRuntime(repoRoot)),
+        getState: (repoRoot, options) => withQueueLock(repoRoot, () => service.getState(repoRoot, options)),
+        createFileJob: (repoRoot, input) => withQueueLock(repoRoot, () => service.createFileJob(repoRoot, input)),
+        readFileJobOutput: (repoRoot, jobId) => withQueueLock(repoRoot, () => service.readFileJobOutput(repoRoot, jobId)),
+        createBootstrapRun: (repoRoot, input) => withQueueLock(repoRoot, () => service.createBootstrapRun(repoRoot, input)),
+        createMemoryUpdate: (repoRoot, input) => withQueueLock(repoRoot, () => service.createMemoryUpdate(repoRoot, input)),
+        createConversationJob: (repoRoot, input) => withQueueLock(repoRoot, () => service.createConversationJob(repoRoot, input)),
+        validateConversationResult: (repoRoot, input) => withQueueLock(repoRoot, () => service.validateConversationResult(repoRoot, input)),
+        promoteFileJob: (repoRoot, jobId, targetPath) => withQueueLock(repoRoot, () => service.promoteFileJob(repoRoot, jobId, targetPath)),
+        // Only the events that touch the queue wait for the lock, so a SessionStart
+        // hook fired while a dispatch is starting the Translator never waits on it.
+        handleTranslatorHook: (repoRoot, eventName, taskSlug) => QUEUE_HOOK_EVENTS.has(eventName)
+            ? withQueueLock(repoRoot, () => service.handleTranslatorHook(repoRoot, eventName, taskSlug))
+            : service.handleTranslatorHook(repoRoot, eventName, taskSlug)
+    };
 }
 function requireTranslationTaskSlug(value) {
     const taskSlug = value?.trim();