@duckmind/dm-linux-x64 0.63.9 → 0.64.2

package/extensions/dm-lens/clients/gzip-stage-write.js

@@ -0,0 +1,85 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { parentPort } from "node:worker_threads";
+import { createGzip } from "node:zlib";
+import { stagePathFor } from "./atomic-write-staging.js";
+export async function writeGzipStageFile(data, stagePath, testDelayMs, options) {
+  const startedAt = performance.now();
+  const tmpPath = stagePathFor(stagePath);
+  try {
+    if (testDelayMs) {
+      await new Promise((resolve) => setTimeout(resolve, testDelayMs));
+    }
+    const serializeStarted = performance.now();
+    const json = JSON.stringify(data);
+    const serializeMs = performance.now() - serializeStarted;
+    const rawBytes = Buffer.byteLength(json);
+    const semanticFingerprint = options?.semanticFingerprint?.(json);
+    if (semanticFingerprint !== undefined && options?.skipIfFingerprints?.includes(semanticFingerprint)) {
+      return {
+        rawBytes,
+        gzBytes: 0,
+        serializeMs,
+        writeMs: 0,
+        durationMs: performance.now() - startedAt,
+        semanticFingerprint,
+        skippedUnchanged: true
+      };
+    }
+    const writeStarted = performance.now();
+    await fs.promises.mkdir(path.dirname(stagePath), { recursive: true });
+    const chunks = function* () {
+      const chunkChars = 256 * 1024;
+      for (let offset = 0;offset < json.length; offset += chunkChars) {
+        yield json.slice(offset, offset + chunkChars);
+      }
+    };
+    await pipeline(Readable.from(chunks()), createGzip(), fs.createWriteStream(tmpPath));
+    await fs.promises.rename(tmpPath, stagePath);
+    const writeMs = performance.now() - writeStarted;
+    const gzBytes = (await fs.promises.stat(stagePath)).size;
+    return {
+      rawBytes,
+      gzBytes,
+      serializeMs,
+      writeMs,
+      durationMs: performance.now() - startedAt,
+      semanticFingerprint
+    };
+  } catch (err) {
+    await fs.promises.rm(tmpPath, { force: true }).catch(() => {});
+    throw err;
+  }
+}
+export function serveGzipStageWorker(buildBaseResult, options) {
+  const port = parentPort;
+  if (!port) {
+    throw new Error("gzip stage persist worker requires a parent port");
+  }
+  port.on("message", (request) => {
+    (async () => {
+      const result = {
+        ...buildBaseResult(request)
+      };
+      try {
+        const fingerprint = options?.semanticFingerprint;
+        const metrics = await writeGzipStageFile(request.data, request.stagePath, request.testDelayMs, {
+          semanticFingerprint: fingerprint ? (json) => fingerprint(request, json) : undefined,
+          skipIfFingerprints: options?.skipIfFingerprints?.(request)
+        });
+        result.rawBytes = metrics.rawBytes;
+        result.gzBytes = metrics.gzBytes;
+        result.serializeMs = metrics.serializeMs;
+        result.writeMs = metrics.writeMs;
+        result.durationMs = metrics.durationMs;
+        result.semanticFingerprint = metrics.semanticFingerprint;
+        result.skippedUnchanged = metrics.skippedUnchanged;
+      } catch (err) {
+        result.error = err instanceof Error ? err.message : String(err);
+      }
+      port.postMessage(result);
+    })();
+  });
+}

package/extensions/dm-lens/clients/hashline-anchor.js

@@ -0,0 +1,222 @@
+import * as nodeFs from "node:fs";
+import { BoundedFifoMap } from "./bounded-cache.js";
+const HASHLINE_ANCHOR_LENGTH = 3;
+const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+const HASH_SPACE = ALPHABET.length ** HASHLINE_ANCHOR_LENGTH;
+const HASH_PROBE_STRIDE = ALPHABET.length ** 2 + ALPHABET.length + 1;
+const MAX_HASH_SOURCE_BYTES = 500;
+const BITSET_WORDS = Math.ceil(HASH_SPACE / 32);
+const ANCHOR_TOKEN_RE = /^[A-Za-z0-9]{3}$/;
+const XXH_PRIME1 = 2654435761;
+const XXH_PRIME2 = 2246822519;
+const XXH_PRIME3 = 3266489917;
+const XXH_PRIME4 = 668265263;
+const XXH_PRIME5 = 374761393;
+function rotl32(value, bits) {
+  return value << bits | value >>> 32 - bits;
+}
+function xxhRound(acc, input) {
+  return Math.imul(rotl32(acc + Math.imul(input, XXH_PRIME2) | 0, 13), XXH_PRIME1) | 0;
+}
+export function xxh32Bytes(bytes) {
+  const length = bytes.length;
+  let index = 0;
+  let hash;
+  if (length >= 16) {
+    const limit = length - 16;
+    let v1 = XXH_PRIME1 + XXH_PRIME2 | 0;
+    let v2 = XXH_PRIME2 | 0;
+    let v3 = 0;
+    let v4 = -XXH_PRIME1 | 0;
+    do {
+      v1 = xxhRound(v1, readU32(bytes, index));
+      v2 = xxhRound(v2, readU32(bytes, index + 4));
+      v3 = xxhRound(v3, readU32(bytes, index + 8));
+      v4 = xxhRound(v4, readU32(bytes, index + 12));
+      index += 16;
+    } while (index <= limit);
+    hash = rotl32(v1, 1) + rotl32(v2, 7) + rotl32(v3, 12) + rotl32(v4, 18) | 0;
+  } else {
+    hash = XXH_PRIME5 | 0;
+  }
+  hash = hash + length | 0;
+  while (index + 4 <= length) {
+    hash = Math.imul(rotl32(hash + Math.imul(readU32(bytes, index), XXH_PRIME3) | 0, 17), XXH_PRIME4) | 0;
+    index += 4;
+  }
+  while (index < length) {
+    hash = Math.imul(rotl32(hash + Math.imul(bytes[index], XXH_PRIME5) | 0, 11), XXH_PRIME1) | 0;
+    index += 1;
+  }
+  hash = hash ^ hash >>> 15 | 0;
+  hash = Math.imul(hash, XXH_PRIME2) | 0;
+  hash = hash ^ hash >>> 13 | 0;
+  hash = Math.imul(hash, XXH_PRIME3) | 0;
+  hash = hash ^ hash >>> 16 | 0;
+  return hash >>> 0;
+}
+function readU32(bytes, offset) {
+  return bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16 | bytes[offset + 3] << 24 | 0;
+}
+function canon(line) {
+  return line.replace(/\r/g, "").trimEnd();
+}
+function splitLines(text) {
+  if (text.length === 0)
+    return [""];
+  const lines = text.split(`
+`);
+  return text.endsWith(`
+`) ? lines.slice(0, -1) : lines;
+}
+function hashSourceBytes(line) {
+  const bytes = Buffer.from(canon(line), "utf8");
+  if (bytes.length <= MAX_HASH_SOURCE_BYTES)
+    return bytes;
+  let cut = MAX_HASH_SOURCE_BYTES;
+  while (cut > 0 && (bytes[cut] & 192) === 128)
+    cut -= 1;
+  return bytes.subarray(0, cut);
+}
+function hashSourceKey(line) {
+  return Buffer.from(hashSourceBytes(line)).toString("utf8");
+}
+function indexToAnchor(index) {
+  let out = "";
+  let remaining = index;
+  for (let digit = 0;digit < HASHLINE_ANCHOR_LENGTH; digit += 1) {
+    out = ALPHABET[remaining % ALPHABET.length] + out;
+    remaining = Math.floor(remaining / ALPHABET.length);
+  }
+  return out;
+}
+function getBit(bits, index) {
+  return (bits[index >>> 5] >>> (index & 31) & 1) !== 0;
+}
+function setBit(bits, index) {
+  bits[index >>> 5] |= 1 << (index & 31);
+}
+function nextZeroBit(bits, start) {
+  let index = start % HASH_SPACE;
+  for (let step = 0;step < HASH_SPACE; step += 1) {
+    if (!getBit(bits, index))
+      return index;
+    index += HASH_PROBE_STRIDE;
+    if (index >= HASH_SPACE)
+      index -= HASH_SPACE;
+  }
+  return -1;
+}
+export function computeHashlineAnchors(content) {
+  const lines = splitLines(content);
+  if (lines.length > HASH_SPACE)
+    return;
+  const anchors = [];
+  anchors.length = lines.length;
+  const used = new Uint32Array(BITSET_WORDS);
+  let hint = 0;
+  const sourceCache = new Map;
+  for (let i = 0;i < lines.length; i += 1) {
+    const line = lines[i];
+    let baseIndex = sourceCache.get(line);
+    if (baseIndex === undefined) {
+      baseIndex = (xxh32Bytes(hashSourceBytes(line)) >>> 14) % HASH_SPACE;
+      sourceCache.set(line, baseIndex);
+    }
+    if (!getBit(used, baseIndex)) {
+      setBit(used, baseIndex);
+      hint = baseIndex + HASH_PROBE_STRIDE;
+      anchors[i] = indexToAnchor(baseIndex);
+      continue;
+    }
+    const probed = nextZeroBit(used, hint);
+    if (probed < 0)
+      return;
+    setBit(used, probed);
+    hint = probed + HASH_PROBE_STRIDE;
+    anchors[i] = indexToAnchor(probed);
+  }
+  return anchors;
+}
+export function normalizeHashlineAnchorToken(value) {
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  return ANCHOR_TOKEN_RE.test(trimmed) ? trimmed : undefined;
+}
+const MAX_ANCHOR_FILE_BYTES = 4 * 1024 * 1024;
+const ANCHOR_INDEX_CACHE_LIMIT = 8;
+const ANCHOR_INDEX_CACHE = new BoundedFifoMap(ANCHOR_INDEX_CACHE_LIMIT);
+export function dropHashlineAnchorMemo() {
+  ANCHOR_INDEX_CACHE.clear();
+}
+function buildAnchorIndex(filePath) {
+  let stats;
+  try {
+    stats = nodeFs.statSync(filePath);
+  } catch {
+    return { failure: "file_unreadable" };
+  }
+  if (!stats.isFile())
+    return { failure: "file_unreadable" };
+  if (stats.size > MAX_ANCHOR_FILE_BYTES)
+    return { failure: "file_too_large" };
+  const cached = ANCHOR_INDEX_CACHE.get(filePath);
+  if (cached && cached.mtimeMs === stats.mtimeMs && cached.size === stats.size) {
+    return { index: cached.index, contentUnique: cached.contentUnique };
+  }
+  let raw;
+  try {
+    raw = nodeFs.readFileSync(filePath, "utf8");
+  } catch {
+    return { failure: "file_unreadable" };
+  }
+  const normalized = (raw.startsWith("\uFEFF") ? raw.slice(1) : raw).replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+  const anchors = computeHashlineAnchors(normalized);
+  if (anchors === undefined)
+    return { failure: "file_too_large" };
+  const index = new Map;
+  for (let i = 0;i < anchors.length; i += 1) {
+    index.set(anchors[i], i + 1);
+  }
+  const lines = splitLines(normalized);
+  const keys = [];
+  keys.length = lines.length;
+  const keyCounts = new Map;
+  const keyCache = new Map;
+  for (let i = 0;i < lines.length; i += 1) {
+    const line = lines[i];
+    let key = keyCache.get(line);
+    if (key === undefined) {
+      key = hashSourceKey(line);
+      keyCache.set(line, key);
+    }
+    keys[i] = key;
+    keyCounts.set(key, (keyCounts.get(key) ?? 0) + 1);
+  }
+  const contentUnique = keys.map((key) => keyCounts.get(key) === 1);
+  ANCHOR_INDEX_CACHE.set(filePath, {
+    mtimeMs: stats.mtimeMs,
+    size: stats.size,
+    index,
+    contentUnique
+  });
+  return { index, contentUnique };
+}
+export function resolveHashlineAnchor(filePath, anchor) {
+  const token = normalizeHashlineAnchorToken(anchor);
+  if (token === undefined)
+    return { failure: "not_an_anchor" };
+  const built = buildAnchorIndex(filePath);
+  if ("failure" in built)
+    return { failure: built.failure };
+  const line = built.index.get(token);
+  if (line === undefined)
+    return { failure: "anchor_not_found" };
+  if (built.contentUnique[line - 1] !== true) {
+    return { failure: "content_not_unique" };
+  }
+  return { line };
+}

package/extensions/dm-lens/clients/hook-budgets.js

@@ -0,0 +1,16 @@
+export const HOOK_WALL_BUDGET_MS = Object.freeze({
+  session_start: 5000,
+  turn_start: 0,
+  turn_end: 3000,
+  agent_end: 1000,
+  agent_settled: 1e4,
+  tool_result_read_only: 500,
+  tool_result_edit: 1e4,
+  session_shutdown: 0,
+  context: 0,
+  session_before_fork: 0
+});
+export const HOOK_BUDGET_KEYS = Object.keys(HOOK_WALL_BUDGET_MS);
+export function isHookBudgetKey(value) {
+  return Object.hasOwn(HOOK_WALL_BUDGET_MS, value);
+}

package/extensions/dm-lens/clients/host-edit-normalize.js

@@ -0,0 +1,87 @@
+export const HOST_EDIT_DIFF_SDK_FLOOR = "0.79.9";
+export const HOST_SMART_SINGLE_QUOTES = [8216, 8217, 8218, 8219];
+export const HOST_SMART_DOUBLE_QUOTES = [8220, 8221, 8222, 8223];
+export const HOST_UNICODE_DASHES = [
+  8208,
+  8209,
+  8210,
+  8211,
+  8212,
+  8213,
+  8722
+];
+export const HOST_SPECIAL_SPACES = [
+  160,
+  8194,
+  8195,
+  8196,
+  8197,
+  8198,
+  8199,
+  8200,
+  8201,
+  8202,
+  8239,
+  8287,
+  12288
+];
+export const HOST_BOM_CODE_POINT = 65279;
+const charClass = (codePoints) => new RegExp(`[${String.fromCharCode(...codePoints)}]`, "g");
+const SMART_SINGLE_QUOTES_RE = charClass(HOST_SMART_SINGLE_QUOTES);
+const SMART_DOUBLE_QUOTES_RE = charClass(HOST_SMART_DOUBLE_QUOTES);
+const UNICODE_DASHES_RE = charClass(HOST_UNICODE_DASHES);
+const SPECIAL_SPACES_RE = charClass(HOST_SPECIAL_SPACES);
+const BOM = String.fromCharCode(HOST_BOM_CODE_POINT);
+export function detectLineEnding(content) {
+  const crlfIdx = content.indexOf(`\r
+`);
+  const lfIdx = content.indexOf(`
+`);
+  if (lfIdx === -1)
+    return `
+`;
+  if (crlfIdx === -1)
+    return `
+`;
+  return crlfIdx < lfIdx ? `\r
+` : `
+`;
+}
+export function normalizeToLF(text) {
+  return text.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+}
+export function restoreLineEndings(text, ending) {
+  return ending === `\r
+` ? text.replace(/\n/g, `\r
+`) : text;
+}
+export function normalizeForFuzzyMatch(text) {
+  return text.normalize("NFKC").split(`
+`).map((line) => line.trimEnd()).join(`
+`).replace(SMART_SINGLE_QUOTES_RE, "'").replace(SMART_DOUBLE_QUOTES_RE, '"').replace(UNICODE_DASHES_RE, "-").replace(SPECIAL_SPACES_RE, " ");
+}
+export function stripBom(content) {
+  return content.startsWith(BOM) ? { bom: BOM, text: content.slice(1) } : { bom: "", text: content };
+}
+export function normalizeForGuardMatch(text) {
+  return normalizeForFuzzyMatch(normalizeToLF(stripBom(text).text));
+}
+export function hostWouldApplyOldText(content, oldText) {
+  const c = normalizeToLF(stripBom(content).text);
+  const o = normalizeToLF(stripBom(oldText).text);
+  if (o.length === 0) {
+    return { wouldApply: false, occurrences: 0, usedFuzzyMatch: false };
+  }
+  const exactFound = c.indexOf(o) !== -1;
+  const fuzzyContent = normalizeForFuzzyMatch(c);
+  const fuzzyOldText = normalizeForFuzzyMatch(o);
+  const fuzzyFound = fuzzyContent.indexOf(fuzzyOldText) !== -1;
+  const occurrences = fuzzyOldText.length === 0 ? 0 : fuzzyContent.split(fuzzyOldText).length - 1;
+  return {
+    wouldApply: (exactFound || fuzzyFound) && occurrences === 1,
+    occurrences,
+    usedFuzzyMatch: !exactFound && fuzzyFound
+  };
+}

package/extensions/dm-lens/clients/host-ports.js

@@ -0,0 +1,35 @@
+export function createDefaultHostPorts(overrides = {}) {
+  const unknownMode = () => "unknown";
+  const defaults = {
+    notify: { user: () => {} },
+    trust: { isProjectTrusted: () => "unknown" },
+    mode: {
+      current: unknownMode,
+      supportsTuiWidget: () => true,
+      suppressesUserNotify: () => false
+    },
+    log: { extension: () => {}, debug: () => {}, sink: () => () => {} },
+    emit: { bus: () => {} },
+    status: { set: () => {} },
+    spawn: { abortSignal: () => {
+      return;
+    }, isAllowed: () => true },
+    render: { invalidate: () => {} },
+    session: { id: () => {
+      return;
+    } },
+    workspace: { cwd: () => {
+      return;
+    }, projectRoot: () => {
+      return;
+    } },
+    flags: { get: () => {
+      return;
+    } },
+    tools: { has: async () => false, getActive: () => [], setActive: () => {} }
+  };
+  return Object.fromEntries(Object.entries(defaults).map(([group, value]) => [
+    group,
+    { ...value, ...overrides[group] }
+  ]));
+}

package/extensions/dm-lens/clients/indent-retarget.js

@@ -0,0 +1,75 @@
+export function retargetReplacementIndentation(newText, oldText, correctedOldText) {
+  const newline = newText.includes(`\r
+`) ? `\r
+` : `
+`;
+  const oldLines = oldText.replace(/\r\n/g, `
+`).split(`
+`);
+  const correctedLines = correctedOldText.replace(/\r\n/g, `
+`).split(`
+`);
+  if (oldLines.length !== correctedLines.length)
+    return;
+  const indentMap = new Map;
+  const ambiguousIndents = new Set;
+  for (let i = 0;i < oldLines.length; i += 1) {
+    const oldIndent = oldLines[i].match(/^[\t ]*/)?.[0] ?? "";
+    const correctedIndent = correctedLines[i].match(/^[\t ]*/)?.[0] ?? "";
+    if (oldIndent === correctedIndent)
+      continue;
+    const previous = indentMap.get(oldIndent);
+    if (previous !== undefined && previous !== correctedIndent) {
+      indentMap.delete(oldIndent);
+      ambiguousIndents.add(oldIndent);
+      continue;
+    }
+    if (!ambiguousIndents.has(oldIndent)) {
+      indentMap.set(oldIndent, correctedIndent);
+    }
+  }
+  if (indentMap.size === 0)
+    return;
+  let baseFrom = "";
+  let baseTo = "";
+  for (const [from, to] of indentMap) {
+    if (from.length > 0 && (baseFrom === "" || from.length < baseFrom.length)) {
+      baseFrom = from;
+      baseTo = to;
+    }
+  }
+  function resolveIndent(indent) {
+    if (indent === "")
+      return "";
+    const direct = indentMap.get(indent);
+    if (direct !== undefined)
+      return direct;
+    if (baseFrom.length > 0 && indent.length % baseFrom.length === 0 && baseFrom.repeat(indent.length / baseFrom.length) === indent) {
+      return baseTo.repeat(indent.length / baseFrom.length);
+    }
+    return;
+  }
+  let changed = false;
+  const newLines = newText.replace(/\r\n/g, `
+`).split(`
+`);
+  const retargetedLines = [];
+  for (const line of newLines) {
+    const indent = line.match(/^[\t ]*/)?.[0] ?? "";
+    if (indent === line) {
+      retargetedLines.push(line);
+      continue;
+    }
+    const resolved = resolveIndent(indent);
+    if (resolved === undefined) {
+      return;
+    }
+    if (resolved !== indent) {
+      changed = true;
+      retargetedLines.push(resolved + line.slice(indent.length));
+    } else {
+      retargetedLines.push(line);
+    }
+  }
+  return changed ? retargetedLines.join(newline) : undefined;
+}

package/extensions/dm-lens/clients/install-diagnostics.js

@@ -0,0 +1,121 @@
+import { createRequire } from "node:module";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+const require = createRequire(import.meta.url);
+const ISSUES_URL = "https://github.com/apmantza/dm-lens/issues";
+const CRITICAL_DEPS = [
+  "typescript",
+  "minimatch",
+  "typebox",
+  "js-yaml",
+  "vscode-jsonrpc",
+  "web-tree-sitter",
+  "@ast-grep/napi"
+];
+function safe(fn, fallback) {
+  try {
+    return fn();
+  } catch {
+    return fallback;
+  }
+}
+export function collectInstallDiagnostics() {
+  const notes = [];
+  const here = safe(() => path.dirname(fileURLToPath(import.meta.url)), "");
+  const pkgDir = safe(() => path.resolve(here, ".."), here);
+  let root = pkgDir;
+  for (let i = 0;i < 6; i++) {
+    if (safe(() => fs.existsSync(path.join(root, "package.json")), false))
+      break;
+    const up = path.dirname(root);
+    if (up === root)
+      break;
+    root = up;
+  }
+  const piLensVersion = safe(() => {
+    const pj = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
+    return String(pj.version ?? "unknown");
+  }, "unknown");
+  const bunVersion = globalThis.Bun?.version;
+  const runtime = bunVersion ? `bun ${bunVersion}` : `node ${process.versions.node}`;
+  const platform = `${process.platform}-${process.arch}`;
+  const pkgRealDir = safe(() => fs.realpathSync(root), root);
+  const behindSymlink = pkgRealDir !== root;
+  let packageManager = "unknown";
+  if (pkgRealDir.includes(`${path.sep}.pnpm${path.sep}`) || behindSymlink) {
+    packageManager = "pnpm-symlinked";
+  } else if (safe(() => fs.existsSync(path.join(root, "node_modules", "typescript")), false)) {
+    packageManager = "nested";
+  } else {
+    packageManager = "npm-hoisted";
+  }
+  const deps = CRITICAL_DEPS.map((name) => {
+    try {
+      return { name, resolved: true, resolvedPath: require.resolve(name) };
+    } catch (err) {
+      return {
+        name,
+        resolved: false,
+        error: `${err?.code ?? ""} ${err?.message ?? String(err)}`.trim()
+      };
+    }
+  });
+  const astGrepCli = safe(() => {
+    const cliPkg = require.resolve("@ast-grep/cli/package.json");
+    const dir = path.dirname(cliPkg);
+    return ["ast-grep", "ast-grep.exe", "sg", "sg.exe"].some((b) => fs.existsSync(path.join(dir, b)));
+  }, false);
+  const grammars = safe(() => {
+    let dir = path.dirname(require.resolve("web-tree-sitter"));
+    while (path.basename(dir) !== "web-tree-sitter" && dir !== path.dirname(dir)) {
+      dir = path.dirname(dir);
+    }
+    return fs.existsSync(path.join(dir, "grammars", "tree-sitter-typescript.wasm"));
+  }, false);
+  if (deps.some((d) => !d.resolved)) {
+    notes.push("One or more runtime dependencies did not resolve. This is the #285/#335 failure mode — usually a package-manager layout (pnpm symlink store / nested install) the runtime's resolver can't traverse, or an outdated runtime.");
+  }
+  if (!astGrepCli || !grammars) {
+    notes.push("ast-grep CLI and/or tree-sitter grammars are missing — pnpm/bun skip lifecycle scripts by default, so the postinstall that fetches them did not run.");
+  }
+  return {
+    piLensVersion,
+    runtime,
+    platform,
+    packageManager,
+    pkgDir: root,
+    pkgRealDir,
+    behindSymlink,
+    deps,
+    astGrepCli,
+    grammars,
+    notes
+  };
+}
+export function formatInstallDiagnostics(diag = collectInstallDiagnostics(), cause) {
+  const lines = [];
+  lines.push("──────── dm-lens install diagnostics ────────");
+  if (cause) {
+    const msg = cause?.message ?? String(cause);
+    lines.push(`LOAD ERROR: ${msg}`);
+  }
+  lines.push(`dm-lens:   ${diag.piLensVersion}`);
+  lines.push(`runtime:   ${diag.runtime}`);
+  lines.push(`platform:  ${diag.platform}`);
+  lines.push(`install:   ${diag.packageManager}${diag.behindSymlink ? " (behind symlink)" : ""}`);
+  lines.push(`pkg dir:   ${diag.pkgDir}`);
+  if (diag.behindSymlink)
+    lines.push(`real dir:  ${diag.pkgRealDir}`);
+  lines.push("deps:");
+  for (const d of diag.deps) {
+    lines.push(`  ${d.resolved ? "ok  " : "FAIL"} ${d.name}${d.error ? ` — ${d.error}` : ""}`);
+  }
+  lines.push(`assets:    ast-grep-cli=${diag.astGrepCli ? "ok" : "MISSING"} grammars=${diag.grammars ? "ok" : "MISSING"}`);
+  for (const n of diag.notes)
+    lines.push(`note: ${n}`);
+  lines.push(`Please paste this into a report at ${ISSUES_URL}`);
+  lines.push("─────────────────────────────────────────────");
+  return lines.join(`
+`);
+}