context-mode 1.0.124 → 1.0.126

package/build/cli.js

@@ -368,22 +368,47 @@ async function doctor() {
                 (result.fix ? color.dim(`\n  Run: ${result.fix}`) : ""));
         }
     }
-    // Hook scripts exist
+    // Hook scripts exist — Algo-D1 protocol path takes precedence.
+    // Adapters that override `getHealthChecks` (claude-code today) get a
+    // direct `existsSync(join(pluginRoot, "hooks", scriptName))` per
+    // HOOK_SCRIPTS entry — no regex round-trip on a hook command, so the
+    // #548 doubled-path FAIL class can't surface. Adapters that don't
+    // override fall through to the legacy `getHookScriptPaths` flow which
+    // generates the hook config and parses each command via
+    // `extractHookScriptPath`. Post-D3 every adapter emits buildNodeCommand-
+    // shape, so the legacy flow is also safe — but the direct existsSync
+    // path is strictly preferable when the adapter offers it.
     p.log.step("Checking hook scripts...");
-    const hookScriptPaths = getHookScriptPaths(adapter, pluginRoot);
-    if (hookScriptPaths.length === 0) {
-        p.log.success(color.green("Hook scripts: PASS") + color.dim(" — no direct .mjs script paths to verify"));
+    const adapterHealthChecks = adapter.getHealthChecks?.(pluginRoot) ?? [];
+    if (adapterHealthChecks.length > 0) {
+        for (const hc of adapterHealthChecks) {
+            const result = hc.check();
+            if (result.status === "OK") {
+                p.log.success(color.green(`${hc.name}: PASS`) +
+                    (result.detail ? color.dim(` — ${result.detail}`) : ""));
+            }
+            else {
+                p.log.error(color.red(`${hc.name}: FAIL`) +
+                    (result.detail ? color.dim(` — ${result.detail}`) : ""));
+            }
+        }
     }
     else {
-        for (const scriptPath of hookScriptPaths) {
-            const absolutePath = resolve(pluginRoot, scriptPath);
-            try {
-                accessSync(absolutePath, constants.R_OK);
-                p.log.success(color.green("Hook script exists: PASS") + color.dim(` — ${absolutePath}`));
-            }
-            catch {
-                p.log.error(color.red("Hook script exists: FAIL") +
-                    color.dim(` — not found at ${absolutePath}`));
+        const hookScriptPaths = getHookScriptPaths(adapter, pluginRoot);
+        if (hookScriptPaths.length === 0) {
+            p.log.success(color.green("Hook scripts: PASS") + color.dim(" — no direct .mjs script paths to verify"));
+        }
+        else {
+            for (const scriptPath of hookScriptPaths) {
+                const absolutePath = resolve(pluginRoot, scriptPath);
+                try {
+                    accessSync(absolutePath, constants.R_OK);
+                    p.log.success(color.green("Hook script exists: PASS") + color.dim(` — ${absolutePath}`));
+                }
+                catch {
+                    p.log.error(color.red("Hook script exists: FAIL") +
+                        color.dim(` — not found at ${absolutePath}`));
+                }
             }
         }
     }

package/build/db-base.d.ts

@@ -61,11 +61,28 @@ export declare class NodeSQLiteAdapter {
  * bundled SQLite always ships with FTS5.
  */
 export declare function nodeSqliteHasFts5(DatabaseSync: any): boolean;
+/**
+ * Returns true when the current runtime ships a built-in SQLite binding:
+ * - Bun has `bun:sqlite` always
+ * - Node has `node:sqlite` since 22.5 (no flag since 22.13)
+ *
+ * Mirrors the helper in hooks/ensure-deps.mjs:61. Exported so the platform
+ * gate in loadDatabase() can be unit-tested without spawning a child
+ * process. `versionsOverride` and `bunOverride` are injection points for
+ * tests — production callers pass nothing.
+ *
+ * Widening the gate from `process.platform === "linux"` to this helper is
+ * required for Node 26 on macOS arm64 (#551): Node 26 removed
+ * `info.This()` from V8 PropertyCallbackInfo, breaking better-sqlite3
+ * 12.9.0's native compile. Using node:sqlite sidesteps the native addon
+ * entirely on every platform that has it.
+ */
+export declare function hasModernSqlite(versionsOverride?: NodeJS.ProcessVersions, bunOverride?: unknown): boolean;
 /**
  * Lazy-load the SQLite driver for the current runtime.
  * Bun → bun:sqlite via BunSQLiteAdapter (issue #45).
- * Linux Node → node:sqlite via NodeSQLiteAdapter when it ships FTS5 (#228, #461).
- * Other Node (or Linux Node without FTS5) → better-sqlite3 (native addon).
+ * Modern Node (>= 22.5) → node:sqlite via NodeSQLiteAdapter when it ships FTS5 (#228, #461, #551).
+ * Other Node (or modern Node without FTS5) → better-sqlite3 (native addon).
  */
 export declare function loadDatabase(): typeof DatabaseConstructor;
 /**

package/build/db-base.js

@@ -184,11 +184,39 @@ export function nodeSqliteHasFts5(DatabaseSync) {
         catch { /* probe never opened or already closed */ }
     }
 }
+/**
+ * Returns true when the current runtime ships a built-in SQLite binding:
+ * - Bun has `bun:sqlite` always
+ * - Node has `node:sqlite` since 22.5 (no flag since 22.13)
+ *
+ * Mirrors the helper in hooks/ensure-deps.mjs:61. Exported so the platform
+ * gate in loadDatabase() can be unit-tested without spawning a child
+ * process. `versionsOverride` and `bunOverride` are injection points for
+ * tests — production callers pass nothing.
+ *
+ * Widening the gate from `process.platform === "linux"` to this helper is
+ * required for Node 26 on macOS arm64 (#551): Node 26 removed
+ * `info.This()` from V8 PropertyCallbackInfo, breaking better-sqlite3
+ * 12.9.0's native compile. Using node:sqlite sidesteps the native addon
+ * entirely on every platform that has it.
+ */
+export function hasModernSqlite(versionsOverride, bunOverride) {
+    const bun = bunOverride !== undefined ? bunOverride : globalThis.Bun;
+    if (typeof bun !== "undefined" && bun !== null)
+        return true;
+    const versions = versionsOverride ?? process.versions;
+    const [majorStr, minorStr] = (versions.node ?? "0.0.0").split(".");
+    const major = Number(majorStr);
+    const minor = Number(minorStr);
+    if (!Number.isFinite(major) || !Number.isFinite(minor))
+        return false;
+    return major > 22 || (major === 22 && minor >= 5);
+}
 /**
  * Lazy-load the SQLite driver for the current runtime.
  * Bun → bun:sqlite via BunSQLiteAdapter (issue #45).
- * Linux Node → node:sqlite via NodeSQLiteAdapter when it ships FTS5 (#228, #461).
- * Other Node (or Linux Node without FTS5) → better-sqlite3 (native addon).
+ * Modern Node (>= 22.5) → node:sqlite via NodeSQLiteAdapter when it ships FTS5 (#228, #461, #551).
+ * Other Node (or modern Node without FTS5) → better-sqlite3 (native addon).
  */
 export function loadDatabase() {
     if (!_Database) {
@@ -211,13 +239,19 @@ export function loadDatabase() {
                 return adapter;
             };
         }
-        else if (process.platform === "linux") {
-            // Linux — try node:sqlite to avoid native addon SIGSEGV (nodejs/node#62515).
-            // node:sqlite is built into Node >= 22.5, no flag needed since 22.13.
-            // Probe FTS5 support before committing — some Linux Node builds ship
-            // node:sqlite without FTS5, which would silently break ctx_search (#461).
-            // The probe runs at most once per process (cached via _Database below),
-            // so the cost of opening an in-memory DatabaseSync is negligible.
+        else if (hasModernSqlite()) {
+            // Any Node >= 22.5 — try node:sqlite to avoid the native addon path
+            // entirely. Historically this was Linux-only (avoiding the Linux
+            // SIGSEGV per nodejs/node#62515, #228), but Node 26 also broke
+            // better-sqlite3's native compile on macOS arm64 by removing
+            // V8 `info.This()` (#551). The built-in `node:sqlite` ships its
+            // own SQLite, so it sidesteps both issues at once.
+            //
+            // Probe FTS5 support before committing — some Node builds ship
+            // node:sqlite without FTS5, which would silently break ctx_search
+            // (#461). The probe runs at most once per process (cached via
+            // _Database below), so the cost of an in-memory DatabaseSync is
+            // negligible.
             let DatabaseSync = null;
             try {
                 // Array.join() prevents esbuild from resolving the specifier at bundle time
@@ -236,16 +270,16 @@ export function loadDatabase() {
                 };
             }
             else {
-                // node:sqlite missing or built without FTS5 — fall through to better-sqlite3.
-                // Trade-off: this reintroduces the native-addon path that #228 routed
-                // around (Linux SIGSEGV per nodejs/node#62515). Deliberate — a visible
-                // crash on the rare unstable build is preferable to a silent
-                // "no such module: fts5" on every ctx_search call.
+                // node:sqlite missing or built without FTS5 — fall through to
+                // better-sqlite3. Trade-off: on Node 26 + macOS this may now hit
+                // the V8 ABI break (#551). A visible crash on the rare
+                // unstable build is preferable to silent "no such module: fts5"
+                // on every ctx_search call.
                 _Database = require("better-sqlite3");
             }
         }
         else {
-            // Non-Linux Node.js — use better-sqlite3.
+            // Old Node (< 22.5) without bun:sqlite — fall back to better-sqlite3.
             _Database = require("better-sqlite3");
         }
     }

package/build/executor.js

@@ -23,6 +23,7 @@ const SCRIPT_EXT = {
     perl: "pl",
     r: "R",
     elixir: "exs",
+    csharp: "csx",
 };
 /** Pure helper — exported for unit testing. Returns "script" or "script.<ext>". */
 export function buildScriptFilename(language, platform, shellPath) {
@@ -223,7 +224,7 @@ export class PolyglotExecutor {
             // .exe paths now (#506), but if it falls back to the bare "bun" string
             // on Windows that resolution typically goes through a `bun.cmd` shim
             // (npm i -g bun) which CreateProcess can't execute without cmd.exe.
-            const needsShell = isWin && ["tsx", "ts-node", "elixir", "bun"].includes(cmd[0]);
+            const needsShell = isWin && ["tsx", "ts-node", "elixir", "bun", "dotnet-script"].includes(cmd[0]);
             // On Windows with Git Bash, pass the script as `bash -c "source /posix/path"`
             // rather than `bash /path/to/script.sh`. This avoids MSYS2 path mangling
             // while still allowing MSYS_NO_PATHCONV to protect non-ASCII paths in commands.
@@ -412,6 +413,30 @@ export class PolyglotExecutor {
             "R_PROFILE", // site-wide R profile
             "R_PROFILE_USER", // user R profile
             "R_HOME", // R installation override
+            // .NET / C# — runtime/startup hooks, additional deps
+            "DOTNET_STARTUP_HOOKS", // injects managed assemblies on startup
+            "DOTNET_ADDITIONAL_DEPS", // additional .deps.json injection
+            "DOTNET_SHARED_STORE", // shared assembly probe path injection
+            "DOTNET_ROOT", // arbitrary .NET runtime override
+            "DOTNET_ROOT(x86)", // 32-bit override
+            "DOTNET_HOST_PATH", // host binary substitution
+            // .NET / C# — profiler attach (loads arbitrary DLL into dotnet host)
+            // and IPC-based debugger/IL injection. PR #546 follow-up.
+            // learn.microsoft.com/en-us/dotnet/core/runtime-config/debugging-profiling
+            "CORECLR_PROFILER", // CLSID of profiler to attach
+            "CORECLR_PROFILER_PATH", // path to profiler DLL
+            "CORECLR_PROFILER_PATH_32", // 32-bit specific profiler DLL
+            "CORECLR_PROFILER_PATH_64", // 64-bit specific profiler DLL
+            "CORECLR_PROFILER_PATH_ARM32", // ARM32 specific profiler DLL
+            "CORECLR_PROFILER_PATH_ARM64", // ARM64 specific profiler DLL
+            "CORECLR_ENABLE_PROFILING", // gates profiler load
+            "DOTNET_PROFILER_PATH", // cross-platform alias
+            "DOTNET_PROFILER_PATH_32",
+            "DOTNET_PROFILER_PATH_64",
+            "DOTNET_PROFILER_PATH_ARM32",
+            "DOTNET_PROFILER_PATH_ARM64",
+            "DOTNET_DiagnosticPorts", // peer attach via diagnostic IPC
+            "DOTNET_BUNDLE_EXTRACT_BASE_DIR", // single-file extraction hijack
             // Dynamic linker — shared library injection
             "LD_PRELOAD", // loads .so before all others (Linux)
             "DYLD_INSERT_LIBRARIES", // macOS equivalent of LD_PRELOAD
@@ -431,10 +456,17 @@ export class PolyglotExecutor {
             "GIT_SSH_COMMAND", // arbitrary ssh command
             "GIT_ASKPASS", // arbitrary credential command
         ]);
-        // Start with parent env, then strip dangerous vars and apply overrides
+        // Start with parent env, then strip dangerous vars and apply overrides.
+        // The `COMPlus_` prefix sweep covers every COMPlus_* synonym of the
+        // DOTNET_* runtime knobs (.NET back-compat alias — case-insensitive).
+        // PR #546 follow-up: closes the alias bypass for the explicit denylist
+        // entries above.
         const env = {};
         for (const [key, val] of Object.entries(process.env)) {
-            if (val !== undefined && !DENIED.has(key) && !key.startsWith("BASH_FUNC_")) {
+            if (val !== undefined &&
+                !DENIED.has(key) &&
+                !key.startsWith("BASH_FUNC_") &&
+                !/^COMPlus_/i.test(key)) {
                 env[key] = val;
             }
         }
@@ -508,6 +540,11 @@ export class PolyglotExecutor {
                 return `FILE_CONTENT_PATH <- ${escaped}\nfile_path <- FILE_CONTENT_PATH\nFILE_CONTENT <- readLines(FILE_CONTENT_PATH, warn=FALSE, encoding="UTF-8")\nFILE_CONTENT <- paste(FILE_CONTENT, collapse="\\n")\n${code}`;
             case "elixir":
                 return `file_content_path = ${escaped}\nfile_path = file_content_path\nfile_content = File.read!(file_content_path)\n${code}`;
+            case "csharp":
+                // .csx forbids `using` directives after any other top-level statement
+                // (CS1529). User code inside executeFile must use fully-qualified type
+                // names (e.g. `System.Text.Json.JsonDocument`) instead of `using`.
+                return `var FILE_CONTENT_PATH = ${escaped};\nvar file_path = FILE_CONTENT_PATH;\nvar FILE_CONTENT = System.IO.File.ReadAllText(FILE_CONTENT_PATH);\n${code}`;
         }
     }
 }

package/build/runtime.d.ts

@@ -1,5 +1,5 @@
 export declare function isAllowlistedShell(shellPath: string): boolean;
-export type Language = "javascript" | "typescript" | "python" | "shell" | "ruby" | "go" | "rust" | "php" | "perl" | "r" | "elixir";
+export type Language = "javascript" | "typescript" | "python" | "shell" | "ruby" | "go" | "rust" | "php" | "perl" | "r" | "elixir" | "csharp";
 export interface RuntimeInfo {
     command: string;
     available: boolean;
@@ -18,6 +18,7 @@ export interface RuntimeMap {
     perl: string | null;
     r: string | null;
     elixir: string | null;
+    csharp: string | null;
 }
 export declare function detectRuntimes(): RuntimeMap;
 export declare function hasBunRuntime(): boolean;

package/build/runtime.js

@@ -232,6 +232,7 @@ export function detectRuntimes() {
                 ? "r"
                 : null,
         elixir: commandExists("elixir") ? "elixir" : null,
+        csharp: commandExists("dotnet-script") ? "dotnet-script" : null,
     };
 }
 export function hasBunRuntime() {
@@ -269,6 +270,8 @@ export function getRuntimeSummary(runtimes) {
         lines.push(`  R:          ${runtimes.r} (${getVersion(runtimes.r)})`);
     if (runtimes.elixir)
         lines.push(`  Elixir:     ${runtimes.elixir} (${getVersion(runtimes.elixir)})`);
+    if (runtimes.csharp)
+        lines.push(`  C#:         ${runtimes.csharp} (${getVersion(runtimes.csharp)})`);
     if (!bunPreferred) {
         lines.push("");
         lines.push("  Tip: Install Bun for 3-5x faster JS/TS execution → https://bun.sh");
@@ -295,6 +298,8 @@ export function getAvailableLanguages(runtimes) {
         langs.push("r");
     if (runtimes.elixir)
         langs.push("elixir");
+    if (runtimes.csharp)
+        langs.push("csharp");
     return langs;
 }
 export function buildCommand(runtimes, language, filePath) {
@@ -376,5 +381,10 @@ export function buildCommand(runtimes, language, filePath) {
                 throw new Error("Elixir not available. Install elixir.");
             }
             return ["elixir", filePath];
+        case "csharp":
+            if (!runtimes.csharp) {
+                throw new Error("C# not available. Install dotnet-script via `dotnet tool install -g dotnet-script`.");
+            }
+            return [runtimes.csharp, filePath];
     }
 }

package/build/server.js

@@ -929,11 +929,12 @@ server.registerTool("ctx_execute", {
             "perl",
             "r",
             "elixir",
+            "csharp",
         ])
             .describe("Runtime language"),
         code: z
             .string()
-            .describe("Source code to execute. Use console.log (JS/TS), print (Python/Ruby/Perl/R), echo (Shell), echo (PHP), fmt.Println (Go), or IO.puts (Elixir) to output a summary to context."),
+            .describe("Source code to execute. Use console.log (JS/TS), print (Python/Ruby/Perl/R), echo (Shell), echo (PHP), fmt.Println (Go), IO.puts (Elixir), or Console.WriteLine (C#) to output a summary to context."),
         timeout: z
             .coerce.number()
             .optional()
@@ -1224,11 +1225,12 @@ server.registerTool("ctx_execute_file", {
             "perl",
             "r",
             "elixir",
+            "csharp",
         ])
             .describe("Runtime language"),
         code: z
             .string()
-            .describe("Code to process FILE_CONTENT (file_content in Elixir). Print summary via console.log/print/echo/IO.puts."),
+            .describe("Code to process FILE_CONTENT (file_content in Elixir). Print summary via console.log/print/echo/IO.puts/Console.WriteLine."),
         timeout: z
             .coerce.number()
             .optional()

package/build/util/hook-config.d.ts

@@ -1,4 +1,27 @@
-import type { HookAdapter } from "../adapters/types.js";
+import { type HookAdapter } from "../adapters/types.js";
 export declare function getCommandsFromHookEntry(entry: unknown): string[];
+/**
+ * Extract the hook script path from a hook command string.
+ *
+ * Post Algo-D2 this is a thin wrapper around `parseNodeCommand` with a
+ * single legacy fallback retained for stale-entry cleanup
+ * (`configureAllHooks` walks pre-v1.0.124 settings.json shapes that
+ * predate `buildNodeCommand`). The legacy branches are deliberately
+ * narrow:
+ *
+ *   1) Canonical: `"<nodePath>" "<scriptPath>.mjs"` — `parseNodeCommand`
+ *      handles this; round-trips with `buildNodeCommand`.
+ *   2) Legacy quoted: `node "<scriptPath>.mjs"` — emitted by claude-code
+ *      pre-D3. The script segment is fully quoted, no whitespace
+ *      ambiguity.
+ *   3) Legacy unquoted: `node <scriptPath>.mjs` — only when the entire
+ *      command is whitespace-safe (exactly two whitespace-separated
+ *      tokens). The #548 wire shape — `node C:/Users/High Ground …` —
+ *      contains internal whitespace so this branch refuses it. Returns
+ *      `null` instead of grabbing the tail after the last whitespace.
+ *
+ * Anything else returns `null`, letting the doctor (Algo-D1) fall
+ * through to direct `existsSync` instead of trusting the regex.
+ */
 export declare function extractHookScriptPath(command: string): string | null;
 export declare function getHookScriptPaths(adapter: HookAdapter, pluginRoot: string): string[];

package/build/util/hook-config.js

@@ -1,3 +1,4 @@
+import { parseNodeCommand } from "../adapters/types.js";
 export function getCommandsFromHookEntry(entry) {
     const commands = [];
     if (entry && typeof entry === "object") {
@@ -17,9 +18,45 @@ export function getCommandsFromHookEntry(entry) {
     }
     return commands;
 }
+/**
+ * Extract the hook script path from a hook command string.
+ *
+ * Post Algo-D2 this is a thin wrapper around `parseNodeCommand` with a
+ * single legacy fallback retained for stale-entry cleanup
+ * (`configureAllHooks` walks pre-v1.0.124 settings.json shapes that
+ * predate `buildNodeCommand`). The legacy branches are deliberately
+ * narrow:
+ *
+ *   1) Canonical: `"<nodePath>" "<scriptPath>.mjs"` — `parseNodeCommand`
+ *      handles this; round-trips with `buildNodeCommand`.
+ *   2) Legacy quoted: `node "<scriptPath>.mjs"` — emitted by claude-code
+ *      pre-D3. The script segment is fully quoted, no whitespace
+ *      ambiguity.
+ *   3) Legacy unquoted: `node <scriptPath>.mjs` — only when the entire
+ *      command is whitespace-safe (exactly two whitespace-separated
+ *      tokens). The #548 wire shape — `node C:/Users/High Ground …` —
+ *      contains internal whitespace so this branch refuses it. Returns
+ *      `null` instead of grabbing the tail after the last whitespace.
+ *
+ * Anything else returns `null`, letting the doctor (Algo-D1) fall
+ * through to direct `existsSync` instead of trusting the regex.
+ */
 export function extractHookScriptPath(command) {
-    const match = command.match(/(?:"([^"]+\.mjs)"|'([^']+\.mjs)'|(\S+\.mjs))/);
-    return match?.[1] ?? match?.[2] ?? match?.[3] ?? null;
+    const parsed = parseNodeCommand(command);
+    if (parsed) {
+        return parsed.scriptPath.endsWith(".mjs") ? parsed.scriptPath : null;
+    }
+    // Legacy quoted: `node "/path/with spaces/x.mjs"` (pre-D3 claude-code emit).
+    const legacyQuoted = command.match(/^\s*node\s+"([^"]+\.mjs)"\s*$/);
+    if (legacyQuoted)
+        return legacyQuoted[1];
+    // Legacy unquoted: `node /path/x.mjs` — refuses internal whitespace
+    // by anchoring both tokens. The #548 ambiguous shape has 3+ tokens
+    // (spaces in the path) and falls through to `null`.
+    const legacyBare = command.match(/^\s*node\s+(\S+\.mjs)\s*$/);
+    if (legacyBare)
+        return legacyBare[1];
+    return null;
 }
 export function getHookScriptPaths(adapter, pluginRoot) {
     const paths = new Set();

package/build/util/plugin-cache-integrity.d.ts

@@ -0,0 +1,37 @@
+/**
+ * TypeScript surface for the start.mjs plugin-cache integrity helper.
+ *
+ * The actual logic lives in `scripts/plugin-cache-integrity.mjs` (raw
+ * `.mjs` so start.mjs can import it without a TS toolchain at boot —
+ * #550 fail-fast happens BEFORE any bundle is loaded). This module is
+ * the bridge that lets TS consumers (claude-code adapter's
+ * getHealthChecks for Algo-D5, the cli doctor surface) call the same
+ * function without duplicating the implementation.
+ *
+ * Single source of truth: scripts/plugin-cache-integrity.mjs. Boot
+ * fail-fast (Algo-D4) and doctor diagnostic (Algo-D5) agree
+ * byte-for-byte because they call the same exported function.
+ *
+ * Top-level dynamic import is used (not a static `import` from `.mjs`)
+ * because the project is ESM and `import` of a sibling `.mjs` from a
+ * `.ts` file relies on the bundler / loader resolving `.mjs`
+ * extensions, which esbuild can do but tsc-only typecheck cannot. The
+ * dynamic import is resolved by the runtime (Node ESM) regardless of
+ * how the consumer was bundled. Errors are caught and surfaced as a
+ * FAIL detail — the helper is required to ship in the npm tarball
+ * (package.json files[]); a missing helper means the install is
+ * fundamentally broken.
+ */
+/**
+ * Run the integrity check synchronously. If the helper module is
+ * still loading (not yet cached) returns a FAIL with detail
+ * "integrity helper not yet loaded" — caller should retry once the
+ * doctor command's IO is complete. In practice the doctor is invoked
+ * many MS after module load so this fallback is defensive only.
+ */
+export declare function checkPluginCacheIntegritySync(pluginRoot: string): {
+    status: "OK" | "FAIL";
+    detail: string;
+};
+/** Force-await the helper load. Tests use this to deflake the eager fire-and-forget. */
+export declare function ensurePluginCacheIntegrityLoaded(): Promise<void>;

package/build/util/plugin-cache-integrity.js

@@ -0,0 +1,105 @@
+/**
+ * TypeScript surface for the start.mjs plugin-cache integrity helper.
+ *
+ * The actual logic lives in `scripts/plugin-cache-integrity.mjs` (raw
+ * `.mjs` so start.mjs can import it without a TS toolchain at boot —
+ * #550 fail-fast happens BEFORE any bundle is loaded). This module is
+ * the bridge that lets TS consumers (claude-code adapter's
+ * getHealthChecks for Algo-D5, the cli doctor surface) call the same
+ * function without duplicating the implementation.
+ *
+ * Single source of truth: scripts/plugin-cache-integrity.mjs. Boot
+ * fail-fast (Algo-D4) and doctor diagnostic (Algo-D5) agree
+ * byte-for-byte because they call the same exported function.
+ *
+ * Top-level dynamic import is used (not a static `import` from `.mjs`)
+ * because the project is ESM and `import` of a sibling `.mjs` from a
+ * `.ts` file relies on the bundler / loader resolving `.mjs`
+ * extensions, which esbuild can do but tsc-only typecheck cannot. The
+ * dynamic import is resolved by the runtime (Node ESM) regardless of
+ * how the consumer was bundled. Errors are caught and surfaced as a
+ * FAIL detail — the helper is required to ship in the npm tarball
+ * (package.json files[]); a missing helper means the install is
+ * fundamentally broken.
+ */
+let cached = null;
+let cachedError = null;
+async function loadHelper() {
+    if (cached)
+        return cached;
+    if (cachedError)
+        return null;
+    try {
+        // Resolve relative to this compiled file. After tsc emits to
+        // build/util/plugin-cache-integrity.js, the helper sits at
+        // ../../scripts/plugin-cache-integrity.mjs. After esbuild bundles
+        // src/cli.ts to cli.bundle.mjs at the repo root, the same relative
+        // path resolves to ./scripts/plugin-cache-integrity.mjs. Both
+        // shapes are walked here.
+        const candidates = [
+            new URL("../../scripts/plugin-cache-integrity.mjs", import.meta.url),
+            new URL("./scripts/plugin-cache-integrity.mjs", import.meta.url),
+        ];
+        let lastErr = null;
+        for (const url of candidates) {
+            try {
+                const mod = (await import(url.href));
+                if (typeof mod?.assertPluginCacheIntegrity === "function") {
+                    cached = mod;
+                    return cached;
+                }
+            }
+            catch (err) {
+                lastErr = err;
+            }
+        }
+        cachedError =
+            lastErr instanceof Error ? lastErr.message : String(lastErr ?? "not found");
+        return null;
+    }
+    catch (err) {
+        cachedError = err instanceof Error ? err.message : String(err);
+        return null;
+    }
+}
+// Eagerly start the load on module init so the first synchronous
+// check() call can hit the cache. The promise is unawaited
+// intentionally — by the time any HealthCheck.check() runs (doctor
+// command, well after MCP server boot), the import has resolved.
+void loadHelper();
+/**
+ * Run the integrity check synchronously. If the helper module is
+ * still loading (not yet cached) returns a FAIL with detail
+ * "integrity helper not yet loaded" — caller should retry once the
+ * doctor command's IO is complete. In practice the doctor is invoked
+ * many MS after module load so this fallback is defensive only.
+ */
+export function checkPluginCacheIntegritySync(pluginRoot) {
+    if (cached) {
+        const result = cached.assertPluginCacheIntegrity({ pluginRoot });
+        if (result.ok) {
+            return {
+                status: "OK",
+                detail: `${pluginRoot} (all required runtime siblings present)`,
+            };
+        }
+        return {
+            status: "FAIL",
+            detail: `missing: ${result.missing.join(", ")}`,
+        };
+    }
+    if (cachedError) {
+        return {
+            status: "FAIL",
+            detail: `integrity helper unavailable: ${cachedError}`,
+        };
+    }
+    return {
+        status: "FAIL",
+        detail: "integrity helper not yet loaded",
+    };
+}
+/** Force-await the helper load. Tests use this to deflake the eager fire-and-forget. */
+export async function ensurePluginCacheIntegrityLoaded() {
+    await loadHelper();
+}