chainlesschain 0.162.150 → 0.162.152

package/src/lib/changelog.js

@@ -0,0 +1,252 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/**
+ * The `cc changelog` data source.
+ *
+ * The canonical update record is the repository-root `CHANGELOG.md`, which is
+ * organized by PRODUCT version (`## [v5.0.3.x]`). Each block references the CLI
+ * npm version (`chainlesschain 0.162.x`) it shipped. This parser distills that
+ * into a CLI-focused view: it keeps only blocks that actually reference a CLI
+ * npm version, and within each block keeps only the CLI-relevant sub-sections.
+ *
+ * At publish time `scripts/build-changelog.mjs` runs `parseChangelog` over the
+ * root CHANGELOG and writes the result to `src/data/changelog.json`, which is
+ * bundled with the npm package. `loadChangelog()` reads that file (with a
+ * fallback to parsing a raw CHANGELOG.md for in-repo dev use).
+ */
+
+// Signals that a `### ` sub-section HEADING is about the CLI npm package rather
+// than the desktop app / Android / iOS / PDH portions of the same product
+// release. CASE-SENSITIVE on purpose: real CLI notes write the acronym "CLI"
+// (e.g. "cc CLI 0.162.150", "CLI 安全"), whereas PDH/Android bundle-roll notes
+// write the version tag lowercase ("(pdh 0.4.6 / cli 0.162.48)"). Matching only
+// uppercase "CLI" keeps collector releases that merely bundle a cli bump out of
+// the CLI view. Heading-only (not body) for the same reason.
+const CLI_HEADING_SIGNAL = /\bCLI\b|命令行/;
+
+// A block with no `### ` sub-sections is a CLI release only if its header or
+// preamble uses CLI-publish language. Same case-sensitivity: a lowercase
+// bundle-roll "cli 0.162.x" mention is not enough.
+const CLI_PUBLISH_SIGNAL = /\bCLI\b|命令行|catch-up/;
+
+// CLI npm versions are 3-segment (0.162.x). The `(?<![\d.])` / `(?!\.\d)` guards
+// stop a 4-segment PRODUCT version (v5.0.3.134) from matching as "5.0.3".
+const V = "(?<![\\d.])(\\d+\\.\\d+\\.\\d+)(?!\\.\\d)";
+
+/**
+ * Extract every CLI npm version token referenced in a block of text and return
+ * the "primary" one (the highest semver — the released target in a
+ * `0.162.149 → 0.162.150` style note).
+ *
+ * @param {string} text
+ * @returns {{ primary: string|null, all: string[] }}
+ */
+export function extractCliVersions(text) {
+  const found = new Set();
+  const patterns = [
+    // "cc CLI 0.162.150", "CLI 0.162.150"
+    new RegExp(`(?:cc\\s+)?cli\\s+${V}`, "gi"),
+    // "chainlesschain` 0.162.149 → **0.162.150**" (capture the arrow target)
+    new RegExp(
+      `chainlesschain[\`\\s]+(?:\\d+\\.\\d+\\.\\d+\\s*(?:→|->)\\s*)?\\*{0,2}${V}`,
+      "gi",
+    ),
+    // bare "cli 0.162.71" inside "(pdh 0.4.25 / cli 0.162.71)"
+    new RegExp(`\\bcli\\s+${V}`, "gi"),
+    // "→ 0.162.150" / "→ **0.162.150**"
+    new RegExp(`(?:→|->)\\s*\\*{0,2}${V}`, "gi"),
+  ];
+  for (const re of patterns) {
+    let m;
+    while ((m = re.exec(text)) !== null) {
+      found.add(m[1]);
+    }
+  }
+  // The CLI npm package (`chainlesschain`) is on the 0.x alpha track; the
+  // product line is 5.x. Keeping only major-0 tokens discards any product
+  // version (v5.0.3.x) or desktop-app-vue (5.0.3-alpha.x) tokens that slip past
+  // the context regexes, so the "primary" is always a real CLI npm version.
+  const all = [...found].filter((v) => v.startsWith("0."));
+  const primary =
+    all.length === 0
+      ? null
+      : all.reduce(
+          (best, v) => (compareSemver(v, best) > 0 ? v : best),
+          all[0],
+        );
+  return { primary, all };
+}
+
+/** Numeric semver compare for plain X.Y.Z (no prerelease). */
+export function compareSemver(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) !== (pb[i] || 0)) return (pa[i] || 0) - (pb[i] || 0);
+  }
+  return 0;
+}
+
+/**
+ * Parse a raw CHANGELOG.md string into CLI-focused release entries.
+ *
+ * @param {string} md
+ * @returns {Array<{
+ *   productVersion: string,
+ *   cliVersion: string|null,
+ *   cliVersions: string[],
+ *   date: string|null,
+ *   title: string,
+ *   sections: Array<{ heading: string, body: string }>,
+ * }>}
+ */
+export function parseChangelog(md) {
+  const lines = md.split(/\r?\n/);
+  const blocks = [];
+  let current = null;
+
+  for (const line of lines) {
+    const h2 = line.match(/^##\s+(.+)$/);
+    if (h2 && !line.startsWith("###")) {
+      if (current) blocks.push(current);
+      current = { header: h2[1].trim(), lines: [] };
+      continue;
+    }
+    if (current) current.lines.push(line);
+  }
+  if (current) blocks.push(current);
+
+  const releases = [];
+  for (const block of blocks) {
+    const parsed = parseBlockHeader(block.header);
+    const bodyText = block.lines.join("\n");
+    const fullText = block.header + "\n" + bodyText;
+
+    const { primary, all } = extractCliVersions(fullText);
+    // A release must reference a CLI npm version at all.
+    if (!primary) continue;
+
+    // CLI-relevance gate is decided by section HEADINGS (or, for a section-less
+    // block, by CLI-publish language) — not by a bare bundled-cli mention.
+    const sections = extractCliSections(block.lines, block.header);
+    if (!sections) continue;
+
+    releases.push({
+      productVersion: parsed.version,
+      cliVersion: primary,
+      cliVersions: all.sort(compareSemver),
+      date: parsed.date,
+      title: parsed.title,
+      sections,
+    });
+  }
+  return releases;
+}
+
+/** Parse "## [v5.0.3.134] - 2026-07-03 — title" into parts. */
+function parseBlockHeader(header) {
+  const tag = header.match(/\[([^\]]+)\]/);
+  const version = tag ? tag[1] : header;
+  const rest = header.replace(/\[[^\]]+\]\s*/, "");
+  const dateMatch = rest.match(/(\d{4}-\d{2}-\d{2})/);
+  const date = dateMatch ? dateMatch[1] : null;
+  // Title = text after the em dash separator, else whatever remains.
+  let title = "";
+  const emDash = rest.split(/\s+—\s+/);
+  if (emDash.length > 1) {
+    title = emDash.slice(1).join(" — ").trim();
+  } else {
+    title = rest
+      .replace(/^-\s*/, "")
+      .replace(/\d{4}-\d{2}-\d{2}/, "")
+      .trim();
+  }
+  return { version, date, title };
+}
+
+/**
+ * Split a block body into `### ` sub-sections and keep only CLI-relevant ones.
+ *
+ * Returns:
+ *  - an array of CLI sections, when the block is a CLI release; or
+ *  - `null`, when the block is NOT a CLI release (all-non-CLI sub-sections, e.g.
+ *    a PDH/Android collector release that merely bundles a new cli version).
+ *
+ * @param {string[]} bodyLines
+ * @param {string} header
+ * @returns {Array<{heading:string, body:string}>|null}
+ */
+function extractCliSections(bodyLines, header) {
+  const sections = [];
+  const preamble = [];
+  let cur = null;
+  for (const line of bodyLines) {
+    const h3 = line.match(/^###\s+(.+)$/);
+    if (h3) {
+      if (cur) sections.push(cur);
+      cur = { heading: h3[1].trim(), lines: [] };
+      continue;
+    }
+    if (cur) cur.lines.push(line);
+    else preamble.push(line); // before the first ### (blockquote summary etc.)
+  }
+  if (cur) sections.push(cur);
+
+  if (sections.length === 0) {
+    // Section-less block: CLI release only if the `##` TITLE names the CLI.
+    // The preamble is NOT consulted — every block carries a boilerplate
+    // "Version surfaces: CLI 0.162.x → ..." line, so a body match would let
+    // every PDH/Android release through.
+    if (!CLI_PUBLISH_SIGNAL.test(header)) return null;
+    const body = preamble.join("\n").trim();
+    return body ? [{ heading: "", body }] : [];
+  }
+
+  const cliSections = sections
+    .filter((s) => CLI_HEADING_SIGNAL.test(s.heading))
+    .map((s) => ({ heading: s.heading, body: s.lines.join("\n").trim() }));
+
+  // Has `### ` sections but none are CLI-headed → not a CLI release.
+  return cliSections.length > 0 ? cliSections : null;
+}
+
+/**
+ * Resolve and load the CLI changelog data.
+ *
+ * Order is CHANGELOG-FIRST so the data can never go stale: when the repo-root
+ * CHANGELOG.md is reachable (source checkout / dev / this monorepo) it is parsed
+ * live, always reflecting the latest edits. The bundled `src/data/changelog.json`
+ * (a build artifact, refreshed at `prepublishOnly`) is only the fallback for an
+ * installed npm package, where CHANGELOG.md is not shipped.
+ *
+ * @returns {{ source: string, releases: Array }}
+ */
+export function loadChangelog() {
+  const changelogCandidates = [
+    path.join(__dirname, "..", "..", "CHANGELOG.md"), // packages/cli/CHANGELOG.md
+    path.join(__dirname, "..", "..", "..", "..", "CHANGELOG.md"), // repo root
+  ];
+  for (const p of changelogCandidates) {
+    if (fs.existsSync(p)) {
+      return {
+        source: "CHANGELOG.md",
+        releases: parseChangelog(fs.readFileSync(p, "utf-8")),
+      };
+    }
+  }
+  // Installed npm package: CHANGELOG.md isn't shipped, use the bundled artifact.
+  const jsonPath = path.join(__dirname, "..", "data", "changelog.json");
+  if (fs.existsSync(jsonPath)) {
+    try {
+      const data = JSON.parse(fs.readFileSync(jsonPath, "utf-8"));
+      if (Array.isArray(data.releases)) return data;
+    } catch {
+      /* fall through to empty */
+    }
+  }
+  return { source: null, releases: [] };
+}

package/src/lib/eval/tasks.js

@@ -30,6 +30,39 @@ const STRINGUTIL_V2 =
   "  return str.charAt(0).toUpperCase() + str.slice(1);\n" +
   "}\n";
 
+// Harness files the agent is told NOT to edit, shared by setup and check so the
+// check can byte-compare them (same anti-cheat as STRINGUTIL_V2 above). A mere
+// presence-regex is neuterable: prepending `console.log('ALL OK');
+// process.exit(0)` keeps the assertion text present while never running it.
+const RUN_CHECKS_MJS = [
+  "import { sum } from './calc.js';",
+  "const cases = [[1,2,3],[10,5,15],[0,0,0]];",
+  "for (const [a,b,want] of cases) {",
+  "  if (sum(a,b) !== want) {",
+  "    console.error(`FAIL sum(${a},${b})=${sum(a,b)} want ${want}`);",
+  "    process.exit(1);",
+  "  }",
+  "}",
+  "console.log('ALL OK');",
+  "",
+].join("\n");
+
+const BUILD_MJS =
+  'import { banner } from "./app.mjs";\n' +
+  'if (banner() !== "v1.0.0") {\n' +
+  '  console.error("BUILD FAIL: " + banner());\n' +
+  "  process.exit(1);\n" +
+  "}\n" +
+  'console.log("BUILD OK");\n';
+
+const RUN_MJS =
+  'import { label } from "./app.mjs";\n' +
+  'if (label("hello") !== "Hello") {\n' +
+  '  console.error("FAIL: " + label("hello"));\n' +
+  "  process.exit(1);\n" +
+  "}\n" +
+  'console.log("OK");\n';
+
 export const BUILTIN_TASKS = [
   {
     id: "create-file",
@@ -134,32 +167,22 @@ export const BUILTIN_TASKS = [
       );
       fs.writeFileSync(
         path.join(dir, "run-checks.mjs"),
-        [
-          "import { sum } from './calc.js';",
-          "const cases = [[1,2,3],[10,5,15],[0,0,0]];",
-          "for (const [a,b,want] of cases) {",
-          "  if (sum(a,b) !== want) {",
-          "    console.error(`FAIL sum(${a},${b})=${sum(a,b)} want ${want}`);",
-          "    process.exit(1);",
-          "  }",
-          "}",
-          "console.log('ALL OK');",
-          "",
-        ].join("\n"),
+        RUN_CHECKS_MJS,
         "utf8",
       );
     },
     check: (dir) => {
-      // Objective: the test harness must actually pass. Guard against the agent
-      // "fixing" it by neutering run-checks.mjs — require the assertions to
-      // still be present.
+      // Objective: the test harness must actually pass. Byte-compare the
+      // harness — a presence-regex alone is neuterable (prepend an early
+      // `console.log('ALL OK'); process.exit(0)` and the assertion text is
+      // still there but never runs).
       const checks = read(dir, "run-checks.mjs");
       if (checks == null)
         return { pass: false, detail: "run-checks.mjs missing" };
-      if (!/sum\(a,\s*b\)\s*!==\s*want/.test(checks)) {
+      if (checks !== RUN_CHECKS_MJS) {
         return {
           pass: false,
-          detail: "run-checks.mjs assertions were altered",
+          detail: "run-checks.mjs was edited (fix calc.js instead)",
         };
       }
       try {
@@ -487,23 +510,19 @@ export const BUILTIN_TASKS = [
           'export function banner() {\n  return "v" + VERSION;\n}\n',
         "utf8",
       );
-      fs.writeFileSync(
-        path.join(dir, "build.mjs"),
-        'import { banner } from "./app.mjs";\n' +
-          'if (banner() !== "v1.0.0") {\n' +
-          '  console.error("BUILD FAIL: " + banner());\n' +
-          "  process.exit(1);\n" +
-          "}\n" +
-          'console.log("BUILD OK");\n',
-        "utf8",
-      );
+      fs.writeFileSync(path.join(dir, "build.mjs"), BUILD_MJS, "utf8");
     },
     check: (dir) => {
       const build = read(dir, "build.mjs");
       if (build == null) return { pass: false, detail: "build.mjs missing" };
-      // Guard: fix the modules, don't neuter the build harness.
-      if (!/banner\(\)\s*!==\s*"v1\.0\.0"/.test(build)) {
-        return { pass: false, detail: "build.mjs assertion was altered" };
+      // Guard: fix the modules, don't neuter the build harness. Byte-compare —
+      // a presence-regex is satisfiable by a rewritten build.mjs that defines
+      // its own banner() and never imports app.mjs.
+      if (build !== BUILD_MJS) {
+        return {
+          pass: false,
+          detail: "build.mjs was edited (reconcile config.mjs/app.mjs instead)",
+        };
       }
       try {
         const out = execFileSync(process.execPath, ["build.mjs"], {
@@ -534,7 +553,7 @@ export const BUILTIN_TASKS = [
       "`capitalize` export was renamed to `toTitle` (same behavior). Do all of: " +
       "(1) bump stringutil to ^2.0.0 in package.json; (2) update app.mjs to " +
       "import and use `toTitle` instead of `capitalize`; (3) do NOT edit " +
-      "stringutil.mjs. Afterwards `node run.mjs` must print OK.",
+      "stringutil.mjs or run.mjs. Afterwards `node run.mjs` must print OK.",
     setup: (dir) => {
       fs.writeFileSync(
         path.join(dir, "package.json"),
@@ -558,16 +577,7 @@ export const BUILTIN_TASKS = [
           "export function label(s) {\n  return capitalize(s);\n}\n",
         "utf8",
       );
-      fs.writeFileSync(
-        path.join(dir, "run.mjs"),
-        'import { label } from "./app.mjs";\n' +
-          'if (label("hello") !== "Hello") {\n' +
-          '  console.error("FAIL: " + label("hello"));\n' +
-          "  process.exit(1);\n" +
-          "}\n" +
-          'console.log("OK");\n',
-        "utf8",
-      );
+      fs.writeFileSync(path.join(dir, "run.mjs"), RUN_MJS, "utf8");
     },
     check: (dir) => {
       // The dependency is vendored — the agent must adapt the caller, NOT edit
@@ -580,6 +590,17 @@ export const BUILTIN_TASKS = [
           detail: "the stringutil dependency was edited (adapt the caller)",
         };
       }
+      // The run harness is equally off-limits: without this guard an agent
+      // could overwrite run.mjs with `console.log("OK")` and pass the textual
+      // checks below without app.mjs ever being executed.
+      const runner = read(dir, "run.mjs");
+      if (runner == null) return { pass: false, detail: "run.mjs missing" };
+      if (runner !== RUN_MJS) {
+        return {
+          pass: false,
+          detail: "run.mjs was edited (adapt app.mjs/package.json instead)",
+        };
+      }
       const pkg = read(dir, "package.json");
       if (pkg == null || !/"stringutil"\s*:\s*"[\^~]?2\./.test(pkg)) {
         return {

package/src/lib/eval/trend.js

@@ -84,7 +84,13 @@ function ordered(records) {
  * }}
  */
 export function computeTrend(runs, { regressionThreshold = 0 } = {}) {
-  const norm = ordered((runs || []).map((r) => summarizeRun(r)));
+  // A dry-run record is always 0% (the no-op agent creates nothing) — folding
+  // it in would flag every previously-passing task as a regression (or, in the
+  // other direction, fake an "all fixed" jump). Smoke-testing with
+  // `--dry-run --history` must not poison the release gate.
+  const norm = ordered(
+    (runs || []).filter((r) => r?.dryRun !== true).map((r) => summarizeRun(r)),
+  );
   const history = norm.map((r) => r.passRate);
   if (norm.length === 0) {
     return {

package/src/lib/lsp/__tests__/lsp-client.test.js

@@ -225,14 +225,20 @@ describe("uri <-> path", () => {
 describe("normalizeUri", () => {
   it("lowercases the windows drive letter so client/server keys match", () => {
     // path.resolve yields C:, servers echo c: — must collapse to one key
-    expect(normalizeUri("file:///C%3A/proj/a.ts")).toBe(
-      "file:///c%3A/proj/a.ts",
-    );
-    expect(normalizeUri("file:///c%3A/proj/a.ts")).toBe(
-      "file:///c%3A/proj/a.ts",
-    );
+    expect(normalizeUri("file:///C%3A/proj/a.ts")).toBe("file:///c:/proj/a.ts");
+    expect(normalizeUri("file:///c%3A/proj/a.ts")).toBe("file:///c:/proj/a.ts");
     expect(normalizeUri("file:///C:/proj/a.ts")).toBe("file:///c:/proj/a.ts");
   });
+  it("collapses the %3A and bare-colon drive forms to ONE key (gopls)", () => {
+    // The client sends percent-encoded didOpen URIs (file:///C%3A/…);
+    // tsserver/pyright echo that form back, but gopls REWRITES to a bare
+    // colon (file:///C:/…). Before this canonicalization the two forms were
+    // distinct diagnostics-Map keys, so every gopls publish missed the
+    // didOpen key and `cc code-intel diag` on Go was permanently empty.
+    const ours = normalizeUri("file:///C%3A/Users/u/goproj/broken.go");
+    const goplsPublished = normalizeUri("file:///C:/Users/u/goproj/broken.go");
+    expect(ours).toBe(goplsPublished);
+  });
   it("leaves POSIX file URIs unchanged", () => {
     expect(normalizeUri("file:///home/u/a.ts")).toBe("file:///home/u/a.ts");
   });

package/src/lib/lsp/code-intelligence.js

@@ -85,11 +85,15 @@ export class CodeIntelligence {
   async references(filePath, line, col, { includeDeclaration = true } = {}) {
     const ready = await this._ensure(filePath);
     if (ready.unavailable) return unavailable(ready.reason);
-    const result = await ready.client.request("textDocument/references", {
-      textDocument: { uri: ready.uri },
-      position: toLspPosition({ line, col }),
-      context: { includeDeclaration },
-    });
+    const result = await this._readRequest(
+      ready.client,
+      "textDocument/references",
+      {
+        textDocument: { uri: ready.uri },
+        position: toLspPosition({ line, col }),
+        context: { includeDeclaration },
+      },
+    );
     return { available: true, locations: this._normalizeLocations(result) };
   }
 
@@ -97,7 +101,7 @@ export class CodeIntelligence {
   async hover(filePath, line, col) {
     const ready = await this._ensure(filePath);
     if (ready.unavailable) return unavailable(ready.reason);
-    const result = await ready.client.request("textDocument/hover", {
+    const result = await this._readRequest(ready.client, "textDocument/hover", {
       textDocument: { uri: ready.uri },
       position: toLspPosition({ line, col }),
     });
@@ -108,9 +112,13 @@ export class CodeIntelligence {
   async documentSymbols(filePath) {
     const ready = await this._ensure(filePath);
     if (ready.unavailable) return unavailable(ready.reason);
-    const result = await ready.client.request("textDocument/documentSymbol", {
-      textDocument: { uri: ready.uri },
-    });
+    const result = await this._readRequest(
+      ready.client,
+      "textDocument/documentSymbol",
+      {
+        textDocument: { uri: ready.uri },
+      },
+    );
     return {
       available: true,
       symbols: this._normalizeSymbols(result, ready.uri),
@@ -124,7 +132,9 @@ export class CodeIntelligence {
     if (!seed) return unavailable("no indexable file found to start a server");
     const ready = await this.manager.ensureFor(seed, this._ensureOpts);
     if (ready.unavailable) return unavailable(ready.reason);
-    const result = await ready.client.request("workspace/symbol", { query });
+    const result = await this._readRequest(ready.client, "workspace/symbol", {
+      query,
+    });
     return { available: true, symbols: this._normalizeSymbols(result) };
   }
 
@@ -160,7 +170,8 @@ export class CodeIntelligence {
     const caps = ready.client.serverCapabilities || {};
     if (caps.diagnosticProvider) {
       try {
-        const report = await ready.client.request(
+        const report = await this._readRequest(
+          ready.client,
           "textDocument/diagnostic",
           { textDocument: { uri: ready.uri } },
           { timeoutMs },
@@ -182,11 +193,15 @@ export class CodeIntelligence {
   async renamePreview(filePath, line, col, newName) {
     const ready = await this._ensure(filePath);
     if (ready.unavailable) return unavailable(ready.reason);
-    const result = await ready.client.request("textDocument/rename", {
-      textDocument: { uri: ready.uri },
-      position: toLspPosition({ line, col }),
-      newName,
-    });
+    const result = await this._readRequest(
+      ready.client,
+      "textDocument/rename",
+      {
+        textDocument: { uri: ready.uri },
+        position: toLspPosition({ line, col }),
+        newName,
+      },
+    );
     return { available: true, edits: this._normalizeWorkspaceEdit(result) };
   }
 
@@ -196,10 +211,33 @@ export class CodeIntelligence {
 
   // ---- internals ----
 
+  /**
+   * Issue an idempotent READ request with a bounded ContentModified retry.
+   * LSP -32801 (ContentModified) means "server state changed mid-request —
+   * the result would be stale, ask again"; rust-analyzer emits it freely
+   * while its index is still settling after didOpen. Read-only queries can
+   * always be retried; mutating requests must NOT go through here.
+   */
+  async _readRequest(client, method, params, opts) {
+    let lastErr;
+    for (let attempt = 0; attempt < 4; attempt++) {
+      try {
+        return await client.request(method, params, opts);
+      } catch (err) {
+        const contentModified =
+          err?.code === -32801 || /content modified/i.test(err?.message || "");
+        if (!contentModified) throw err;
+        lastErr = err;
+        await new Promise((r) => setTimeout(r, 500 * (attempt + 1)));
+      }
+    }
+    throw lastErr;
+  }
+
   async _locationQuery(method, filePath, line, col) {
     const ready = await this._ensure(filePath);
     if (ready.unavailable) return unavailable(ready.reason);
-    const result = await ready.client.request(method, {
+    const result = await this._readRequest(ready.client, method, {
       textDocument: { uri: ready.uri },
       position: toLspPosition({ line, col }),
     });

package/src/lib/lsp/lsp-client.js

@@ -297,9 +297,15 @@ export function pathToFileUri(p) {
  */
 export function normalizeUri(uri) {
   if (!uri) return uri;
+  // Canonicalize BOTH the drive-letter case AND the colon encoding. Servers
+  // differ in the form they publish back: tsserver/pyright echo the client's
+  // percent-encoded `c%3A/…`, but gopls rewrites to a bare `C:/…` — keeping
+  // the incoming colon form made the two forms distinct Map keys, so every
+  // gopls publishDiagnostics missed the didOpen key and Go diagnostics were
+  // permanently empty regardless of timeout.
   return String(uri).replace(
     /^(file:\/\/\/)([A-Za-z])(%3[Aa]|:)/,
-    (_m, p, drive, colon) => p + drive.toLowerCase() + colon,
+    (_m, p, drive) => p + drive.toLowerCase() + ":",
   );
 }
 

package/src/lib/lsp/lsp-server-registry.js

@@ -70,6 +70,13 @@ function tsServer() {
 // Registry of plugin-contributed servers, keyed by languageId. Wins over
 // builtins if a plugin explicitly overrides.
 const pluginServers = new Map();
+// Plugin-contributed extension→languageId overrides, kept SEPARATE from the
+// builtin EXTENSION_LANGUAGE map so `_resetPluginServers` (used by
+// `/reload-plugins`) can fully roll them back. Mutating the builtin map
+// directly meant an uninstalled/untrusted plugin's `.py`→"mylang" remap
+// survived a reload — languageIdForFile kept returning the dead languageId and
+// the builtin server for that extension became unreachable until process exit.
+const pluginExtensions = new Map();
 
 /**
  * Register an extra language server (from a plugin `.lsp.json`).
@@ -87,21 +94,25 @@ export function registerLanguageServer(def) {
   });
   if (Array.isArray(def.extensions)) {
     for (const ext of def.extensions) {
-      EXTENSION_LANGUAGE[ext.startsWith(".") ? ext : "." + ext] =
-        def.languageId;
+      pluginExtensions.set(
+        ext.startsWith(".") ? ext : "." + ext,
+        def.languageId,
+      );
     }
   }
 }
 
-/** Test/reset hook — clears plugin registrations. */
+/** Test/reset hook — clears plugin registrations (servers AND extension maps). */
 export function _resetPluginServers() {
   pluginServers.clear();
+  pluginExtensions.clear();
 }
 
 /** Map a file path to its LSP languageId, or null if unsupported. */
 export function languageIdForFile(filePath) {
   const ext = path.extname(String(filePath || "")).toLowerCase();
-  return EXTENSION_LANGUAGE[ext] || null;
+  // Plugin overrides win over builtins (same precedence as pluginServers).
+  return pluginExtensions.get(ext) || EXTENSION_LANGUAGE[ext] || null;
 }
 
 /**

package/src/lib/plugin-runtime/hooks.js

@@ -60,11 +60,27 @@ export function collectPluginHooks(opts = {}) {
   for (const p of trusted) {
     if (!p.manifest || p.manifest.ok !== true) continue;
     const h = p.manifest.components?.hooks;
-    if (!h || !h.absPath) continue;
+    if (!h) continue;
     let parsed;
-    try {
-      parsed = JSON.parse(_deps.readFileSync(h.absPath, "utf8"));
-    } catch {
+    if (h.absPath) {
+      try {
+        parsed = JSON.parse(_deps.readFileSync(h.absPath, "utf8"));
+      } catch {
+        continue;
+      }
+    } else if (h.inline) {
+      // Hooks declared inline in plugin.json — the normalized component keeps
+      // only counts, so re-read the raw manifest for the actual entries (same
+      // approach as the MCP collector). Without this, inline hooks never fire.
+      try {
+        const raw = JSON.parse(
+          _deps.readFileSync(p.manifest.manifestPath, "utf8"),
+        );
+        parsed = raw && typeof raw === "object" ? raw.hooks : null;
+      } catch {
+        continue;
+      }
+    } else {
       continue;
     }
     const map = normalizeHookMap(parsed);