@sigrun/ext-codemode 0.1.3 → 0.2.1

package/CHANGELOG.md

@@ -5,12 +5,22 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.4] - 2026-11-08
+
+- CI: grant actions: read to the release workflow (the release-test skip lookup). No code change.
+
 ## [0.1.3] - 2026-11-07
 
-## [Unreleased]
+## [0.2.1] - 2026-11-09
+
+- CI: needs-core true (the settings rework added the `@sigrun/sigrun` file: dev dependency; the v0.2.0 tag's test job failed before publishing, so the version was never live).
+
+## [0.2.0] - 2026-11-09
 
 ### Changed
 
+- MCP namespaces now come from the `mcp.servers` published hook and refresh
+  after settings writes; legacy `mcp.json` reading is removed.
 - peer pi-durable/pi-ai/chord ~1.5.0 (requires sigrun 0.11.0).
 
 ## [0.1.1] - 2026-10-27

package/README.md

@@ -7,33 +7,28 @@ a restart — installed via upstream's
 sigrun's config and prompt additions.
 
 The sigrun extension-package contract: the default export is a factory
-taking no arguments, returning `{ extension }`.
+taking the sigrun host, returning `{ extension }` and lifecycle handlers.
 
 ## What the factory does
 
-1. Reads the MCP namespace snapshot ONCE from the same config
-   sigrun-ext-mcp reads: `SIGRUN_MCP_CONFIG` env override →
-   `~/.config/sigrun/mcp.json`. One `CodemodeNamespace` per enabled
-   server, `prefix: "<server>/"`. Absent file → empty namespaces (the
-   codemode tool + section still ship). A bad file warns at factory time
-   (best-effort) and installs un-namespaced rather than throwing — a bad
-   config must not cost the model its codemode tool.
+1. Creates one live MCP namespace array from sigrun-ext-mcp's
+   `mcp.servers` published hook. One `CodemodeNamespace` per enabled,
+   visible server, `prefix: "<server>/"`. The first call starts without
+   blocking the factory; committed settings writes and run settlement
+   refresh the same array in place. A failed hook call warns once per
+   failure status and preserves the last known namespaces.
 2. Builds the QuickJS sandbox (`CodemodeSandbox` from
    `@earendil-works/pi-codemode`) with pinned constructor options:
    `timeoutMs: 300_000`, `memoryLimitBytes: 256 MiB`.
 3. Wraps upstream's `createCodemodeExtension({ sandbox, namespaces })`
    with a companion `codemode_notice` section (below).
 
-Config fields read per server entry (the sigrun-ext-mcp shapes,
-duplicated here because that package is not npm-published): `enabled` /
-`disabled` (either false means off), `exposure`
-(`"codemode"` default | `"deferred"` | `"direct"` | `"hidden"`, plus the
-pi alias `"codemode-deferred"`), and `toolExposure` overrides. A server
-resolving fully `hidden` (server default `hidden` and every override
-`hidden`) is excluded from the snapshot — hidden tools never register,
+The hook supplies each server's resolved `enabled`, `exposure`, and
+`toolExposure` values. A fully `hidden` server (server default `hidden`
+and every override `hidden`) is excluded: hidden tools never register,
 so nothing scripts can call remains. Per-tool `hidden` resolution is
-sigrun-ext-mcp's job at registration time; this snapshot only groups by
-prefix, and hidden tools never reach `agent.callable` to be grouped.
+sigrun-ext-mcp's job at registration time; these namespaces only group
+by prefix, and hidden tools never reach `agent.callable` to be grouped.
 
 ### The deadline (verified against pi-codemode 1.2.0)
 
@@ -83,7 +78,7 @@ sigrun-ext-mcp's README; the two must stay consistent.
 
 Replace this package by not installing it and installing yours: the
 surface is one tool named exactly `codemode` (plus the companion
-`codemode_notice` section and the factory-time namespace snapshot), so a
+`codemode_notice` section and live MCP namespaces), so a
 per-name replacement is trivial — uninstall ours, install the replacement
 under the same tool name. Do NOT co-install: pi-durable resolves
 cross-extension duplicate tool names last-selected-wins, so a co-installed

package/dist/extension.d.ts

@@ -4,11 +4,10 @@
  * `callers: ["model"]`, plus the upstream `codemode` prompt section) with
  * our two sigrun additions:
  *
- * 1. The MCP namespace snapshot (src/config.ts): one `CodemodeNamespace`
- *    per configured MCP server, prefix `"<server>/"`, read once at factory
- *    time. The upstream section groups `agent.callable` tools by the
- *    longest matching prefix, so sigrun's `<server>/<tool>` MCP tools
- *    render grouped per server with no renames (the namespace ruler).
+ * 1. The live MCP namespaces: one `CodemodeNamespace` per configured MCP
+ *    server, prefix `"<server>/"`. The upstream section groups
+ *    `agent.callable` tools by the longest matching prefix, so sigrun's
+ *    `<server>/<tool>` MCP tools render grouped per server with no renames.
  *
  * 2. The warn-if-not-offered channel (the spec's corrected mechanism):
  *    when the extension is installed but the `codemode` TOOL is not
@@ -52,11 +51,11 @@ export declare const CODEMODE_NOT_OFFERED_NOTICE: string;
 export declare function renderCodemodeNotice(input: PromptInput): string | undefined;
 /**
  * The sigrun codemode extension: upstream's `codemode` extension (tool +
- * section, with our namespace snapshot) plus the companion notice section.
+ * section, with our live namespace array) plus the companion notice section.
  */
 export declare function createSigrunCodemodeExtension(options: {
     /** Runs the scripts: `CodemodeSandbox` on Node. */
     readonly sandbox: CodemodeSandboxBase;
-    /** The factory-time MCP namespace snapshot (src/config.ts). */
+    /** The live MCP namespace array; upstream reads it at use time. */
     readonly namespaces?: readonly CodemodeNamespace[];
 }): Extension;

package/dist/extension.js

@@ -4,11 +4,10 @@
  * `callers: ["model"]`, plus the upstream `codemode` prompt section) with
  * our two sigrun additions:
  *
- * 1. The MCP namespace snapshot (src/config.ts): one `CodemodeNamespace`
- *    per configured MCP server, prefix `"<server>/"`, read once at factory
- *    time. The upstream section groups `agent.callable` tools by the
- *    longest matching prefix, so sigrun's `<server>/<tool>` MCP tools
- *    render grouped per server with no renames (the namespace ruler).
+ * 1. The live MCP namespaces: one `CodemodeNamespace` per configured MCP
+ *    server, prefix `"<server>/"`. The upstream section groups
+ *    `agent.callable` tools by the longest matching prefix, so sigrun's
+ *    `<server>/<tool>` MCP tools render grouped per server with no renames.
  *
  * 2. The warn-if-not-offered channel (the spec's corrected mechanism):
  *    when the extension is installed but the `codemode` TOOL is not
@@ -58,7 +57,7 @@ export function renderCodemodeNotice(input) {
 }
 /**
  * The sigrun codemode extension: upstream's `codemode` extension (tool +
- * section, with our namespace snapshot) plus the companion notice section.
+ * section, with our live namespace array) plus the companion notice section.
  */
 export function createSigrunCodemodeExtension(options) {
     const upstream = createCodemodeExtension({

package/dist/index.d.ts

@@ -1,41 +1,19 @@
 /**
  * sigrun-ext-codemode: the codemode factory (the loader contract).
  *
- * The sigrun extension-package contract (sigrun's src/harness/loader.ts):
- * the default export is a FACTORY TAKING NO ARGUMENTS, returning
- * `{ extension }`. The loader calls it synchronously at boot, before
- * `Harness.open` reads the registry.
+ * MCP namespaces come from ext-mcp's `mcp.servers` published hook. Codemode
+ * loads before ext-mcp, so the factory starts (but never awaits) the first
+ * refresh; committed settings writes and the per-run lifecycle refresh it
+ * again. Upstream reads the namespaces array at use time, so the
+ * owned array is updated in place rather than replaced.
  *
- * What the factory does, in order:
- *   1. Reads the MCP namespace snapshot ONCE (src/config.ts):
- *      `SIGRUN_MCP_CONFIG` → `~/.config/sigrun/mcp.json`; absent file →
- *      empty namespaces (the extension still ships its codemode tool +
- *      section); a bad file warns and installs un-namespaced.
- *   2. Builds the QuickJS sandbox with the pinned constructor options
- *      (timeoutMs 300_000 — pi-codemode's own default, restated so the
- *      contract does not drift; memoryLimitBytes 256 MiB — a real cap
- *      where the upstream default is unbounded wasm32).
- *   3. Wraps upstream's `createCodemodeExtension({ sandbox, namespaces })`
- *      with the companion notice section (src/extension.ts).
- *
- * Note on `timeoutMs` (verified against pi-codemode 1.2.0): the
- * CONSTRUCTOR timeout governs `sandbox.execute()`; the durable codemode
- * tool path (`sandbox.start()`) takes its deadline from the script's own
- * `// @options: {"timeout_ms": N}` line (no options line → no deadline:
- * the sandbox default does not apply there). The constructor cap is
- * still the right pin: it bounds every execution of the plain sandbox
- * surface and documents the intended ceiling.
- *
- * `quickjs-wasi` is a REAL dependency of this package, not a transitive
- * courtesy: pi-codemode's worker resolves `quickjs-wasi/quickjs.wasm`
- * from disk at the first script. A re-pinned or deduped-away transitive
- * copy strands the wasm file and the first codemode call fails at runtime
- * (500s in prod) — declaring it here pins the resolution to this
- * package's own tree.
+ * `quickjs-wasi` is a direct dependency: pi-codemode's worker resolves its
+ * wasm from this package's tree at the first script.
  */
 import type { CodemodeSandboxBase } from "@earendil-works/pi-codemode/portable";
 import type { CodemodeNamespace } from "@earendil-works/pi-durable/codemode";
 import type { Extension } from "@earendil-works/pi-durable";
+import type { SigrunExtensionResult, SigrunHost } from "@sigrun/sigrun/extension";
 /** Pinned per-execution wall-clock deadline (pi-codemode's default). */
 export declare const CODEMODE_TIMEOUT_MS = 300000;
 /** Pinned QuickJS heap cap (256 MiB; upstream default is unbounded). */
@@ -46,27 +24,21 @@ export interface CodemodeWiring {
     readonly extension: Extension;
     /** The sandbox the extension runs scripts in (call `close()` on shutdown). */
     readonly sandbox: CodemodeSandboxBase;
-    /** The factory-time namespace snapshot (empty without an mcp.json). */
+    /** The live namespace list, refreshed after loading and between runs. */
     readonly namespaces: readonly CodemodeNamespace[];
-    /**
-     * Close the sandbox: aborts in-flight executions and stops the worker
-     * machinery. Called by hosts on harness shutdown; a fresh factory builds
-     * a fresh sandbox, so a closed wiring is never reused.
-     */
+    /** The initial hook call; the factory itself never waits on it. */
+    readonly ready: Promise<void>;
+    /** Refresh before a newly created conversation's first run. */
+    readonly conversationCreated: NonNullable<SigrunExtensionResult["conversationCreated"]>;
+    /** Refresh after every settled run. */
+    readonly runSettled: NonNullable<SigrunExtensionResult["runSettled"]>;
+    /** Refresh immediately after any committed settings write. */
+    readonly onSettingsChanged: NonNullable<SigrunExtensionResult["onSettingsChanged"]>;
+    /** Abort in-flight executions and stop the worker machinery. */
     close(): Promise<void>;
 }
-/**
- * The codemode factory (the loader contract: no arguments; config resolves
- * from the package context). Each call builds a FRESH sandbox — one
- * wiring, one sandbox, no shared worker state across installs.
- */
-export declare function createCodemodeWiring(): CodemodeWiring;
-/**
- * The sigrun extension-package contract: the default export is a factory
- * taking no arguments, returning `{ extension }`.
- */
+/** Each call builds a fresh sandbox and one live array shared with upstream. */
+export declare function createCodemodeWiring(host?: SigrunHost): CodemodeWiring;
 declare const _default: typeof createCodemodeWiring;
 export default _default;
 export { CODEMODE_NOT_OFFERED_NOTICE, CODEMODE_NOTICE_SECTION_KEY, renderCodemodeNotice, } from "./extension.js";
-export { loadNamespaces, MCP_CONFIG_ENV, resolveMcpConfigPath, serverEnabled, } from "./config.js";
-export type { McpServerEntry } from "./config.js";

package/dist/index.js

@@ -1,68 +1,77 @@
 /**
  * sigrun-ext-codemode: the codemode factory (the loader contract).
  *
- * The sigrun extension-package contract (sigrun's src/harness/loader.ts):
- * the default export is a FACTORY TAKING NO ARGUMENTS, returning
- * `{ extension }`. The loader calls it synchronously at boot, before
- * `Harness.open` reads the registry.
+ * MCP namespaces come from ext-mcp's `mcp.servers` published hook. Codemode
+ * loads before ext-mcp, so the factory starts (but never awaits) the first
+ * refresh; committed settings writes and the per-run lifecycle refresh it
+ * again. Upstream reads the namespaces array at use time, so the
+ * owned array is updated in place rather than replaced.
  *
- * What the factory does, in order:
- *   1. Reads the MCP namespace snapshot ONCE (src/config.ts):
- *      `SIGRUN_MCP_CONFIG` → `~/.config/sigrun/mcp.json`; absent file →
- *      empty namespaces (the extension still ships its codemode tool +
- *      section); a bad file warns and installs un-namespaced.
- *   2. Builds the QuickJS sandbox with the pinned constructor options
- *      (timeoutMs 300_000 — pi-codemode's own default, restated so the
- *      contract does not drift; memoryLimitBytes 256 MiB — a real cap
- *      where the upstream default is unbounded wasm32).
- *   3. Wraps upstream's `createCodemodeExtension({ sandbox, namespaces })`
- *      with the companion notice section (src/extension.ts).
- *
- * Note on `timeoutMs` (verified against pi-codemode 1.2.0): the
- * CONSTRUCTOR timeout governs `sandbox.execute()`; the durable codemode
- * tool path (`sandbox.start()`) takes its deadline from the script's own
- * `// @options: {"timeout_ms": N}` line (no options line → no deadline:
- * the sandbox default does not apply there). The constructor cap is
- * still the right pin: it bounds every execution of the plain sandbox
- * surface and documents the intended ceiling.
- *
- * `quickjs-wasi` is a REAL dependency of this package, not a transitive
- * courtesy: pi-codemode's worker resolves `quickjs-wasi/quickjs.wasm`
- * from disk at the first script. A re-pinned or deduped-away transitive
- * copy strands the wasm file and the first codemode call fails at runtime
- * (500s in prod) — declaring it here pins the resolution to this
- * package's own tree.
+ * `quickjs-wasi` is a direct dependency: pi-codemode's worker resolves its
+ * wasm from this package's tree at the first script.
  */
 import { CodemodeSandbox } from "@earendil-works/pi-codemode";
-import { loadNamespaces } from "./config.js";
 import { createSigrunCodemodeExtension } from "./extension.js";
 /** Pinned per-execution wall-clock deadline (pi-codemode's default). */
 export const CODEMODE_TIMEOUT_MS = 300_000;
 /** Pinned QuickJS heap cap (256 MiB; upstream default is unbounded). */
 export const CODEMODE_MEMORY_LIMIT_BYTES = 256 * 1024 * 1024;
-/**
- * The codemode factory (the loader contract: no arguments; config resolves
- * from the package context). Each call builds a FRESH sandbox — one
- * wiring, one sandbox, no shared worker state across installs.
- */
-export function createCodemodeWiring() {
-    const namespaces = loadNamespaces();
+/** Hidden-only servers have no tools scripts can call. */
+function fullyHidden(server) {
+    return server.exposure === "hidden" &&
+        Object.values(server.toolExposure).every((exposure) => exposure === "hidden");
+}
+/** Each call builds a fresh sandbox and one live array shared with upstream. */
+export function createCodemodeWiring(host) {
+    const namespaces = [];
     const sandbox = new CodemodeSandbox({
         timeoutMs: CODEMODE_TIMEOUT_MS,
         memoryLimitBytes: CODEMODE_MEMORY_LIMIT_BYTES,
     });
     const extension = createSigrunCodemodeExtension({ sandbox, namespaces });
+    let failure;
+    const refreshNamespaces = async () => {
+        if (host === undefined)
+            return;
+        let problem;
+        try {
+            const result = await host.publishedHooks.call("mcp.servers", {});
+            if (result.status === "absent") {
+                // MCP is optional: an intentionally disabled provider is not a failure.
+            }
+            else if (result.status !== "ok") {
+                problem = `status ${result.status}`;
+            }
+            else {
+                const { servers } = result.value;
+                const next = servers
+                    .filter((server) => server.enabled && !fullyHidden(server))
+                    .map((server) => ({
+                    name: server.name,
+                    description: `MCP server ${server.name} (tools ${server.name}/<tool>, registered by sigrun-ext-mcp)`,
+                    prefix: `${server.name}/`,
+                }));
+                namespaces.splice(0, namespaces.length, ...next);
+            }
+        }
+        catch (cause) {
+            problem = cause instanceof Error ? cause.message : String(cause);
+        }
+        if (problem !== undefined && problem !== failure) {
+            console.warn(`sigrun-ext-codemode: mcp.servers refresh failed: ${problem}`);
+        }
+        failure = problem;
+    };
     return {
         extension,
         sandbox,
         namespaces,
+        ready: refreshNamespaces(),
+        conversationCreated: refreshNamespaces,
+        runSettled: refreshNamespaces,
+        onSettingsChanged: refreshNamespaces,
         close: () => sandbox.close(),
     };
 }
-/**
- * The sigrun extension-package contract: the default export is a factory
- * taking no arguments, returning `{ extension }`.
- */
 export default createCodemodeWiring;
 export { CODEMODE_NOT_OFFERED_NOTICE, CODEMODE_NOTICE_SECTION_KEY, renderCodemodeNotice, } from "./extension.js";
-export { loadNamespaces, MCP_CONFIG_ENV, resolveMcpConfigPath, serverEnabled, } from "./config.js";

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@sigrun/ext-codemode",
-	"version": "0.1.3",
-	"description": "Codemode extension for sigrun (pi-durable): the `codemode` tool — model-written JavaScript in a QuickJS sandbox, with MCP-server tools namespaced as script-callable tools",
+	"version": "0.2.1",
+	"description": "Codemode extension for sigrun (pi-durable): the `codemode` tool \u2014 model-written JavaScript in a QuickJS sandbox, with MCP-server tools namespaced as script-callable tools",
 	"type": "module",
 	"engines": {
 		"node": ">=22.19.0"
@@ -31,15 +31,18 @@
 		"@earendil-works/chord": "~1.5.0",
 		"@earendil-works/pi-ai": "~1.5.0",
 		"@earendil-works/pi-codemode": "~1.5.0",
-		"@earendil-works/pi-durable": "~1.5.0"
+		"@earendil-works/pi-durable": "~1.5.0",
+		"typebox": "1.3.27"
 	},
 	"devDependencies": {
 		"@earendil-works/chord": "1.5.0",
 		"@earendil-works/pi-ai": "1.5.0",
 		"@earendil-works/pi-codemode": "1.5.0",
 		"@earendil-works/pi-durable": "1.5.0",
+		"@sigrun/sigrun": "file:../sigrun",
 		"@types/node": "^26.6.4",
 		"tsx": "^4.23.15",
+		"typebox": "1.3.27",
 		"typescript": "^7.0.2",
 		"vitest": "^5.0.3"
 	},

package/dist/config.d.ts

@@ -1,68 +0,0 @@
-/**
- * The codemode config snapshot: the mcp.json-derived namespace list.
- *
- * Reuses the MCP config RESOLUTION and the namespace-relevant parse SHAPES
- * from sigrun-ext-mcp (rev-3 ruling accepts the duplicated parse of the
- * config file across repos; sigrun-ext-mcp is not npm-published, so its
- * `parseMcpConfig` cannot be imported here — the shapes are duplicated
- * with the derivations quoted below for review parity).
- *
- * Resolution order (identical to sigrun-ext-mcp src/config.ts):
- *   1. `SIGRUN_MCP_CONFIG` env override — an explicit path to an mcp.json
- *   2. `~/.config/sigrun/mcp.json` (the sigrun config dir)
- *
- * What we read from each server entry:
- *   - `serverEnabled` (mcp repo's derivation): `enabled: false` OR
- *     `disabled: true` skips the server entirely.
- *   - Exposure (mcp repo's shape): a server-default `exposure` word, plus
- *     `toolExposure` overrides mapping exact tool names or `*`-patterns to
- *     exposure words; the pi alias `codemode-deferred` normalizes to
- *     `codemode`. A server whose tools all resolve `hidden` contributes
- *     nothing scripts can call (hidden tools never register), so it is
- *     excluded from the snapshot: that happens when the server default is
- *     `hidden` and every override is `hidden` too (an exact name wins over
- *     patterns; among patterns the first match in config order wins — so
- *     only a fully-hidden override table leaves every tool hidden).
- *
- * Snapshot semantics (the spec ruling): the config is read ONCE at factory
- * time; late or flapping servers render un-namespaced in the section until
- * the next boot. The section BODY re-renders live from
- * `PromptInput.agent.callable` each turn (upstream's render), so tool
- * lists are never stale — only the namespace GROUPING is a snapshot.
- */
-import type { CodemodeNamespace } from "@earendil-works/pi-durable/codemode";
-/** The env override the config store reads (sigrun-ext-mcp's name). */
-export declare const MCP_CONFIG_ENV = "SIGRUN_MCP_CONFIG";
-/** The exposure words, after normalization (mcp repo's McpExposure). */
-declare const EXPOSURE_WORDS: readonly ["codemode", "deferred", "direct", "hidden"];
-type ExposureWord = (typeof EXPOSURE_WORDS)[number];
-/** One server entry as this package needs it (a subset of the mcp repo's
- * McpServerConfig: only the namespace-relevant fields). */
-export interface McpServerEntry {
-    /** Skip this server entirely (either false means off). */
-    readonly enabled?: boolean;
-    readonly disabled?: boolean;
-    /** Server-default exposure (default "codemode"). */
-    readonly exposure?: ExposureWord;
-    /** Per-tool overrides: exact names beat `*`-patterns; first pattern wins. */
-    readonly toolExposure?: Readonly<Record<string, ExposureWord>>;
-}
-/** Resolve the config path without reading it (for diagnostics). */
-export declare function resolveMcpConfigPath(env?: NodeJS.ProcessEnv): string;
-/** Whether a configured server participates at all (mcp repo's
- * `serverEnabled`): `enabled: false` and `disabled: true` both skip it. */
-export declare function serverEnabled(server: McpServerEntry): boolean;
-/**
- * Read the mcp.json from the resolved path and build the namespace
- * snapshot: one `CodemodeNamespace` per participating server with prefix
- * `"<server>/"` (the namespace ruler: our tool-name shape is already
- * `<server>/<tool>`, so upstream's longest-prefix grouping needs no renames).
- *
- * A missing file is an EMPTY namespace list (the extension still ships its
- * codemode tool + section). An existing-but-bad file or entry warns at
- * factory time (the spec's best-effort boot log; NOT the contract — a bad
- * config must not cost the model its codemode tool) and the extension
- * installs un-namespaced rather than throwing.
- */
-export declare function loadNamespaces(env?: NodeJS.ProcessEnv): readonly CodemodeNamespace[];
-export {};

package/dist/config.js

@@ -1,166 +0,0 @@
-/**
- * The codemode config snapshot: the mcp.json-derived namespace list.
- *
- * Reuses the MCP config RESOLUTION and the namespace-relevant parse SHAPES
- * from sigrun-ext-mcp (rev-3 ruling accepts the duplicated parse of the
- * config file across repos; sigrun-ext-mcp is not npm-published, so its
- * `parseMcpConfig` cannot be imported here — the shapes are duplicated
- * with the derivations quoted below for review parity).
- *
- * Resolution order (identical to sigrun-ext-mcp src/config.ts):
- *   1. `SIGRUN_MCP_CONFIG` env override — an explicit path to an mcp.json
- *   2. `~/.config/sigrun/mcp.json` (the sigrun config dir)
- *
- * What we read from each server entry:
- *   - `serverEnabled` (mcp repo's derivation): `enabled: false` OR
- *     `disabled: true` skips the server entirely.
- *   - Exposure (mcp repo's shape): a server-default `exposure` word, plus
- *     `toolExposure` overrides mapping exact tool names or `*`-patterns to
- *     exposure words; the pi alias `codemode-deferred` normalizes to
- *     `codemode`. A server whose tools all resolve `hidden` contributes
- *     nothing scripts can call (hidden tools never register), so it is
- *     excluded from the snapshot: that happens when the server default is
- *     `hidden` and every override is `hidden` too (an exact name wins over
- *     patterns; among patterns the first match in config order wins — so
- *     only a fully-hidden override table leaves every tool hidden).
- *
- * Snapshot semantics (the spec ruling): the config is read ONCE at factory
- * time; late or flapping servers render un-namespaced in the section until
- * the next boot. The section BODY re-renders live from
- * `PromptInput.agent.callable` each turn (upstream's render), so tool
- * lists are never stale — only the namespace GROUPING is a snapshot.
- */
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { isAbsolute, resolve } from "node:path";
-/** The env override the config store reads (sigrun-ext-mcp's name). */
-export const MCP_CONFIG_ENV = "SIGRUN_MCP_CONFIG";
-/** The exposure words, after normalization (mcp repo's McpExposure). */
-const EXPOSURE_WORDS = ["codemode", "deferred", "direct", "hidden"];
-/** Parse one exposure word; the pi alias normalizes to "codemode". */
-const EXPOSURE_WORD_SET = new Set(EXPOSURE_WORDS);
-function parseExposure(value, where) {
-    if (value === "codemode-deferred")
-        return "codemode";
-    if (typeof value !== "string" || !EXPOSURE_WORD_SET.has(value)) {
-        throw new Error(`${where} exposure must be one of ${EXPOSURE_WORDS.map((word) => JSON.stringify(word)).join(", ")} (or "codemode-deferred", the pi alias for "codemode")`);
-    }
-    return value;
-}
-/** Resolve the config path without reading it (for diagnostics). */
-export function resolveMcpConfigPath(env = process.env) {
-    const override = env[MCP_CONFIG_ENV];
-    if (override !== undefined && override !== "") {
-        // A relative override resolves against cwd, like sigrun's other paths.
-        return isAbsolute(override) ? override : resolve(override);
-    }
-    return resolve(homedir(), ".config", "sigrun", "mcp.json");
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/** Whether a configured server participates at all (mcp repo's
- * `serverEnabled`): `enabled: false` and `disabled: true` both skip it. */
-export function serverEnabled(server) {
-    return server.enabled !== false && server.disabled !== true;
-}
-/** Whether every tool of this server resolves `hidden`: the server default
- * is `hidden` and no override can un-hide a tool (every override value is
- * `hidden`; an exact name or pattern pointing elsewhere un-hides whatever
- * it matches). Hidden tools never register, so such a server contributes
- * nothing scripts can call and gets no namespace. */
-function serverFullyHidden(server) {
-    if ((server.exposure ?? "codemode") !== "hidden")
-        return false;
-    return Object.values(server.toolExposure ?? {}).every((word) => word === "hidden");
-}
-/**
- * Read the mcp.json from the resolved path and build the namespace
- * snapshot: one `CodemodeNamespace` per participating server with prefix
- * `"<server>/"` (the namespace ruler: our tool-name shape is already
- * `<server>/<tool>`, so upstream's longest-prefix grouping needs no renames).
- *
- * A missing file is an EMPTY namespace list (the extension still ships its
- * codemode tool + section). An existing-but-bad file or entry warns at
- * factory time (the spec's best-effort boot log; NOT the contract — a bad
- * config must not cost the model its codemode tool) and the extension
- * installs un-namespaced rather than throwing.
- */
-export function loadNamespaces(env = process.env) {
-    const path = resolveMcpConfigPath(env);
-    if (!existsSync(path))
-        return [];
-    try {
-        return parseNamespaces(readFileSync(path, "utf8"), path);
-    }
-    catch (cause) {
-        console.warn(`sigrun-ext-codemode: mcp config ${path} is invalid (codemode ` +
-            `tools install un-namespaced): ${cause instanceof Error ? cause.message : String(cause)}`);
-        return [];
-    }
-}
-/** Parse and validate the config body into the namespace snapshot. */
-function parseNamespaces(text, path) {
-    const parsed = JSON.parse(text);
-    if (!isRecord(parsed) || !isRecord(parsed.servers)) {
-        throw new Error(`must be a JSON object with a "servers" object mapping names to server entries`);
-    }
-    const namespaces = [];
-    for (const [name, entry] of Object.entries(parsed.servers)) {
-        if (!isRecord(entry)) {
-            throw new Error(`server "${name}" must be an object`);
-        }
-        const server = parseServerEntry(entry, path, name);
-        if (!serverEnabled(server))
-            continue;
-        if (serverFullyHidden(server)) {
-            // The spec's best-effort boot log: hidden-only rows.
-            console.warn(`sigrun-ext-codemode: mcp server "${name}" resolves fully ` +
-                `hidden (excluded from the codemode namespaces)`);
-            continue;
-        }
-        namespaces.push({
-            name,
-            description: `MCP server ${name} (tools ${name}/<tool>, registered by sigrun-ext-mcp)`,
-            prefix: `${name}/`,
-        });
-    }
-    return namespaces;
-}
-/** Validate one server entry's namespace-relevant fields. */
-function parseServerEntry(entry, path, name) {
-    for (const field of ["enabled", "disabled"]) {
-        const value = entry[field];
-        if (value !== undefined && typeof value !== "boolean") {
-            throw new Error(`mcp config ${path}: server "${name}" ${field} must be a boolean`);
-        }
-    }
-    return {
-        ...(entry.enabled === undefined
-            ? {}
-            : { enabled: entry.enabled }),
-        ...(entry.disabled === undefined
-            ? {}
-            : { disabled: entry.disabled }),
-        ...(entry.exposure === undefined
-            ? {}
-            : {
-                exposure: parseExposure(entry.exposure, `mcp config ${path}: server "${name}"`),
-            }),
-        ...(entry.toolExposure === undefined
-            ? {}
-            : {
-                toolExposure: parseToolExposure(entry.toolExposure, path, name),
-            }),
-    };
-}
-function parseToolExposure(value, path, name) {
-    if (!isRecord(value)) {
-        throw new Error(`mcp config ${path}: server "${name}" toolExposure must be an object`);
-    }
-    const overrides = {};
-    for (const [key, exposure] of Object.entries(value)) {
-        overrides[key] = parseExposure(exposure, `mcp config ${path}: server "${name}" toolExposure "${key}"`);
-    }
-    return overrides;
-}