@akira-tl/forgerelay 0.4.4 → 0.4.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akira-tl/forgerelay",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "Local development control plane for MCP coding agents.",
   "type": "module",
   "homepage": "https://github.com/Akira-TL/forgerelay#readme",
@@ -40,9 +40,11 @@
     "dev": "node scripts/debug/serve.mjs",
     "debug:serve": "node scripts/debug/serve.mjs",
     "debug:accept": "node scripts/debug/accept.mjs",
+    "lsp:interop": "node scripts/lsp-interop.mjs",
+    "release:parity": "node scripts/release-parity.mjs",
     "postinstall": "node scripts/fix-node-pty-permissions.mjs",
     "start": "node dist/cli.js serve",
-    "test": "tsx src/config.test.ts && tsx src/lsp/language-server-config.test.ts && tsx src/lsp/normalization/hover.test.ts && tsx src/lsp/references.server.test.ts && tsx src/lsp/operations/document-symbols.server.test.ts && tsx src/lsp/operations/workspace-symbols.server.test.ts && tsx src/lsp/operations/diagnostics-push.server.test.ts && tsx src/lsp/operations/diagnostics-pull.server.test.ts && tsx src/logger.test.ts && tsx src/proxy-trust.test.ts && tsx src/mcp-app-template.test.ts && tsx src/hooks.test.ts && tsx src/capability-registry.test.ts && tsx src/mcp/server-instructions.test.ts && tsx src/request-meta.test.ts && tsx src/incoming-artifacts.test.ts && tsx src/artifact-download.test.ts && tsx src/ui/card-types.test.ts && tsx src/ui/patch-display.test.ts && tsx src/ui/tool-display.test.ts && tsx src/apply-patch.test.ts && tsx src/process-platform.test.ts && tsx src/process-sessions.test.ts && tsx src/mcp-sessions.test.ts && tsx src/server-shutdown.test.ts && tsx src/local-agent-runtime.test.ts && tsx src/local-agent-adapters.test.ts && tsx src/local-agent-availability.test.ts && tsx src/local-agent-profiles.test.ts && tsx src/local-agent-targets.test.ts && tsx src/local-agent-store.test.ts && tsx src/roots.test.ts && tsx src/file-mutations.test.ts && tsx src/skills.test.ts && tsx src/workspace-store.test.ts && tsx src/workspaces.test.ts && tsx src/workspace-conversation.test.ts && tsx src/review-checkpoints.test.ts && tsx src/lsp/code-intelligence.server.test.ts && tsx src/server.test.ts && tsx src/oauth-store.test.ts && tsx src/cli.test.ts",
+    "test": "tsx src/config.test.ts && tsx src/lsp/language-server-config.test.ts && tsx src/lsp/normalization/hover.test.ts && tsx src/lsp/references.server.test.ts && tsx src/lsp/operations/document-symbols.server.test.ts && tsx src/lsp/operations/workspace-symbols.server.test.ts && tsx src/lsp/operations/diagnostics-push.server.test.ts && tsx src/lsp/operations/diagnostics-pull.server.test.ts && tsx src/lsp/operations/request-hardening.server.test.ts && tsx src/lsp/operations/recovery.server.test.ts && tsx src/lsp/operations/lifecycle.server.test.ts && tsx src/lsp/runtime/semantic-requests.test.ts && tsx src/logger.test.ts && tsx src/proxy-trust.test.ts && tsx src/mcp-app-template.test.ts && tsx src/hooks.test.ts && tsx src/capability-registry.test.ts && tsx src/mcp/server-instructions.test.ts && tsx src/request-meta.test.ts && tsx src/incoming-artifacts.test.ts && tsx src/artifact-download.test.ts && tsx src/ui/card-types.test.ts && tsx src/ui/patch-display.test.ts && tsx src/ui/tool-display.test.ts && tsx src/apply-patch.test.ts && tsx src/process-platform.test.ts && tsx src/process-sessions.test.ts && tsx src/mcp-sessions.test.ts && tsx src/server-shutdown.test.ts && tsx src/local-agent-runtime.test.ts && tsx src/local-agent-adapters.test.ts && tsx src/local-agent-availability.test.ts && tsx src/local-agent-profiles.test.ts && tsx src/local-agent-targets.test.ts && tsx src/local-agent-store.test.ts && tsx src/roots.test.ts && tsx src/file-mutations.test.ts && tsx src/skills.test.ts && tsx src/workspace-store.test.ts && tsx src/workspaces.test.ts && tsx src/workspace-conversation.test.ts && tsx src/review-checkpoints.test.ts && tsx src/lsp/code-intelligence.server.test.ts && tsx src/server.test.ts && tsx src/oauth-store.test.ts && tsx src/cli.test.ts",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "release:check": "node scripts/release-version.mjs check",
     "release:tag-check": "node scripts/release-version.mjs tag",
@@ -50,7 +52,7 @@
     "release:patch": "node scripts/release-version.mjs next patch",
     "release:minor": "node scripts/release-version.mjs next minor",
     "release:major": "node scripts/release-version.mjs next major",
-    "release:verify": "npm run release:check && npm run typecheck && npm test && npm run build"
+    "release:verify": "npm run release:check && npm run typecheck && npm test && npm run build && npm run lsp:interop && npm run release:parity"
   },
   "keywords": [
     "mcp",

package/scripts/debug/accept.mjs

@@ -20,6 +20,11 @@ import {
   debugRoot,
   repoRoot,
 } from "./runtime.mjs";
+import {
+  assertCodeIntelligenceShutdown as assertCodeIntelligenceAcceptanceShutdown,
+  exerciseCodeIntelligence as exerciseCodeIntelligenceAcceptance,
+  setupCodeIntelligenceProject as setupCodeIntelligenceAcceptanceProject,
+} from "./code-intelligence-accept.mjs";
 
 const packageJson = JSON.parse(readFileSync(join(repoRoot, "package.json"), "utf8"));
 const acceptanceRoot = resolve(debugRoot, "acceptance");
@@ -27,6 +32,8 @@ const stateDir = resolve(acceptanceRoot, "state");
 const worktreeRoot = resolve(acceptanceRoot, "worktrees");
 const hookLog = resolve(acceptanceRoot, "hooks.jsonl");
 const checkoutWorkspace = resolve(acceptanceRoot, "workspace");
+const codeIntelligenceLog = resolve(acceptanceRoot, "code-intelligence-lsp.jsonl");
+const fakeLanguageServer = resolve(repoRoot, "src", "lsp", "test-fixtures", "fake-lsp-server.mjs");
 const gitProject = resolve(acceptanceRoot, "git-project");
 const releaseProject = resolve(acceptanceRoot, "release-project");
 const releaseRemote = resolve(acceptanceRoot, "release-remote.git");
@@ -38,6 +45,11 @@ await assertDebugPortFree();
 rmSync(acceptanceRoot, { recursive: true, force: true });
 mkdirSync(acceptanceRoot, { recursive: true });
 setupGitProject(checkoutWorkspace);
+setupCodeIntelligenceAcceptanceProject({
+  root: checkoutWorkspace,
+  fakeLanguageServer,
+  logPath: codeIntelligenceLog,
+});
 
 const { env } = createDebugEnvironment({
   ownerToken,
@@ -64,6 +76,7 @@ const server = spawn(process.execPath, ["--import", "tsx", "src/cli.ts", "serve"
   env,
   stdio: ["ignore", "inherit", "inherit"],
 });
+let acceptanceCompleted = false;
 
 try {
   const health = await waitForHealth(server);
@@ -349,6 +362,13 @@ try {
     (variant) => variant.properties.operation.const === "workspaceSymbols",
   );
   assert.ok(workspaceSymbolsSchema.required.includes("query"));
+  exerciseCodeIntelligenceAcceptance({
+    callTool,
+    accessToken: oauth.accessToken,
+    sessionId,
+    workspaceId,
+    pass,
+  });
   if (process.platform === "linux") {
     const describedArtifact = callTool(oauth.accessToken, sessionId, 82, "capability", {
       workspaceId,
@@ -569,9 +589,7 @@ try {
     headers: mcpHeaders(oauth.accessToken, sessionId),
   });
   assert.ok([200, 202, 204].includes(deleteSession.status));
-
-  console.log("\nForgeRelay 7677 acceptance passed.");
-  console.log(`Artifacts: ${acceptanceRoot}`);
+  acceptanceCompleted = true;
 } catch (error) {
   console.error("\nForgeRelay 7677 acceptance failed.");
   throw error;
@@ -580,6 +598,12 @@ try {
   await stopServer(server);
 }
 
+if (acceptanceCompleted) {
+  assertCodeIntelligenceAcceptanceShutdown({ logPath: codeIntelligenceLog, pass });
+  console.log("\nForgeRelay 7677 acceptance passed.");
+  console.log(`Artifacts: ${acceptanceRoot}`);
+}
+
 function authorizeDebugClient(metadata) {
   const redirectUri = `${debugBaseUrl}/debug/callback`;
   const registration = jsonRequest(metadata.registration_endpoint, {

package/scripts/debug/code-intelligence-accept.mjs

@@ -0,0 +1,169 @@
+import assert from "node:assert/strict";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+export function setupCodeIntelligenceProject({ root, fakeLanguageServer, logPath }) {
+  mkdirSync(join(root, ".forgerelay"), { recursive: true });
+  mkdirSync(join(root, "src"), { recursive: true });
+  writeFileSync(join(root, "tsconfig.json"), "{}\n", "utf8");
+  writeFileSync(
+    join(root, "src", "main.ts"),
+    [
+      "const value = target();",
+      "class Widget {",
+      "  runMethod() {}",
+      "  stopMethod() {}",
+      "}",
+      "",
+    ].join("\n"),
+    "utf8",
+  );
+  writeFileSync(join(root, "src", "target.ts"), "export const target = () => 1;\n", "utf8");
+  writeFileSync(
+    join(root, ".forgerelay", "language-servers.json"),
+    `${JSON.stringify({
+      "debug-fake": {
+        command: process.execPath,
+        args: [fakeLanguageServer],
+        env: {
+          FORGERELAY_FAKE_LSP_LOG: logPath,
+          FORGERELAY_FAKE_LSP_HOVER_TEXT: "**debug target**: `() => void`",
+          FORGERELAY_FAKE_LSP_REFERENCE_COUNT: "2",
+          FORGERELAY_FAKE_LSP_DIAGNOSTICS_MODE: "pull",
+          FORGERELAY_FAKE_LSP_DIAGNOSTIC_COUNT: "2",
+        },
+        languages: ["typescript"],
+        extensions: [".ts"],
+        projectMarkers: ["tsconfig.json"],
+      },
+    }, null, 2)}\n`,
+    "utf8",
+  );
+}
+
+export function exerciseCodeIntelligence({ callTool, accessToken, sessionId, workspaceId, pass }) {
+  const run = (id, argumentsValue) => callTool(accessToken, sessionId, id, "capability", {
+    workspaceId,
+    name: "code.intelligence",
+    action: "run",
+    arguments: argumentsValue,
+  });
+
+  const definition = run(90, {
+    operation: "definition",
+    path: "src/main.ts",
+    line: 1,
+    column: 15,
+  });
+  assert.equal(definition.isError, undefined);
+  const definitionResult = definition.structuredContent.result;
+  assert.equal(definitionResult.operation, "definition");
+  assert.equal(definitionResult.selectedServer, "debug-fake");
+  assert.deepEqual(definitionResult.locations, [{
+    path: "src/target.ts",
+    external: false,
+    range: {
+      start: { line: 1, column: 8 },
+      end: { line: 1, column: 14 },
+    },
+  }]);
+
+  const hover = run(91, {
+    operation: "hover",
+    path: "src/main.ts",
+    line: 1,
+    column: 15,
+  });
+  assert.equal(hover.isError, undefined);
+  assert.equal(hover.structuredContent.result.operation, "hover");
+  assert.equal(hover.structuredContent.result.contents, "**debug target**: `() => void`");
+  assert.deepEqual(hover.structuredContent.result.range, {
+    start: { line: 1, column: 15 },
+    end: { line: 1, column: 21 },
+  });
+
+  const references = run(92, {
+    operation: "references",
+    path: "src/main.ts",
+    line: 1,
+    column: 15,
+  });
+  assert.equal(references.isError, undefined);
+  assert.equal(references.structuredContent.result.operation, "references");
+  assert.equal(references.structuredContent.result.returned, 2);
+  assert.equal(references.structuredContent.result.total, 2);
+  assert.equal(references.structuredContent.result.truncated, false);
+  assert.ok(references.structuredContent.result.locations.every((location) =>
+    location.path === "src/target.ts" && location.external === false
+  ));
+
+  const documentSymbols = run(93, {
+    operation: "documentSymbols",
+    path: "src/main.ts",
+  });
+  assert.equal(documentSymbols.isError, undefined);
+  const documentSymbolsResult = documentSymbols.structuredContent.result;
+  assert.equal(documentSymbolsResult.operation, "documentSymbols");
+  assert.equal(documentSymbolsResult.hierarchical, true);
+  assert.equal(documentSymbolsResult.returned, 3);
+  assert.equal(documentSymbolsResult.symbols[0].name, "Widget");
+  assert.deepEqual(
+    documentSymbolsResult.symbols[0].children.map((symbol) => symbol.name),
+    ["run", "stop"],
+  );
+
+  const workspaceSymbols = run(94, {
+    operation: "workspaceSymbols",
+    path: "src/main.ts",
+    query: "Target",
+  });
+  assert.equal(workspaceSymbols.isError, undefined);
+  const workspaceSymbolsResult = workspaceSymbols.structuredContent.result;
+  assert.equal(workspaceSymbolsResult.operation, "workspaceSymbols");
+  assert.equal(workspaceSymbolsResult.returned, 1);
+  assert.equal(workspaceSymbolsResult.symbols[0].name, "Target");
+  assert.equal(workspaceSymbolsResult.symbols[0].location.path, "src/target.ts");
+  assert.equal(workspaceSymbolsResult.symbols[0].location.external, false);
+
+  const diagnostics = run(95, {
+    operation: "diagnostics",
+    path: "src/main.ts",
+  });
+  assert.equal(diagnostics.isError, undefined);
+  const diagnosticsResult = diagnostics.structuredContent.result;
+  assert.equal(diagnosticsResult.operation, "diagnostics");
+  assert.equal(diagnosticsResult.provider, "pull");
+  assert.equal(diagnosticsResult.returned, 2);
+  assert.equal(diagnosticsResult.total, 2);
+  assert.equal(diagnosticsResult.freshness.state, "fresh");
+  assert.deepEqual(
+    diagnosticsResult.diagnostics.map((diagnostic) => diagnostic.message),
+    ["pulled diagnostic 1", "pulled diagnostic 2"],
+  );
+
+  const invalidPosition = run(96, {
+    operation: "definition",
+    path: "src/main.ts",
+    line: 99,
+    column: 1,
+  });
+  assert.equal(invalidPosition.isError, true);
+  assert.equal(invalidPosition.structuredContent.error.code, "code.invalid_position");
+  pass(
+    "code intelligence execution",
+    "definition + hover + references + document/workspace symbols + diagnostics + stable error over OAuth/MCP",
+  );
+}
+
+export function assertCodeIntelligenceShutdown({ logPath, pass }) {
+  const events = readFileSync(logPath, "utf8")
+    .trim()
+    .split(/\r?\n/)
+    .filter(Boolean)
+    .map((line) => JSON.parse(line));
+  const shutdownIndex = events.findIndex((event) => event.method === "shutdown");
+  const exitIndex = events.findIndex((event, index) => index > shutdownIndex && event.method === "exit");
+  assert.ok(shutdownIndex >= 0, "code-intelligence Language server did not receive shutdown");
+  assert.ok(exitIndex > shutdownIndex, "code-intelligence Language server did not receive exit after shutdown");
+  pass("code intelligence shutdown", "Language service received shutdown -> exit during ForgeRelay server shutdown");
+}

package/scripts/lsp-interop-support.mjs

@@ -0,0 +1,49 @@
+import { spawnSync } from "node:child_process";
+import { accessSync, constants } from "node:fs";
+import { delimiter, join } from "node:path";
+
+export function findExecutable(
+  command,
+  env = process.env,
+  platform = process.platform,
+) {
+  const pathValue = env.PATH ?? env.Path ?? "";
+  const pathEntries = pathValue.split(delimiter).filter(Boolean);
+  const extensions = platform === "win32"
+    ? (env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";").filter(Boolean)
+    : [""];
+  const accessMode = platform === "win32" ? constants.F_OK : constants.X_OK;
+
+  for (const directory of pathEntries) {
+    for (const extension of extensions) {
+      const candidate = join(directory, platform === "win32" ? `${command}${extension}` : command);
+      try {
+        accessSync(candidate, accessMode);
+        return candidate;
+      } catch {
+        // Continue searching PATH without invoking or installing anything.
+      }
+    }
+  }
+  return undefined;
+}
+
+export function probeExecutable(
+  executable,
+  env = process.env,
+  platform = process.platform,
+) {
+  const result = spawnSync(executable, ["--version"], {
+    encoding: "utf8",
+    env,
+    windowsHide: true,
+    timeout: 5_000,
+    ...(platform === "win32" ? { shell: true } : {}),
+  });
+  if (result.status === 0) return { available: true };
+  const reason = result.error?.message ?? result.stderr?.trim() ?? result.stdout?.trim() ?? `exit ${result.status ?? "unknown"}`;
+  return {
+    available: false,
+    reason: reason.replace(/\s+/g, " ").slice(0, 240),
+  };
+}

package/scripts/lsp-interop-support.test.mjs

@@ -0,0 +1,40 @@
+import assert from "node:assert/strict";
+import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { delimiter, join } from "node:path";
+import test from "node:test";
+import { findExecutable, probeExecutable } from "./lsp-interop-support.mjs";
+
+const root = mkdtempSync(join(tmpdir(), "forgerelay-lsp-preflight-test-"));
+
+try {
+  const env = { ...process.env, PATH: root };
+  if (process.platform === "win32") {
+    env.PATHEXT = ".CMD";
+    writeFileSync(join(root, "working.cmd"), "@echo off\r\nif \"%1\"==\"--version\" echo fake-lsp 1.0.0 & exit /b 0\r\n", "utf8");
+    writeFileSync(join(root, "broken.cmd"), "@echo off\r\necho error: Unknown binary 1>&2\r\nexit /b 1\r\n", "utf8");
+  } else {
+    writeFileSync(join(root, "working"), "#!/bin/sh\necho fake-lsp 1.0.0\nexit 0\n", "utf8");
+    writeFileSync(join(root, "broken"), "#!/bin/sh\necho 'error: Unknown binary' >&2\nexit 1\n", "utf8");
+    chmodSync(join(root, "working"), 0o755);
+    chmodSync(join(root, "broken"), 0o755);
+  }
+
+  test("interop preflight distinguishes runnable executables from PATH proxies that fail", () => {
+    const working = findExecutable("working", env);
+    const broken = findExecutable("broken", env);
+    assert.ok(working);
+    assert.ok(broken);
+    assert.deepEqual(probeExecutable(working, env), { available: true });
+    const unavailable = probeExecutable(broken, env);
+    assert.equal(unavailable.available, false);
+    assert.match(unavailable.reason, /Unknown binary|exit 1/i);
+  });
+
+  test("interop preflight treats a missing command as unavailable without installation", () => {
+    assert.equal(findExecutable("missing-language-server", env), undefined);
+    assert.equal(env.PATH.split(delimiter).length, 1);
+  });
+} finally {
+  process.on("exit", () => rmSync(root, { recursive: true, force: true }));
+}

package/scripts/lsp-interop.mjs

@@ -0,0 +1,180 @@
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { CodeIntelligenceManager } from "../dist/lsp/runtime/manager.js";
+import { findExecutable, probeExecutable } from "./lsp-interop-support.mjs";
+
+const repoRoot = resolve(fileURLToPath(new URL("..", import.meta.url)));
+const interopRoot = resolve(repoRoot, ".forgerelay-debug", "lsp-interop");
+const fixtures = [
+  {
+    id: "typescript",
+    command: "typescript-language-server",
+    sourcePath: "src/main.ts",
+    hover: { line: 1, column: 14 },
+    setup(root) {
+      write(root, "tsconfig.json", `${JSON.stringify({ compilerOptions: { strict: true } }, null, 2)}\n`);
+      write(root, "src/main.ts", [
+        "export class Widget {",
+        "  run(): number { return 1; }",
+        "  stop(): number { return 0; }",
+        "}",
+        "",
+      ].join("\n"));
+    },
+  },
+  {
+    id: "pyright",
+    command: "pyright-langserver",
+    sourcePath: "main.py",
+    hover: { line: 1, column: 7 },
+    setup(root) {
+      write(root, "pyrightconfig.json", "{}\n");
+      write(root, "main.py", [
+        "class Widget:",
+        "    def run(self) -> int:",
+        "        return 1",
+        "",
+      ].join("\n"));
+    },
+  },
+  {
+    id: "rust-analyzer",
+    command: "rust-analyzer",
+    sourcePath: "src/lib.rs",
+    hover: { line: 1, column: 12 },
+    setup(root) {
+      write(root, "Cargo.toml", [
+        "[package]",
+        'name = "forgerelay-interop"',
+        'version = "0.1.0"',
+        'edition = "2021"',
+        "",
+        "[lib]",
+        'path = "src/lib.rs"',
+        "",
+      ].join("\n"));
+      write(root, "src/lib.rs", [
+        "pub struct Widget;",
+        "impl Widget {",
+        "    pub fn run(&self) -> i32 { 1 }",
+        "}",
+        "",
+      ].join("\n"));
+    },
+  },
+  {
+    id: "gopls",
+    command: "gopls",
+    sourcePath: "main.go",
+    hover: { line: 3, column: 6 },
+    setup(root) {
+      write(root, "go.mod", "module example.com/forgerelay-interop\n\ngo 1.22\n");
+      write(root, "main.go", [
+        "package interop",
+        "",
+        "type Widget struct{}",
+        "",
+        "func (Widget) Run() int { return 1 }",
+        "",
+      ].join("\n"));
+    },
+  },
+  {
+    id: "clangd",
+    command: "clangd",
+    sourcePath: "main.cpp",
+    hover: { line: 1, column: 7 },
+    setup(root) {
+      write(root, "compile_flags.txt", "-std=c++17\n");
+      write(root, "main.cpp", [
+        "class Widget {",
+        " public:",
+        "  int run() const { return 1; }",
+        "};",
+        "",
+      ].join("\n"));
+    },
+  },
+];
+
+rmSync(interopRoot, { recursive: true, force: true });
+
+let passed = 0;
+let skipped = 0;
+const failures = [];
+
+for (const fixture of fixtures) {
+  const executable = findExecutable(fixture.command);
+  if (!executable) {
+    skipped += 1;
+    console.log(`SKIP ${fixture.id}: ${fixture.command} not found on PATH; ForgeRelay does not install Language servers.`);
+    continue;
+  }
+  const preflight = probeExecutable(executable);
+  if (!preflight.available) {
+    skipped += 1;
+    console.log(`SKIP ${fixture.id}: ${executable} is present but not runnable: ${preflight.reason}`);
+    continue;
+  }
+
+  const root = join(interopRoot, fixture.id);
+  fixture.setup(root);
+  const manager = new CodeIntelligenceManager(
+    { languageServers: {} },
+    {
+      startTimeoutMs: 30_000,
+      requestTimeoutMs: 30_000,
+      shutdownTimeoutMs: 5_000,
+      idleMs: 60_000,
+      cleanupIntervalMs: 60_000,
+    },
+  );
+
+  try {
+    const symbols = await manager.run(root, {
+      operation: "documentSymbols",
+      path: fixture.sourcePath,
+      limit: 20,
+    });
+    assert.equal(symbols.operation, "documentSymbols");
+    assert.equal(symbols.selectedServer, fixture.id);
+    assert.ok(symbols.returned > 0, `${fixture.id} returned no document symbols`);
+
+    const hover = await manager.run(root, {
+      operation: "hover",
+      path: fixture.sourcePath,
+      line: fixture.hover.line,
+      column: fixture.hover.column,
+    });
+    assert.equal(hover.operation, "hover");
+    assert.equal(hover.selectedServer, fixture.id);
+
+    passed += 1;
+    console.log(
+      `PASS ${fixture.id}: ${executable} -> documentSymbols(${symbols.returned}) + hover via built-in discovery and stdio LSP.`,
+    );
+  } catch (error) {
+    const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
+    failures.push(`${fixture.id}: ${message}`);
+    console.error(`FAIL ${fixture.id}: ${message}`);
+  } finally {
+    await manager.shutdown();
+    assert.equal(manager.stats().servicesTotal, 0, `${fixture.id} retained a Language service after shutdown`);
+  }
+}
+
+console.log(`LSP interoperability summary: ${passed} passed, ${skipped} skipped, ${failures.length} failed.`);
+if (failures.length > 0) {
+  console.error(`Interop artifacts retained at ${interopRoot}`);
+  process.exitCode = 1;
+} else {
+  rmSync(interopRoot, { recursive: true, force: true });
+}
+
+function write(root, relativePath, content) {
+  const path = join(root, relativePath);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, content, "utf8");
+}

package/scripts/release-parity.mjs

@@ -0,0 +1,85 @@
+import { spawnSync } from "node:child_process";
+import { cpSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const minimumNode = "22.19.0";
+const npmVersion = "11";
+const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const debugRoot = join(repoRoot, ".forgerelay-debug");
+const sandbox = mkdtempSync(join(ensureDirectory(debugRoot), "release-parity-node22-"));
+const npx = process.platform === "win32" ? "npx.cmd" : "npx";
+const highRiskTests = [
+  "scripts/lsp-interop-support.test.mjs",
+  "src/lsp/language-server-config.test.ts",
+  "src/lsp/runtime/semantic-requests.test.ts",
+  "src/lsp/operations/request-hardening.server.test.ts",
+  "src/lsp/operations/recovery.server.test.ts",
+  "src/lsp/operations/lifecycle.server.test.ts",
+];
+
+try {
+  copy("package.json");
+  copy("package-lock.json");
+  copy("tsconfig.json");
+  copy("src");
+  copy("scripts");
+  copy("capabilities");
+
+  run(
+    ["--yes", "-p", `node@${minimumNode}`, "-p", `npm@${npmVersion}`, "--", "npm", "ci", "--no-audit", "--no-fund"],
+    `Node ${minimumNode} isolated npm ci`,
+    sandbox,
+  );
+
+  run(
+    [
+      "--yes",
+      `node@${minimumNode}`,
+      "--import",
+      "tsx",
+      "--test",
+      "--test-concurrency=1",
+      ...highRiskTests,
+    ],
+    `Node ${minimumNode} high-risk parity tests`,
+    sandbox,
+  );
+
+  console.log(`Release parity passed in an isolated Node ${minimumNode} sandbox.`);
+} finally {
+  rmSync(sandbox, {
+    recursive: true,
+    force: true,
+    maxRetries: 8,
+    retryDelay: 100,
+  });
+}
+
+function ensureDirectory(path) {
+  mkdirSync(path, { recursive: true });
+  return `${path}/`;
+}
+
+function copy(relativePath) {
+  cpSync(join(repoRoot, relativePath), join(sandbox, relativePath), {
+    recursive: true,
+    force: true,
+  });
+}
+
+function run(args, label, cwd) {
+  console.log(`\n== ${label} ==`);
+  const result = spawnSync(npx, args, {
+    cwd,
+    env: process.env,
+    stdio: "inherit",
+    windowsHide: true,
+  });
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    console.error(`${label} failed with exit ${result.status ?? "unknown"}.`);
+    process.exitCode = result.status ?? 1;
+    throw new Error(`${label} failed.`);
+  }
+}