vibe-coding-master 0.7.36 → 0.7.37

package/README.md

@@ -455,6 +455,7 @@ Harness Studio is the UI for VCM harness maintenance.
 Use it to:
 
 - inspect fixed harness status
+- inspect detected project languages and verified language-server readiness
 - run bootstrap
 - open Harness Engineer
 - review harness files
@@ -466,6 +467,13 @@ 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 for Architect, Coder, and
+Reviewer sessions, including CCR launches. The project environment must still
+provide the language server for each detected language: `rust-analyzer`,
+`typescript-language-server`, `pyright-langserver`, `gopls`, `clangd`, or
+`jdtls`. Harness Studio reports a missing executable or failed startup probe
+with the backend diagnostic.
+
 Harness Engineer is task-scoped and runs from the active task worktree. The
 backend automatically starts a fresh Harness Engineer for each active task or
 resumes its saved Session. Durable memory is versioned with the project harness

package/dist/backend/adapters/claude-adapter.js

@@ -18,8 +18,9 @@ export function createClaudeAdapter(runner) {
             }
             return result.stdout.trim();
         },
-        buildRoleStartCommand(role, command = "claude", permissionMode = "default", claudeSessionId, resume = false, model = "default", effort = "default", settingsOverride, appendSystemPrompt) {
-            const args = ["--agent", role];
+        buildRoleStartCommand(role, command = "claude", permissionMode = "default", claudeSessionId, resume = false, model = "default", effort = "default", settingsOverride, appendSystemPrompt, pluginDirs = []) {
+            const args = pluginDirs.flatMap((pluginDir) => ["--plugin-dir", pluginDir]);
+            args.push("--agent", role);
             const sessionSettings = { ...settingsOverride };
             if (claudeSessionId) {
                 args.push(resume ? "--resume" : "--session-id", claudeSessionId);

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

@@ -6,6 +6,7 @@ export function createCommandRunner() {
                 const result = await execa(command, args, {
                     cwd: options.cwd,
                     env: options.env,
+                    timeout: options.timeoutMs,
                     reject: false
                 });
                 return {

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

@@ -20,6 +20,7 @@ import { renderProjectManagerHarnessRules } from "../templates/harness/project-m
 import { renderPullRequestTemplateHarnessRules } from "../templates/harness/pull-request-template.js";
 import { renderTesterHarnessRules } from "../templates/harness/tester-agent.js";
 import { renderVcmArchitectureInterviewSkillRules } from "../templates/harness/vcm-architecture-interview-skill.js";
+import { renderVcmCodeNavigationSkillRules } from "../templates/harness/vcm-code-navigation-skill.js";
 import { renderVcmFinalAcceptanceSkillRules } from "../templates/harness/vcm-final-acceptance-skill.js";
 import { renderVcmHarnessBootstrapSkillRules } from "../templates/harness/vcm-harness-bootstrap-skill.js";
 import { renderVcmLongRunningValidationSkillRules } from "../templates/harness/vcm-long-running-validation-skill.js";
@@ -64,18 +65,18 @@ const AGENT_FRONTMATTER = {
     },
     architect: {
         description: "VCM architecture role for plans, module boundaries, public contracts, verifiable behavior, and docs sync.",
-        tools: "Read, Grep, Glob, Bash, Edit, Write, Agent"
+        tools: "Read, Grep, Glob, Bash, Edit, Write, Agent, LSP"
     },
     coder: {
         description: "VCM implementation role for scoped code changes and focused tests.",
-        tools: "Read, Grep, Glob, Bash, Edit, Write, Agent"
+        tools: "Read, Grep, Glob, Bash, Edit, Write, Agent, LSP"
     },
     tester: {
         description: "VCM testing role for validation, test adequacy, approved-scope validation, and risk findings."
     },
     reviewer: {
         description: "VCM independent gate review role for architecture plans, validation adequacy, and code diffs.",
-        tools: "Read, Grep, Glob, Bash, Write"
+        tools: "Read, Grep, Glob, Bash, Write, LSP"
     },
     translator: {
         description: "VCM task-scoped translation tool role for conversation translation, file translation, bootstrap, and memory updates."
@@ -93,6 +94,11 @@ const AGENT_FRONTMATTER = {
         effort: "xhigh"
     }
 };
+const REQUIRED_AGENT_TOOLS = {
+    architect: ["Agent", "LSP"],
+    coder: ["Agent", "LSP"],
+    reviewer: ["LSP"]
+};
 const MANAGED_FILES = [
     {
         path: "CLAUDE.md",
@@ -256,6 +262,12 @@ const WHOLE_FILES = [
         mode: 0o644,
         content: renderSkillFile("VCM Architecture Interview Skill", "vcm-architecture-interview", "Use when Architect must confirm user-owned behavior and contract decisions before architecture planning.", renderVcmArchitectureInterviewSkillRules())
     },
+    {
+        path: ".claude/skills/vcm-code-navigation/SKILL.md",
+        category: "skill",
+        mode: 0o644,
+        content: renderSkillFile("VCM Code Navigation Skill", "vcm-code-navigation", "Use when Architect or Reviewer must resolve code symbols, references, implementations, call hierarchies, or bounded dependency paths.", renderVcmCodeNavigationSkillRules())
+    },
     {
         path: ".claude/skills/vcm-final-acceptance/SKILL.md",
         category: "skill",
@@ -657,8 +669,8 @@ async function installManagedFile({ projectRoot, definition, dryRun, operations
     if (definition.memoryBlock) {
         nextContent = ensureVcmMemoryBlock(nextContent);
     }
-    if (definition.agentName === "architect") {
-        nextContent = ensureAgentTool(nextContent, "Agent");
+    for (const requiredTool of REQUIRED_AGENT_TOOLS[definition.agentName] ?? []) {
+        nextContent = ensureAgentTool(nextContent, requiredTool);
     }
     await writeIfChanged({
         targetPath,

package/dist/backend/server.js

@@ -246,6 +246,7 @@ export function createDefaultServerDeps(options = {}) {
     });
     const harnessService = createHarnessService({
         fs,
+        commandRunner: runner,
         git,
         runtime,
         harnessEngineerSessions: sessionService,

package/dist/backend/services/code-intelligence-service.js

@@ -0,0 +1,253 @@
+import path from "node:path";
+import { VCM_LSP_PLUGIN_DIR, VCM_LSP_PLUGIN_MANIFEST, VCM_LSP_PLUGIN_NAME } from "./lsp-plugin.js";
+const LANGUAGE_DEFINITIONS = [
+    {
+        language: "rust",
+        label: "Rust",
+        extensions: [".rs"],
+        manifests: ["Cargo.toml"],
+        serverCommand: "rust-analyzer",
+        pluginServerName: "rust-analyzer",
+        probeArgs: ["--version"]
+    },
+    {
+        language: "typescript",
+        label: "TypeScript / JavaScript",
+        extensions: [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs"],
+        manifests: ["package.json", "tsconfig.json", "jsconfig.json"],
+        serverCommand: "typescript-language-server",
+        pluginServerName: "typescript",
+        probeArgs: ["--version"]
+    },
+    {
+        language: "python",
+        label: "Python",
+        extensions: [".py", ".pyi"],
+        manifests: ["pyproject.toml", "requirements.txt", "setup.py"],
+        serverCommand: "pyright-langserver",
+        pluginServerName: "pyright",
+        probeArgs: ["--version"]
+    },
+    {
+        language: "go",
+        label: "Go",
+        extensions: [".go"],
+        manifests: ["go.mod"],
+        serverCommand: "gopls",
+        pluginServerName: "gopls",
+        probeArgs: ["version"]
+    },
+    {
+        language: "cpp",
+        label: "C / C++",
+        extensions: [".c", ".cc", ".cpp", ".cxx", ".h", ".hh", ".hpp", ".hxx"],
+        manifests: ["CMakeLists.txt", "compile_commands.json"],
+        serverCommand: "clangd",
+        pluginServerName: "clangd",
+        probeArgs: ["--version"]
+    },
+    {
+        language: "java",
+        label: "Java",
+        extensions: [".java"],
+        manifests: ["pom.xml", "build.gradle", "build.gradle.kts", "settings.gradle", "settings.gradle.kts"],
+        serverCommand: "jdtls",
+        pluginServerName: "jdtls",
+        probeArgs: ["--version"]
+    }
+];
+const DEFAULT_PROBE_TIMEOUT_MS = 3_000;
+const DEFAULT_CACHE_TTL_MS = 60_000;
+export function createHarnessCodeIntelligenceDetector(fs, options = {}) {
+    const probeCache = new Map();
+    const probesInFlight = new Map();
+    const now = options.now ?? Date.now;
+    const cacheTtlMs = options.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
+    return {
+        async detect(repoRoot) {
+            return detectCodeIntelligence(fs, repoRoot, options, async (definition, executablePath) => {
+                const cacheKey = `${executablePath}\u0000${definition.probeArgs.join("\u0000")}`;
+                const cached = probeCache.get(cacheKey);
+                const currentTime = now();
+                if (cached && cached.expiresAt > currentTime) {
+                    return cached.result;
+                }
+                if (!options.runner) {
+                    return undefined;
+                }
+                const existingProbe = probesInFlight.get(cacheKey);
+                if (existingProbe) {
+                    return existingProbe;
+                }
+                const probePromise = options.runner.run(executablePath, definition.probeArgs, {
+                    cwd: repoRoot,
+                    timeoutMs: options.probeTimeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS
+                });
+                probesInFlight.set(cacheKey, probePromise);
+                const result = await probePromise.finally(() => probesInFlight.delete(cacheKey));
+                probeCache.set(cacheKey, {
+                    expiresAt: currentTime + cacheTtlMs,
+                    result
+                });
+                return result;
+            });
+        }
+    };
+}
+export async function detectHarnessCodeIntelligence(fs, repoRoot, options = {}) {
+    return createHarnessCodeIntelligenceDetector(fs, options).detect(repoRoot);
+}
+async function detectCodeIntelligence(fs, repoRoot, options, probe) {
+    const indexPaths = await readModuleIndexPaths(fs, repoRoot);
+    const pluginServers = await readPluginServers(fs, options.pluginDir ?? VCM_LSP_PLUGIN_DIR);
+    const detectedLanguages = await Promise.all(LANGUAGE_DEFINITIONS.map(async (definition) => {
+        const detectedBy = await detectLanguage(fs, repoRoot, indexPaths, definition);
+        if (detectedBy.length === 0) {
+            return undefined;
+        }
+        const pluginReady = pluginServers.get(definition.pluginServerName) === definition.serverCommand;
+        const executablePath = await findExecutable(fs, repoRoot, definition.serverCommand, options);
+        const probeResult = executablePath ? await probe(definition, executablePath) : undefined;
+        const serverFound = Boolean(executablePath);
+        const serverRunnable = probeResult?.exitCode === 0;
+        const state = languageState(pluginReady, serverFound, serverRunnable, Boolean(probeResult));
+        const status = {
+            language: definition.language,
+            label: definition.label,
+            serverCommand: definition.serverCommand,
+            pluginName: VCM_LSP_PLUGIN_NAME,
+            detected: true,
+            pluginReady,
+            serverFound,
+            serverRunnable,
+            state,
+            error: languageError(state, definition.serverCommand, probeResult),
+            detectedBy
+        };
+        return status;
+    }));
+    const languages = detectedLanguages.filter((language) => language !== undefined);
+    const readyCount = languages.filter((language) => language.state === "ready").length;
+    return {
+        state: languages.length === 0
+            ? "not_detected"
+            : readyCount === languages.length
+                ? "ready"
+                : readyCount === 0
+                    ? "missing"
+                    : "partial",
+        languages
+    };
+}
+function languageState(pluginReady, serverFound, serverRunnable, probeCompleted) {
+    if (!pluginReady) {
+        return "plugin_missing";
+    }
+    if (!serverFound) {
+        return "server_missing";
+    }
+    if (!probeCompleted) {
+        return "server_unverified";
+    }
+    return serverRunnable ? "ready" : "server_failed";
+}
+function languageError(state, command, probeResult) {
+    if (state === "plugin_missing") {
+        return `VCM LSP plugin manifest is missing or does not declare ${command}.`;
+    }
+    if (state === "server_missing") {
+        return `${command} was not found in the VCM backend PATH.`;
+    }
+    if (state === "server_unverified") {
+        return `${command} was found but has not been probed by this runtime.`;
+    }
+    if (state !== "server_failed") {
+        return undefined;
+    }
+    const detail = firstNonEmptyLine(probeResult?.stderr, probeResult?.stdout);
+    return detail
+        ? `${command} failed its startup probe. ${detail}`
+        : `${command} failed its startup probe with exit code ${probeResult?.exitCode ?? 1}.`;
+}
+async function readPluginServers(fs, pluginDir) {
+    const manifestPath = pluginDir === VCM_LSP_PLUGIN_DIR
+        ? VCM_LSP_PLUGIN_MANIFEST
+        : path.join(pluginDir, ".claude-plugin", "plugin.json");
+    if (!await fs.pathExists(manifestPath)) {
+        return new Map();
+    }
+    try {
+        const manifest = await fs.readJson(manifestPath);
+        return new Map(Object.entries(manifest.lspServers ?? {})
+            .filter((entry) => typeof entry[1]?.command === "string")
+            .map(([name, server]) => [name, server.command]));
+    }
+    catch {
+        return new Map();
+    }
+}
+async function readModuleIndexPaths(fs, repoRoot) {
+    const indexPath = path.join(repoRoot, ".ai/generated/module-index.json");
+    if (!await fs.pathExists(indexPath)) {
+        return [];
+    }
+    try {
+        const value = await fs.readJson(indexPath);
+        return collectPathLikeStrings(value);
+    }
+    catch {
+        return [];
+    }
+}
+async function detectLanguage(fs, repoRoot, indexPaths, definition) {
+    const evidence = new Set();
+    for (const manifest of definition.manifests) {
+        if (await fs.pathExists(path.join(repoRoot, manifest))) {
+            evidence.add(manifest);
+        }
+    }
+    for (const filePath of indexPaths) {
+        if (definition.extensions.includes(path.extname(filePath).toLowerCase())) {
+            evidence.add(".ai/generated/module-index.json");
+            break;
+        }
+    }
+    return Array.from(evidence);
+}
+async function findExecutable(fs, repoRoot, command, options) {
+    const platform = options.platform ?? process.platform;
+    const pathEnv = options.pathEnv ?? process.env.PATH ?? "";
+    const extensions = platform === "win32"
+        ? (options.pathExt ?? process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";")
+        : [""];
+    for (const directory of pathEnv.split(path.delimiter)) {
+        for (const extension of extensions) {
+            const candidate = path.resolve(directory || repoRoot, `${command}${extension.toLowerCase()}`);
+            if (await fs.pathExists(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    return undefined;
+}
+function firstNonEmptyLine(...values) {
+    for (const value of values) {
+        const line = value?.split(/\r?\n/).map((part) => part.trim()).find(Boolean);
+        if (line) {
+            return line.length > 300 ? `${line.slice(0, 297)}...` : line;
+        }
+    }
+    return undefined;
+}
+function collectPathLikeStrings(value) {
+    if (typeof value === "string") {
+        return value.includes("/") || path.extname(value) ? [value] : [];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap(collectPathLikeStrings);
+    }
+    if (value && typeof value === "object") {
+        return Object.values(value).flatMap(collectPathLikeStrings);
+    }
+    return [];
+}

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

@@ -17,6 +17,7 @@ import { renderProjectManagerHarnessRules } from "../templates/harness/project-m
 import { renderPullRequestTemplateHarnessRules } from "../templates/harness/pull-request-template.js";
 import { renderTesterHarnessRules } from "../templates/harness/tester-agent.js";
 import { renderVcmArchitectureInterviewSkillRules } from "../templates/harness/vcm-architecture-interview-skill.js";
+import { renderVcmCodeNavigationSkillRules } from "../templates/harness/vcm-code-navigation-skill.js";
 import { renderVcmFinalAcceptanceSkillRules } from "../templates/harness/vcm-final-acceptance-skill.js";
 import { renderVcmHarnessBootstrapSkillRules } from "../templates/harness/vcm-harness-bootstrap-skill.js";
 import { renderVcmLongRunningValidationSkillRules } from "../templates/harness/vcm-long-running-validation-skill.js";
@@ -29,6 +30,7 @@ import { renderRequestArchitectRestartTool, renderRestartArchitectSkillRules } f
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { VcmError } from "../errors.js";
 import { bumpHarnessRevision, readHarnessRevisionState } from "./harness-revision.js";
+import { createHarnessCodeIntelligenceDetector } from "./code-intelligence-service.js";
 const execFileAsync = promisify(execFile);
 const BOOTSTRAP_SESSION_PATH = ".ai/vcm/bootstrap/session.json";
 const HARNESS_ENGINEER_SESSION_PATH = ".ai/vcm/harness-engineer/session.json";
@@ -110,6 +112,14 @@ const HARNESS_FILES = [
         ownership: "whole-file",
         renderRules: renderVcmArchitectureInterviewSkillRules
     },
+    {
+        kind: "skill-vcm-code-navigation",
+        path: ".claude/skills/vcm-code-navigation/SKILL.md",
+        title: "VCM Code Navigation Skill",
+        frontmatter: renderSkillFrontmatter("vcm-code-navigation", "Use when Architect or Reviewer must resolve code symbols, references, implementations, call hierarchies, or bounded dependency paths."),
+        ownership: "whole-file",
+        renderRules: renderVcmCodeNavigationSkillRules
+    },
     {
         kind: "skill-vcm-route-message",
         path: ".claude/skills/vcm-route-message/SKILL.md",
@@ -187,7 +197,8 @@ const HARNESS_FILES = [
         path: ".claude/agents/reviewer.md",
         title: "Reviewer Agent",
         memoryBlock: true,
-        frontmatter: renderAgentFrontmatter("reviewer", "VCM independent gate review role for architecture plans, validation adequacy, and code diffs.", { tools: "Read, Grep, Glob, Bash, Write" }),
+        requiredTools: ["LSP"],
+        frontmatter: renderAgentFrontmatter("reviewer", "VCM independent gate review role for architecture plans, validation adequacy, and code diffs.", { tools: "Read, Grep, Glob, Bash, Write, LSP" }),
         renderRules: renderReviewerAgentRules
     },
     {
@@ -260,8 +271,9 @@ const HARNESS_FILES = [
         path: ".claude/agents/architect.md",
         title: "Architect Agent",
         memoryBlock: true,
+        requiredTools: ["Agent", "LSP"],
         blankLineBeforeEnd: true,
-        frontmatter: renderAgentFrontmatter("architect", "VCM architecture role for plans, module boundaries, public contracts, verifiable behavior, and docs sync.", { tools: "Read, Grep, Glob, Bash, Edit, Write, Agent" }),
+        frontmatter: renderAgentFrontmatter("architect", "VCM architecture role for plans, module boundaries, public contracts, verifiable behavior, and docs sync.", { tools: "Read, Grep, Glob, Bash, Edit, Write, Agent, LSP" }),
         renderRules: renderArchitectHarnessRules
     },
     {
@@ -269,7 +281,8 @@ const HARNESS_FILES = [
         path: ".claude/agents/coder.md",
         title: "Coder Agent",
         memoryBlock: true,
-        frontmatter: renderAgentFrontmatter("coder", "VCM implementation role for scoped code changes and focused tests.", { tools: "Read, Grep, Glob, Bash, Edit, Write, Agent" }),
+        requiredTools: ["Agent", "LSP"],
+        frontmatter: renderAgentFrontmatter("coder", "VCM implementation role for scoped code changes and focused tests.", { tools: "Read, Grep, Glob, Bash, Edit, Write, Agent, LSP" }),
         renderRules: renderCoderHarnessRules
     },
     {
@@ -284,14 +297,20 @@ const HARNESS_FILES = [
 export function createHarnessService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     const vcmVersion = deps.vcmVersion ?? "unknown";
+    const codeIntelligenceDetector = createHarnessCodeIntelligenceDetector(deps.fs, {
+        runner: deps.commandRunner
+    });
     return {
         async getHarnessStatus(repoRoot) {
-            const analyses = await analyzeHarnessFiles(deps.fs, repoRoot);
+            const [analyses, codeIntelligence] = await Promise.all([
+                analyzeHarnessFiles(deps.fs, repoRoot),
+                codeIntelligenceDetector.detect(repoRoot)
+            ]);
             const legacyChanges = await analyzeLegacyCodexHarnessPaths(deps.fs, repoRoot);
             const manifestChange = deps.runFixedInstaller
                 ? await analyzeHarnessManifest(deps.fs, repoRoot, vcmVersion)
                 : undefined;
-            return renderHarnessStatus(await readHarnessRevisionValue(deps.fs, repoRoot), analyses, legacyChanges, manifestChange);
+            return renderHarnessStatus(await readHarnessRevisionValue(deps.fs, repoRoot), analyses, legacyChanges, manifestChange, codeIntelligence);
         },
         async getHarnessFileContent(repoRoot, filePath) {
             return readHarnessFileContent(deps.fs, repoRoot, filePath);
@@ -320,14 +339,17 @@ export function createHarnessService(deps) {
                 harnessCommit = (await commitHarnessVisibleChanges(deps.git, repoRoot, "chore(vcm-harness): update harness file")).harnessCommit;
             }
             const file = await readHarnessFileContent(deps.fs, repoRoot, definition.path);
-            const analyses = await analyzeHarnessFiles(deps.fs, repoRoot);
+            const [analyses, codeIntelligence] = await Promise.all([
+                analyzeHarnessFiles(deps.fs, repoRoot),
+                codeIntelligenceDetector.detect(repoRoot)
+            ]);
             const legacyChanges = await analyzeLegacyCodexHarnessPaths(deps.fs, repoRoot);
             const manifestChange = deps.runFixedInstaller
                 ? await analyzeHarnessManifest(deps.fs, repoRoot, vcmVersion)
                 : undefined;
             return {
                 file,
-                status: renderHarnessStatus(await readHarnessRevisionValue(deps.fs, repoRoot), analyses, legacyChanges, manifestChange),
+                status: renderHarnessStatus(await readHarnessRevisionValue(deps.fs, repoRoot), analyses, legacyChanges, manifestChange, codeIntelligence),
                 harnessCommit
             };
         },
@@ -1197,7 +1219,8 @@ async function analyzeHarnessFile(fs, repoRoot, definition) {
     if (!match) {
         const migratedContent = migrateLegacyHarnessFile(definition, currentContent, expectedBlock);
         if (migratedContent) {
-            const nextContent = definition.memoryBlock ? ensureVcmMemoryBlock(migratedContent) : migratedContent;
+            const memoryUpdatedContent = definition.memoryBlock ? ensureVcmMemoryBlock(migratedContent) : migratedContent;
+            const nextContent = ensureAgentTools(memoryUpdatedContent, definition.requiredTools);
             return {
                 definition,
                 status: {
@@ -1216,9 +1239,7 @@ async function analyzeHarnessFile(fs, repoRoot, definition) {
             };
         }
         const insertedContent = `${currentContent.trimEnd()}\n\n${expectedBlock}\n`;
-        const nextContent = definition.kind === "agent-architect"
-            ? ensureAgentTool(insertedContent, "Agent")
-            : insertedContent;
+        const nextContent = ensureAgentTools(insertedContent, definition.requiredTools);
         return {
             definition,
             status: {
@@ -1240,9 +1261,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 = definition.kind === "agent-architect"
-        ? ensureAgentTool(memoryUpdatedContent, "Agent")
-        : memoryUpdatedContent;
+    const nextContent = ensureAgentTools(memoryUpdatedContent, definition.requiredTools);
     const action = currentContent === nextContent ? "ok" : "update";
     return {
         definition,
@@ -1300,7 +1319,7 @@ async function removeLegacyCodexHarnessPaths(fs, repoRoot) {
     }
     return changes;
 }
-function renderHarnessStatus(harnessRevision, analyses, legacyChanges = [], manifestChange) {
+function renderHarnessStatus(harnessRevision, analyses, legacyChanges = [], manifestChange, codeIntelligence) {
     const files = analyses.map((analysis) => analysis.status);
     const plannedChanges = analyses
         .map((analysis) => analysis.plannedChange)
@@ -1326,6 +1345,7 @@ function renderHarnessStatus(harnessRevision, analyses, legacyChanges = [], mani
         files,
         needsApply: plannedChanges.length > 0,
         plannedChanges,
+        codeIntelligence,
         warnings: plannedChanges.length > 0
             ? ["Review and commit VCM Harness changes before starting long-running work."]
             : []
@@ -1369,6 +1389,9 @@ function ensureAgentTool(content, requiredTool) {
     const nextTools = [...tools, requiredTool].join(", ");
     return content.replace(frontmatterMatch[0], frontmatterMatch[0].replace(toolsMatch[0], `tools: ${nextTools}`));
 }
+function ensureAgentTools(content, requiredTools) {
+    return (requiredTools ?? []).reduce(ensureAgentTool, content);
+}
 function migrateLegacyHarnessFile(definition, currentContent, block) {
     const legacyContent = definition.legacyWholeFile?.trimEnd();
     if (!legacyContent) {

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

@@ -0,0 +1,9 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+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");
+const LSP_ROLES = new Set(["architect", "coder", "reviewer"]);
+export function roleUsesLsp(role) {
+    return LSP_ROLES.has(role);
+}

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

@@ -8,6 +8,7 @@ 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, VCM_LSP_PLUGIN_DIR } from "./lsp-plugin.js";
 const TRANSLATOR_ROLE = "translator";
 const HARNESS_ENGINEER_ROLE = "harness-engineer";
 const TRANSLATION_DIR = ".ai/vcm/translations";
@@ -82,7 +83,7 @@ export function createSessionService(deps) {
                 ? claudeTranscriptPath(taskRepoRoot, resumeClaudeSessionId, persisted?.claudeConfigDir)
                 : undefined;
         const startCommand = {
-            ...deps.claude.buildRoleStartCommand(role, config.claudeCommand, permissionMode, resumeClaudeSessionId, launchMode === "resume", model, effort, modelSettingsOverride, input.appendSystemPrompt),
+            ...deps.claude.buildRoleStartCommand(role, config.claudeCommand, permissionMode, resumeClaudeSessionId, launchMode === "resume", model, effort, modelSettingsOverride, input.appendSystemPrompt, roleUsesLsp(role) ? [VCM_LSP_PLUGIN_DIR] : []),
             cwd: taskRepoRoot
         };
         const runtimeSessionToken = randomUUID();
@@ -101,7 +102,10 @@ export function createSessionService(deps) {
                 VCM_ROLE: role,
                 VCM_SESSION_ID: claudeSessionId || undefined,
                 VCM_RUNTIME_SESSION_TOKEN: runtimeSessionToken
-            }, modelEnvironment, buildUsageTelemetryEnvironment(deps.apiUrl, role, model)),
+            }, modelEnvironment, {
+                ...buildUsageTelemetryEnvironment(deps.apiUrl, role, model),
+                ...(roleUsesLsp(role) ? { ENABLE_LSP_TOOL: "true" } : {})
+            }),
             cols: input.cols,
             rows: input.rows
         });

package/dist/backend/templates/harness/architect-agent.js

@@ -19,6 +19,13 @@ ${renderRoleMemoryRules("architect")}
 - In Debug Mode and Architecture Diagnosis Mode, writing baseline unit tests for changed code and running required L0/L1 plus applicable L2/L3 checks are part of the implementation duty; tester still owns final validation.
 - Do not make product priority or approval decisions; route those questions back to project-manager.
 
+### Work Persistence
+
+- Treat Architect artifacts, not Session memory, as continuation state.
+- Write each verified code fact, confirmed user decision, architecture decision, root cause, and validation result to its owning artifact as soon as it becomes an input to later work.
+- Before ending any turn, ensure all information required to continue the current Architect work is present in the current artifacts.
+- Keep artifacts current and self-contained. Replace superseded content instead of appending conversation history or investigation logs.
+
 ### Architecture Interview
 
 - Before the first Architecture Planning step of Code-Change Flow, use \`vcm-architecture-interview\` and complete \`.ai/vcm/handoffs/architecture-brief.md\` and \`.ai/vcm/handoffs/architecture-evidence.md\`.
@@ -38,6 +45,9 @@ ${renderRoleMemoryRules("architect")}
 ### Planning Code Reading
 
 - Do not plan from session memory, architecture docs, generated context, or code comments alone. Re-read current-worktree source and verify actual behavior from implementation.
+- Use \`vcm-code-navigation\` for symbol definitions, implementations, references, call hierarchies, and bounded behavior paths. Start from generated indexes, use LSP semantic navigation when available, then read every resolved callable unit in full.
+- Use structural search when available and Grep for dynamic registrations, configuration or string edges, macros not resolved by LSP, documentation, and explicit fallback discovery. When LSP is available, do not treat Grep as proof of a complete symbol, caller, implementation, or reference set.
+- If LSP is unavailable or cannot resolve a required relationship, record the limitation and exact fallback evidence in \`architecture-evidence.md\`; do not claim compiler-accurate completeness from text search alone.
 - Define the planning boundary as the affected feature or module and identify every existing or intended observable entry point for the behavior being changed.
 - Read the complete implementation of each relevant existing entry point.
 - Follow every project-owned call path the plan will change through cross-module calls, state reads and writes, persistence, side effects, completion and failure signals, and consumers.
@@ -66,6 +76,8 @@ ${renderRoleMemoryRules("architect")}
 - When starting architecture planning, first write an \`Architecture Evidence Verification\` row to \`.ai/vcm/handoffs/planning-progress.md\`, with the evidence artifact, verified worktree revision, done criterion, and status. Complete it by checking that the evidence covers the accepted feature boundary and still matches the current worktree.
 - After \`Architecture Evidence Verification\` is complete, add the remaining planning steps: one head step for cross-module work (architecture decision, boundaries, ownership, invariants, build-configuration proofs), one middle step per affected module from the module index in dependency order — split a module into per-file steps when it exceeds one round — and one tail step for cross-module wiring, whole-plan ledger reconciliation, and final build evidence. A small task degrades to head, one middle step, and tail.
 - Bind every step to repository facts and machine checks: scope is module or file paths from the module index; deliverable is plan sections or ledger ID ranges; done criterion is a tool output or recorded check result — never a self-assessment.
+- Complete a planning step only after its architecture conclusions, affected files, callable surfaces, ledger items, risks, and evidence references have been written to the corresponding sections of \`architecture-plan.md\`.
+- Update \`architecture-plan.md\` before marking the corresponding \`planning-progress.md\` step complete. A conclusion that exists only in Session context is not completed planning work.
 - Update \`planning-progress.md\` at the end of every planning round: mark completed steps with their evidence and leave remaining steps unchanged. Do not shrink, merge, or drop a remaining step without recording the change and its reason.
 - If the round ends before all steps are done, report \`Planning Result: incomplete\` with the progress record; project-manager routes continuation. Never compress remaining enumeration or scaffolding into summary rows to reach \`Planning Result: complete\` within the current round — an honest \`incomplete\` with recorded progress is the required outcome.
 - \`planning-progress.md\` is task-runtime state for continuation and routing, not part of the reviewed plan; \`architecture-plan.md\` alone remains the executable plan of record.
@@ -135,6 +147,8 @@ ${renderRoleMemoryRules("architect")}
 ### Debug Mode
 
 - Project-manager may route bugs, failing tests, build/runtime failures, or unclear defects directly to architect Debug Mode.
+- Maintain \`architect-debug.md\` throughout Debug Mode. Record the triggering failure and diagnostic evidence while investigating, write the confirmed root cause before implementing the fix, and add implementation and validation evidence as each stage completes.
+- Do not postpone the first durable Debug record until the final handoff.
 - Architect may read source/tests, edit code, and run focused diagnostics until root cause is known. Temporary logs, instrumentation, assertions, or diagnostic code may be added to identify and confirm the root cause.
 - Once the root cause is confirmed, architect owns the technical change boundary for the fix. Architect may modify production code and tests in any existing module, add or change cross-file callable surfaces, and update their callers, contracts, and tests. No pre-approved module or file list limits Debug Mode implementation.
 - When editing production code or tests in Debug Mode, read and follow \`docs/CODING_STANDARDS.md\`.
@@ -164,6 +178,7 @@ Do not assume existing code or comments are correct. Read the implementation to
 Before choosing or implementing a fix:
 
 - Define the affected feature or module and identify every observable entry point for the failing behavior.
+- Use \`vcm-code-navigation\` to resolve definitions, implementations, references, callers, callees, and call hierarchy before following the complete implementation path.
 - Read the relevant project and module architecture documents, public contracts, generated context, tests, handoff artifacts, and runtime evidence.
 - Starting from each entry point, read the complete implementation of every reachable project-owned function, method, handler, callback, or command.
 - Recursively follow every project-owned call until no unresolved project-owned callee remains. Read each symbol once and record recursive or cyclic calls.
@@ -175,8 +190,8 @@ Before choosing or implementing a fix:
 
 Maintain a \`Code Reading Closure\` in \`.ai/vcm/handoffs/architecture-diagnosis.md\`:
 
-| Symbol | File | Called By | Calls | State Read/Written | Side Effects | Status |
-|---|---|---|---|---|---|---|
+| Symbol | Definition | Implementations | Called By | Calls | State Read/Written | Side Effects | Resolution Evidence | Status |
+|---|---|---|---|---|---|---|---|---|
 
 \`Status\` must be \`read\`, \`external-boundary\`, or \`generated-boundary\`.
 
@@ -187,10 +202,15 @@ The code-reading phase is complete only when:
 - every indirect callback, event, hook, queue, route, and dynamic dispatch path has been resolved
 - every relevant state reader and writer has been read
 - every relevant cross-file surface caller and consumer has been read
+- every semantic relationship records LSP, structural-search, Grep-fallback, runtime, external-boundary, or generated-boundary evidence
 - no unresolved project-owned symbol remains
 
 Do not diagnose the root cause or choose a fix before the Code Reading Closure is complete.
 
+After Code Reading Closure is complete, write \`Current Architecture\`, \`Failure Trace\`, \`Architecture Assessment\`, and \`Required Architecture Direction\` before modifying code.
+
+Update \`Implementation And Validation\` as implementation and validation stages complete. Do not keep the diagnosis direction or completed validation evidence only in Session context.
+
 After completing the code-reading closure, reconstruct and analyze:
 
 - **Ownership:** owners of state, decisions, lifecycle transitions, side effects, and durable artifacts.