vibe-coding-master 0.9.1 → 0.9.2

package/README.md

@@ -510,15 +510,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/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

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/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,16 +39,19 @@ 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) {
+export function renderLspNotice(status) {
     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."

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

@@ -25,6 +25,7 @@ export const GATE_ANALYSIS_FIELDS = {
         "Code Reality",
         "Invalidated Assumptions",
         "Existing-Class Completeness",
+        "Relationship Evidence",
         "Ownership",
         "Data Flow",
         "Lifecycle",

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)]
             .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/templates/harness/architect-agent.js

@@ -74,7 +74,7 @@ ${renderRoleMemoryRules("architect")}
 
 - 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, then personally read every decision-bearing callable unit in full.
-- Delegate bounded supporting implementation and document reading to \`vcm-architect-evidence-worker\` when it would otherwise add substantial raw context. Worker reports do not replace Architect's LSP verification of decision-bearing symbols, relationships, public surfaces, ownership, lifecycle, failure paths, contradictions, or unresolved evidence.
+- Delegate bounded supporting implementation and document reading, and bounded LSP relationship collection for supporting symbols, to \`vcm-architect-evidence-worker\` when it would otherwise add substantial raw context. Worker reports cite the LSP operation behind each relationship but do not replace Architect's own LSP verification of decision-bearing symbols, relationships, public surfaces, ownership, lifecycle, failure paths, contradictions, or unresolved evidence.
 - If LSP cannot resolve a required project-owned relationship, record the limitation in \`architecture-evidence.md\` and leave it unresolved.
 - Define the planning boundary as the affected feature or module and identify every existing or intended observable entry point for the behavior being changed.
 - Personally read the complete implementation of each decision-bearing existing entry point. Supporting entry points may be covered by accepted evidence-worker reports when their facts do not determine the architecture decision.

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

@@ -12,13 +12,16 @@ You are \`vcm-architect-evidence-worker\`, a foreground evidence-collection suba
 - Record repository facts with exact repo-relative file paths and symbol or section names.
 - Separate verified facts, contradictions, and unresolved items.
 - Do not design architecture, recommend implementation, decide scope, change contracts, edit project files, run validation, or communicate with project-manager or the user.
-- Do not claim a complete semantic relationship from text matches. Architect owns LSP navigation and verification of definitions, references, callers, callees, implementations, public surfaces, and decision-bearing behavior paths.
+- Use LSP for every definition, reference, caller, callee, and implementation relationship you report. LSP results are symbol-specific: query an accessor, its backing field, a trait declaration, its implementation, a wrapper, and an alias separately.
+- If LSP is unavailable for the language, reports that the server is still indexing, or cannot resolve the relationship, record the relationship as unresolved with the operation and result. Never report a relationship from text matches; text search only locates candidate files.
+- Architect remains responsible for verifying decision-bearing behavior paths before relying on them.
 - Do not reconstruct command output. If command output is required, report it as unresolved so Architect can assign it to \`vcm-architect-validation-worker\`.
 
 ### Evidence Output
 
 - Write the assigned report under \`.ai/vcm/architect-workers/evidence/worker-<worker-id>.md\` before returning. Only that report and its candidate or staging files may be written.
 - For candidate or staging Markdown, use \`worker-<worker-id>-candidate.md\`; never start its basename with \`report\`, \`summary\`, \`findings\`, or \`analysis\` (case-insensitive). If Write rejects a candidate or staging basename, rename it and retry; still deliver the assigned final report file, not just response text.
+- In Verified Facts, set Source to \`LSP <operation>\` for each relationship and \`read\` for facts read directly from code or documents.
 - Keep the report concise and factual. Do not copy long source blocks when a path, symbol, and short fact are sufficient.
 - Use this structure:
 
@@ -31,8 +34,8 @@ You are \`vcm-architect-evidence-worker\`, a foreground evidence-collection suba
 
 ## Verified Facts
 
-| Fact | Evidence |
-| --- | --- |
+| Fact | Evidence | Source |
+| --- | --- | --- |
 
 ## Observed Data And Lifecycle Paths
 

package/dist/backend/templates/harness/gate-review.js

@@ -35,6 +35,15 @@ implementations, callers, tests, and changed code before deciding the gate. Text
 matches locate evidence; they do not establish behavior or relationship correctness
 without inspection of the corresponding code.
 
+Establish definitions, references, callers, callees, and implementations with
+LSP when a language server is registered for the language. LSP results are
+symbol-specific: query an accessor, backing field, trait declaration,
+implementation, wrapper, and alias separately. An LSP query that fails because
+the server is still indexing returned no result; retry it, and if it still fails,
+record the relationship as not re-verified instead of treating it as empty or
+verified. When no server is registered for a language, say so in the report and
+verify relationships by reading the complete candidate code.
+
 Every Gate Review is a complete review of the current gate inputs. Review all
 required evidence and rerun every required mechanical check before deciding.
 Do not carry forward prior conclusions, closed checks, or partial verification.
@@ -147,6 +156,22 @@ evidence records the correct prior LSP operation and its missing relationship,
 limits candidate search to the identified owning file or module, and
 semantically verifies every candidate; text matches alone are not evidence.
 
+Verify relationship evidence for the plan (record it under Relationship Evidence):
+
+- Every definition, reference, caller, callee, or implementation relationship
+  the design depends on must cite its source in \`architecture-evidence.md\` or
+  the plan: an LSP operation, runtime evidence, verified bounded source fallback,
+  an external boundary, a generated boundary, or an explicit unresolved status.
+  A decision-bearing relationship with no source, or supported only by text
+  matches, is \`request_changes\`.
+- Re-run the LSP query for each decision-bearing relationship (the callers of a
+  changed surface, the implementations of a changed trait or interface, the
+  producers and consumers of changed data) and compare it with the recorded
+  result. A missing caller, implementation, or consumer is \`request_changes\`.
+- Record each relationship checked, its recorded source, and your re-query
+  result. A relationship that LSP could not re-verify is listed as such; it does
+  not count as verified.
+
 Run a backward-impact pass over the plan:
 
 - For every existing code site named by the Module/File Plan or Scaffold
@@ -293,7 +318,9 @@ Before deciding:
   surface, state, lifecycle, event, command, persisted artifact, or public
   contract changes, read its project-owned callers, consumers, readers,
   writers, and adjacent completion, failure, cancellation, retry, recovery, and
-  cleanup paths.
+  cleanup paths. Find the callers and implementations of every changed callable
+  or type with LSP references and implementations, not text search, and record
+  under Callers And Public Surface any that LSP could not resolve.
 - Keep this reading bounded to behavior affected by the named commits. Do
   not expand review to unrelated code, the whole task, whole branch, or PR.
 - Derive applicable boundary and failure cases from the actual changed behavior.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibe-coding-master",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "description": "Local GUI session cockpit for Claude Code role sessions.",
   "type": "module",
   "files": [

package/scripts/claude-plugins/vcm-lsp-bridge/vcm-lsp-proxy.mjs

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+// Stdio proxy between Claude Code's LSP client and one language server.
+//
+// Usage: node vcm-lsp-proxy.mjs -- <server-command> [server-args...]
+//
+// A language server that is still loading or indexing answers navigation
+// queries with partial or empty results, which reads as "no references".
+// The proxy tracks the server's work-done progress (and rust-analyzer's
+// quiescence status), holds navigation queries until the server is idle, and
+// fails a query with an explicit "still indexing" error when the server does
+// not become idle in time. Every other message passes through unchanged.
+
+import { spawn } from "node:child_process";
+import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+const NAVIGATION_METHODS = new Set([
+  "textDocument/definition",
+  "textDocument/declaration",
+  "textDocument/typeDefinition",
+  "textDocument/implementation",
+  "textDocument/references",
+  "textDocument/hover",
+  "textDocument/documentSymbol",
+  "textDocument/prepareCallHierarchy",
+  "callHierarchy/incomingCalls",
+  "callHierarchy/outgoingCalls",
+  "workspace/symbol"
+]);
+
+const READY_TIMEOUT_MS = positiveNumber(process.env.VCM_LSP_READY_TIMEOUT_MS, 180_000);
+// Servers announce indexing shortly after "initialized"; a query sent before
+// any progress appears waits this long for indexing to start.
+const STARTUP_GRACE_MS = positiveNumber(process.env.VCM_LSP_STARTUP_GRACE_MS, 2_000);
+const REQUEST_FAILED = -32803;
+const REQUEST_CANCELLED = -32800;
+
+function positiveNumber(raw, fallback) {
+  const value = Number(raw);
+  return Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+
+// Parses Content-Length framed JSON-RPC messages from a byte stream.
+export function createMessageReader(onMessage) {
+  let buffer = Buffer.alloc(0);
+  return (chunk) => {
+    buffer = Buffer.concat([buffer, chunk]);
+    while (true) {
+      const headerEnd = buffer.indexOf("\r\n\r\n");
+      if (headerEnd < 0) {
+        return;
+      }
+      const header = buffer.subarray(0, headerEnd).toString("ascii");
+      const match = /content-length:\s*(\d+)/i.exec(header);
+      if (!match) {
+        // Unframed bytes cannot be routed; drop the header and resynchronize.
+        buffer = buffer.subarray(headerEnd + 4);
+        continue;
+      }
+      const length = Number(match[1]);
+      const bodyStart = headerEnd + 4;
+      if (buffer.length < bodyStart + length) {
+        return;
+      }
+      const body = buffer.subarray(bodyStart, bodyStart + length).toString("utf8");
+      buffer = buffer.subarray(bodyStart + length);
+      onMessage(JSON.parse(body));
+    }
+  };
+}
+
+export function frameMessage(message) {
+  const body = Buffer.from(JSON.stringify(message), "utf8");
+  return Buffer.concat([Buffer.from(`Content-Length: ${body.length}\r\n\r\n`, "ascii"), body]);
+}
+
+// Readiness state shared by both directions of the proxy.
+export function createReadinessTracker(options = {}) {
+  const now = options.now ?? Date.now;
+  const activeProgress = new Map();
+  let quiescent = true;
+  let initializedAt;
+  let progressSeen = false;
+  const listeners = new Set();
+
+  function notify() {
+    for (const listener of [...listeners]) {
+      listener();
+    }
+  }
+
+  return {
+    markInitialized() {
+      initializedAt = now();
+    },
+    progressBegin(token, title) {
+      progressSeen = true;
+      activeProgress.set(String(token), title || "indexing");
+      notify();
+    },
+    progressEnd(token) {
+      activeProgress.delete(String(token));
+      notify();
+    },
+    serverStatus(isQuiescent) {
+      progressSeen = true;
+      quiescent = isQuiescent;
+      notify();
+    },
+    // Remaining startup grace in ms, or 0 once it no longer applies.
+    graceRemaining() {
+      if (progressSeen || initializedAt === undefined) {
+        return 0;
+      }
+      return Math.max(0, initializedAt + (options.startupGraceMs ?? STARTUP_GRACE_MS) - now());
+    },
+    isBusy() {
+      return activeProgress.size > 0 || !quiescent;
+    },
+    busyReason() {
+      const titles = [...new Set(activeProgress.values())];
+      if (!quiescent) {
+        titles.push("server not quiescent");
+      }
+      return titles.join(", ") || "starting up";
+    },
+    onChange(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+}
+
+export function startProxy({ command, args, input, output, errorOutput, readyTimeoutMs = READY_TIMEOUT_MS, startupGraceMs = STARTUP_GRACE_MS }) {
+  const server = spawn(command, args, { stdio: ["pipe", "pipe", "pipe"] });
+  const readiness = createReadinessTracker({ startupGraceMs });
+  const pending = new Map();
+  let clientWantsProgress = false;
+  let clientWantsServerStatus = false;
+
+  const toClient = (message) => output.write(frameMessage(message));
+  const toServer = (message) => {
+    if (server.stdin.writable) {
+      server.stdin.write(frameMessage(message));
+    }
+  };
+
+  server.stderr.pipe(errorOutput);
+  server.on("error", (error) => {
+    errorOutput.write(`vcm-lsp-proxy: cannot start ${command}: ${error.message}\n`);
+    process.exitCode = 1;
+    output.end?.();
+  });
+  server.on("exit", (code, signal) => {
+    for (const entry of pending.values()) {
+      entry.dispose();
+    }
+    process.exitCode = code ?? (signal ? 1 : 0);
+    output.end?.();
+  });
+
+  function releaseWhenReady(message) {
+    const key = String(message.id);
+    let timer;
+    let graceTimer;
+    let unsubscribe = () => undefined;
+    const dispose = () => {
+      clearTimeout(timer);
+      clearTimeout(graceTimer);
+      unsubscribe();
+      pending.delete(key);
+    };
+    const attempt = () => {
+      const grace = readiness.graceRemaining();
+      if (grace > 0) {
+        clearTimeout(graceTimer);
+        graceTimer = setTimeout(attempt, grace);
+        return;
+      }
+      if (!readiness.isBusy()) {
+        dispose();
+        toServer(message);
+      }
+    };
+    pending.set(key, {
+      dispose,
+      cancel() {
+        dispose();
+        toClient({ jsonrpc: "2.0", id: message.id, error: { code: REQUEST_CANCELLED, message: "Request cancelled." } });
+      }
+    });
+    unsubscribe = readiness.onChange(attempt);
+    timer = setTimeout(() => {
+      dispose();
+      toClient({
+        jsonrpc: "2.0",
+        id: message.id,
+        error: {
+          code: REQUEST_FAILED,
+          message: `Language server is still indexing (${readiness.busyReason()}) after ${Math.round(readyTimeoutMs / 1000)}s; ${message.method} results would be incomplete. Retry after indexing finishes, or record the relationship as unresolved.`
+        }
+      });
+    }, readyTimeoutMs);
+    attempt();
+  }
+
+  input.on("data", createMessageReader((message) => {
+    if (message.method === "initialize" && message.params) {
+      const capabilities = message.params.capabilities ?? {};
+      clientWantsProgress = capabilities.window?.workDoneProgress === true;
+      clientWantsServerStatus = capabilities.experimental?.serverStatusNotification === true;
+      message.params.capabilities = {
+        ...capabilities,
+        window: { ...capabilities.window, workDoneProgress: true },
+        experimental: { ...capabilities.experimental, serverStatusNotification: true }
+      };
+    }
+    if (message.method === "initialized") {
+      readiness.markInitialized();
+    }
+    if (message.method === "$/cancelRequest" && pending.has(String(message.params?.id))) {
+      pending.get(String(message.params.id)).cancel();
+      return;
+    }
+    if (message.id !== undefined && NAVIGATION_METHODS.has(message.method)) {
+      releaseWhenReady(message);
+      return;
+    }
+    toServer(message);
+  }));
+  input.on("end", () => server.stdin.end());
+
+  server.stdout.on("data", createMessageReader((message) => {
+    if (message.method === "window/workDoneProgress/create") {
+      if (!clientWantsProgress) {
+        toServer({ jsonrpc: "2.0", id: message.id, result: null });
+        return;
+      }
+    } else if (message.method === "$/progress") {
+      const value = message.params?.value;
+      if (value?.kind === "begin") {
+        readiness.progressBegin(message.params.token, value.title);
+      } else if (value?.kind === "end") {
+        readiness.progressEnd(message.params.token);
+      }
+      if (!clientWantsProgress) {
+        return;
+      }
+    } else if (message.method === "experimental/serverStatus") {
+      readiness.serverStatus(message.params?.quiescent !== false);
+      if (!clientWantsServerStatus) {
+        return;
+      }
+    }
+    toClient(message);
+  }));
+
+  return { server, readiness };
+}
+
+const separator = process.argv.indexOf("--");
+if (separator >= 0 && process.argv[1] && realpathSync(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  const [command, ...args] = process.argv.slice(separator + 1);
+  if (!command) {
+    process.stderr.write("usage: vcm-lsp-proxy.mjs -- <server-command> [args...]\n");
+    process.exit(2);
+  }
+  startProxy({ command, args, input: process.stdin, output: process.stdout, errorOutput: process.stderr });
+}

package/scripts/verify-package.mjs

@@ -7,6 +7,7 @@ const requiredFiles = [
   "package.json",
   "scripts/fix-node-pty-spawn-helper.mjs",
   "scripts/claude-plugins/vcm-lsp-bridge/.claude-plugin/plugin.json",
+  "scripts/claude-plugins/vcm-lsp-bridge/vcm-lsp-proxy.mjs",
   "scripts/harness-tools/check-durable-docs",
   "scripts/harness-tools/generate-module-index",
   "scripts/harness-tools/generate-public-surface",