vibe-coding-master 0.7.36 → 0.7.38

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,16 @@ 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`. Architect, Coder, and Reviewer do not receive the Grep tool, and the
+Harness guard rejects shell text-search commands for those roles so unresolved
+semantic relationships cannot be hidden by textual fallback. Harness Studio
+reports a missing executable or failed readiness 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";
@@ -52,6 +53,7 @@ const VCM_BASH_DEFAULT_TIMEOUT_MS = "600000";
 const VCM_AUTO_MEMORY_ENABLED = false;
 const VCM_HOOK_DEFINITIONS = [
     { eventName: "PreToolUse", matcher: "Bash", command: VCM_BASH_GUARD_HOOK_COMMAND, timeout: 10 },
+    { eventName: "PreToolUse", matcher: "Grep", command: VCM_BASH_GUARD_HOOK_COMMAND, timeout: 10 },
     { eventName: "UserPromptSubmit", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "Stop", command: VCM_STOP_HOOK_COMMAND, timeout: 10 },
     { eventName: "StopFailure", command: VCM_HOOK_COMMAND, timeout: 5 },
@@ -64,18 +66,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, 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, 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, Glob, Bash, Write, LSP"
     },
     translator: {
         description: "VCM task-scoped translation tool role for conversation translation, file translation, bootstrap, and memory updates."
@@ -93,6 +95,16 @@ const AGENT_FRONTMATTER = {
         effort: "xhigh"
     }
 };
+const REQUIRED_AGENT_TOOLS = {
+    architect: ["Agent", "LSP"],
+    coder: ["Agent", "LSP"],
+    reviewer: ["LSP"]
+};
+const FORBIDDEN_AGENT_TOOLS = {
+    architect: ["Grep"],
+    coder: ["Grep"],
+    reviewer: ["Grep"]
+};
 const MANAGED_FILES = [
     {
         path: "CLAUDE.md",
@@ -256,6 +268,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, Coder, 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 +675,11 @@ 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);
+    }
+    for (const forbiddenTool of FORBIDDEN_AGENT_TOOLS[definition.agentName] ?? []) {
+        nextContent = removeAgentTool(nextContent, forbiddenTool);
     }
     await writeIfChanged({
         targetPath,
@@ -722,6 +743,22 @@ function ensureAgentTool(content, requiredTool) {
     const nextTools = [...tools, requiredTool].join(", ");
     return content.replace(frontmatterMatch[0], frontmatterMatch[0].replace(toolsMatch[0], `tools: ${nextTools}`));
 }
+function removeAgentTool(content, forbiddenTool) {
+    const frontmatterMatch = content.match(/^---\r?\n[\s\S]*?\r?\n---/);
+    if (!frontmatterMatch) {
+        return content;
+    }
+    const toolsMatch = frontmatterMatch[0].match(/^tools:\s*(.*)$/m);
+    if (!toolsMatch) {
+        return content;
+    }
+    const tools = toolsMatch[1].split(",").map((tool) => tool.trim()).filter(Boolean);
+    const nextTools = tools.filter((tool) => tool !== forbiddenTool);
+    if (nextTools.length === tools.length) {
+        return content;
+    }
+    return content.replace(frontmatterMatch[0], frontmatterMatch[0].replace(toolsMatch[0], `tools: ${nextTools.join(", ")}`));
+}
 function migrateLegacyManagedFile(definition, currentContent, block) {
     const legacyContent = definition.legacyWholeFile?.trimEnd();
     if (!legacyContent) {

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";
@@ -51,6 +53,7 @@ const VCM_BASH_DEFAULT_TIMEOUT_MS = "600000";
 const VCM_AUTO_MEMORY_ENABLED = false;
 const VCM_HOOK_DEFINITIONS = [
     { eventName: "PreToolUse", matcher: "Bash", command: VCM_BASH_GUARD_HOOK_COMMAND, timeout: 10 },
+    { eventName: "PreToolUse", matcher: "Grep", command: VCM_BASH_GUARD_HOOK_COMMAND, timeout: 10 },
     { eventName: "UserPromptSubmit", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "Stop", command: VCM_STOP_HOOK_COMMAND, timeout: 10 },
     { eventName: "StopFailure", command: VCM_HOOK_COMMAND, timeout: 5 },
@@ -110,6 +113,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, Coder, 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 +198,9 @@ 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"],
+        forbiddenTools: ["Grep"],
+        frontmatter: renderAgentFrontmatter("reviewer", "VCM independent gate review role for architecture plans, validation adequacy, and code diffs.", { tools: "Read, Glob, Bash, Write, LSP" }),
         renderRules: renderReviewerAgentRules
     },
     {
@@ -260,8 +273,10 @@ const HARNESS_FILES = [
         path: ".claude/agents/architect.md",
         title: "Architect Agent",
         memoryBlock: true,
+        requiredTools: ["Agent", "LSP"],
+        forbiddenTools: ["Grep"],
         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, Glob, Bash, Edit, Write, Agent, LSP" }),
         renderRules: renderArchitectHarnessRules
     },
     {
@@ -269,7 +284,9 @@ 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"],
+        forbiddenTools: ["Grep"],
+        frontmatter: renderAgentFrontmatter("coder", "VCM implementation role for scoped code changes and focused tests.", { tools: "Read, Glob, Bash, Edit, Write, Agent, LSP" }),
         renderRules: renderCoderHarnessRules
     },
     {
@@ -284,14 +301,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 +343,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 +1223,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 = normalizeAgentTools(memoryUpdatedContent, definition.requiredTools, definition.forbiddenTools);
             return {
                 definition,
                 status: {
@@ -1216,9 +1243,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 = normalizeAgentTools(insertedContent, definition.requiredTools, definition.forbiddenTools);
         return {
             definition,
             status: {
@@ -1240,9 +1265,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 = normalizeAgentTools(memoryUpdatedContent, definition.requiredTools, definition.forbiddenTools);
     const action = currentContent === nextContent ? "ok" : "update";
     return {
         definition,
@@ -1300,7 +1323,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 +1349,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 +1393,29 @@ 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 removeAgentTool(content, forbiddenTool) {
+    const frontmatterMatch = content.match(/^---\r?\n[\s\S]*?\r?\n---/);
+    if (!frontmatterMatch) {
+        return content;
+    }
+    const toolsMatch = frontmatterMatch[0].match(/^tools:\s*(.*)$/m);
+    if (!toolsMatch) {
+        return content;
+    }
+    const tools = toolsMatch[1].split(",").map((tool) => tool.trim()).filter(Boolean);
+    const nextTools = tools.filter((tool) => tool !== forbiddenTool);
+    if (nextTools.length === tools.length) {
+        return content;
+    }
+    return content.replace(frontmatterMatch[0], frontmatterMatch[0].replace(toolsMatch[0], `tools: ${nextTools.join(", ")}`));
+}
+function normalizeAgentTools(content, requiredTools, forbiddenTools) {
+    const required = ensureAgentTools(content, requiredTools);
+    return (forbiddenTools ?? []).reduce(removeAgentTool, required);
+}
 function migrateLegacyHarnessFile(definition, currentContent, block) {
     const legacyContent = definition.legacyWholeFile?.trimEnd();
     if (!legacyContent) {
@@ -1456,7 +1503,7 @@ function withVcmClaudeHooks(settings) {
             ? hooks[definition.eventName]
             : [];
         hooks[definition.eventName] = [
-            ...existingMatchers.filter((entry) => !isVcmHookMatcher(entry)),
+            ...existingMatchers,
             {
                 ...(definition.matcher ? { matcher: definition.matcher } : {}),
                 hooks: [

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
         });