heedvane 0.2.1 → 0.3.4

package/dist/commands/heedvane.js

@@ -22,7 +22,6 @@ export async function cmdLogin(ctx) {
             ctx.out(`  ⚠ ${url} does not accept the sign-in on its agent routes yet (401): steering, skills and event forwarding stay off with it.`);
             ctx.out("    while signed in, no organization key is used; to use one until Heedvane accepts the sign-in, delete ~/.heed/login.json and run npx heedvane auth org < key-file");
         }
-        ctx.out("    a running listener picks it up when restarted: npx heedvane listener start");
         return 0;
     }
     catch (err) {
@@ -30,6 +29,16 @@ export async function cmdLogin(ctx) {
         return 1;
     }
 }
+/** heed.yaml's Heedvane URL, or null after saying that heed.yaml does not parse. */
+function serverUrl(root, out) {
+    try {
+        return heedvaneConfigAt(root).url;
+    }
+    catch (err) {
+        out(`  ✗ ~/.heed/heed.yaml does not parse (${errorMessage(err)}); fix it, then run this again`);
+        return null;
+    }
+}
 /** `npx heedvane auth org`: the key arrives on stdin, so it never lands in shell history. */
 export async function cmdAuth(ctx) {
     const kind = ctx.words[0];
@@ -43,7 +52,10 @@ export async function cmdAuth(ctx) {
         return 1;
     }
     const root = join(ctx.home, ".heed");
-    await withSignInChange(root, heedvaneConfigAt(root).url, () => saveCredential(root, kind, key));
+    const url = serverUrl(root, ctx.out);
+    if (url === null)
+        return 1;
+    await withSignInChange(root, url, () => saveCredential(root, kind, key));
     ctx.out(`  ✓ ${kind} key saved to ~/.heed/credentials.json (mode 0600)`);
     return 0;
 }
@@ -54,7 +66,10 @@ export async function cmdSkills(ctx) {
         return 2;
     }
     const root = join(ctx.home, ".heed");
-    const backend = await backendAt(root, heedvaneConfigAt(root).url);
+    const url = serverUrl(root, ctx.out);
+    if (url === null)
+        return 1;
+    const backend = await backendAt(root, url);
     if (backend === null) {
         ctx.out("  ✗ not signed in — run: npx heedvane login (or, headless: npx heedvane auth org < key-file)");
         return 1;

package/dist/commands/mcp-stub.d.ts

@@ -0,0 +1 @@
+export declare function cmdMcpStub(): Promise<number>;

package/dist/commands/mcp-stub.js

@@ -0,0 +1,44 @@
+/**
+ * `npx heedvane mcp`: 0.1.0 to 0.2.1 registered this local helper in agent configs, and npx now starts this version
+ * for them. It answers as an MCP server with no tools (newline-delimited JSON-RPC on stdio), so those agents still
+ * start cleanly, says on stderr how to connect, and ends when the agent closes stdin. `connect` replaces the entry with
+ * Heedvane's MCP connection, and `doctor` names it.
+ */
+import { createInterface } from "node:readline";
+import { isRecord } from "../guards.js";
+const LATEST_PROTOCOL = "2025-06-18";
+export async function cmdMcpStub() {
+    process.stderr.write("heedvane: this local MCP helper was replaced by Heedvane's MCP connection. Run: npx -y heedvane connect --org <organization id>\n");
+    for await (const line of createInterface({ input: process.stdin })) {
+        const answer = answerTo(line);
+        if (answer !== undefined)
+            process.stdout.write(`${JSON.stringify(answer)}\n`);
+    }
+    return 0;
+}
+/** The answer to one request; none for a notification or a line that is not a request. */
+function answerTo(line) {
+    let request;
+    try {
+        request = JSON.parse(line);
+    }
+    catch {
+        return undefined; // not JSON-RPC: nothing to answer
+    }
+    if (!isRecord(request) || request["id"] === undefined)
+        return undefined;
+    const id = request["id"];
+    const params = isRecord(request["params"]) ? request["params"] : {};
+    switch (request["method"]) {
+        case "initialize": {
+            const protocolVersion = typeof params["protocolVersion"] === "string" ? params["protocolVersion"] : LATEST_PROTOCOL;
+            return { jsonrpc: "2.0", id, result: { protocolVersion, capabilities: { tools: {} }, serverInfo: { name: "heedvane", version: "replaced" } } };
+        }
+        case "tools/list":
+            return { jsonrpc: "2.0", id, result: { tools: [] } };
+        case "ping":
+            return { jsonrpc: "2.0", id, result: {} };
+        default:
+            return { jsonrpc: "2.0", id, error: { code: -32601, message: "Method not found" } };
+    }
+}

package/dist/commands/memory.js

@@ -37,7 +37,12 @@ async function ask(ctx, request) {
         return 1;
     }
     const root = join(ctx.home, ".heed");
-    const backend = await backendAt(root, heedvaneConfigAt(root).url);
+    const config = heedvaneConfigAt(root);
+    if (config.dataMode === "metrics-only") {
+        ctx.out("  ✗ team memory is off on this machine: heed.yaml heedvane.dataMode is metrics-only, so no question or repository leaves it");
+        return 1;
+    }
+    const backend = await backendAt(root, config.url);
     if (backend === null) {
         ctx.out("  ✗ not signed in — run: npx heedvane login (or, headless: npx heedvane auth org < key-file)");
         return 1;

package/dist/dispatchers/posix.d.ts

@@ -7,22 +7,16 @@ import type { HeedGatingConfig } from "../heed-file.js";
  * configs, so policy updates rewrite only this file. Observe-only v1: every path
  * exits 0; the agent is never blocked and never sees stderr noise.
  *
- * Spool fallback (Orca's spool_hook_event): appends one JSON line to
- * <heed root>/spool/pane-<key>.jsonl, beside endpoint.env (HEED_AGENT_HOOK_ENDPOINT, else
- * $HEED_AGENT_HOOK_ROOT or ~/.heed), 5 MB cap per pane file, 7-day TTL via
- * `find -mtime`, 0600 perms, JSON-escaped envelope carrying
- * paneKey/tabId/worktreeId/launchToken/source/receivedAt/payload.
+ * Live path: curl POST to http://127.0.0.1:$HEED_AGENT_HOOK_PORT/hook/<agent> with X-Heed-Agent-Hook-Token and
+ * X-Heed-Hook-Version: 1, within the timeouts of src/hook-fallback.ts. The listener answers from this machine alone;
+ * only a session start waits longer, for the session's one fetch of the steering policy.
  *
- * Live path: curl POST to http://127.0.0.1:$HEED_AGENT_HOOK_PORT/hook/<agent> with
- * X-Heed-Agent-Hook-Token and X-Heed-Hook-Version: 1, 0.5s connect / 0.8s max, falling back to spool
- * on any failure. The listener answers from this machine alone; only a session start waits (2s max)
- * for the session's one fetch of the steering policy.
- *
- * Start on the fly: when nothing listens on the port (curl exit 7, connection refused), the event is
- * spooled and `npx -y heedvane listener start` is started in the background, at most once a minute
- * (a `listener.starting` lock directory older than a minute is cleared). The listener replays the
- * spool when it starts, so steering comes back by itself after a restart; no login service is needed.
- * `HEED_LISTENER_AUTOSTART=0` in the agent's environment turns this off.
+ * Fallback: when the listener gives no answer (no endpoint, nothing listens, it times out, or it answers an error),
+ * the script runs Heedvane's one fallback, `fallback.mjs` beside it (src/guard.ts), with the Node that installed the
+ * hooks (named in `node` beside it), or with node on PATH once that one is gone. That keeps the event in the spool beside endpoint.env for the listener to replay, starts
+ * `npx -y heedvane listener start` (which decides itself whether a listener must start or take over), and adds the
+ * notice the first time in a session. When the fallback itself fails, the agent still gets the fallback answer.
+ * `HEED_LISTENER_AUTOSTART=0` in the agent's environment turns the start off.
  */
 export interface DispatcherOptions {
     /** heed.yaml `heedvane.skills.whenUnknown: deny`: with no listener to check it, deny a skill use. */
@@ -30,12 +24,15 @@ export interface DispatcherOptions {
     /** heed.yaml `gating.mode`: `pane` (the default) runs the hooks only in sessions launched with
      *  HEED_SESSION set; `always` runs them in every session. */
     gating?: HeedGatingConfig["mode"];
-    /** The folder holding node and npx at install time, appended to PATH for the start on the fly:
-     *  an agent launched from a desktop app may run its hooks without them on PATH. */
-    nodeDir?: string;
 }
 export declare function dispatcherScript(agentId: string, options?: DispatcherOptions): string;
 /** The on-disk dispatcher directory under the heed root. */
 export declare function agentHooksDir(home: string): string;
-/** Write (or update) the dispatcher script for one agent. Idempotent, mode 0700. */
+/** Write (or update) the dispatcher script for one agent, mode 0700, and the fallback it runs beside it. Idempotent. */
 export declare function writeDispatcherScript(home: string, agent: string, options?: DispatcherOptions): Promise<void>;
+/**
+ * Names the Node running this install in `node` beside the dispatchers, for every hook's fallback (the dispatchers' and
+ * Hermes'). It is the PATH entry that links to that Node when there is one: Homebrew's /opt/homebrew/bin/node outlives
+ * `brew upgrade`, the Cellar path it links to does not. Git Bash on Windows runs C:/… paths, so no backslashes.
+ */
+export declare function writeHookNode(home: string, path?: string): Promise<void>;

package/dist/dispatchers/posix.js

@@ -1,6 +1,10 @@
+import { realpathSync } from "node:fs";
 import { chmod, mkdir, readFile } from "node:fs/promises";
-import { join } from "node:path";
+import { basename, delimiter, join } from "node:path";
 import writeFileAtomic from "write-file-atomic";
+import { guardSource } from "../clients/pi-extension.js";
+import { FALLBACK_FILE, HOOK_CONNECT_TIMEOUT_MS, HOOK_NODE_FILE, HOOK_TIMEOUT_MS, PROOF_KEY, RETRY_AFTER_MS, SESSION_START_TIMEOUT_MS, UNANSWERED_FLAG } from "../hook-fallback.js";
+import { USER_NOTICE_FIELD } from "../reply/harness-output.js";
 import { validateAgentId } from "./snippets.js";
 /** The stdout a Claude Code PreToolUse hook prints to deny (src/reply/harness-output.ts owns the shape). */
 const UNCHECKED_SKILL_DENY = JSON.stringify({
@@ -15,7 +19,7 @@ export function dispatcherScript(agentId, options = {}) {
     // Only Claude Code's deny shape is verified; other agents keep the fail-open fallback.
     const denySkills = options.denySkillsWhenUnchecked === true && agentId === "claude";
     const gating = options.gating ?? "always";
-    const nodeDir = (options.nodeDir ?? "").replaceAll("'", "'\\''");
+    const noticeField = USER_NOTICE_FIELD[agentId];
     return `#!/bin/sh
 # heedvane-agent-hook dispatcher for ${agentId} — generated by heedvane-hook. Do not hand-edit.
 # Rewritten wholesale by \`npx heedvane setup\`; policy updates never touch agent configs.
@@ -28,9 +32,6 @@ umask 077
 
 HEED_HOOK_AGENT="${agentId}"
 HEED_HOOK_VERSION=1
-HEED_HOOK_SPOOL_CAP=5242880
-HEED_HOOK_SPOOL_TTL_DAYS=7
-HEED_HOOK_NODE_DIR='${nodeDir}'
 
 [ -n "\${HOME:-}" ] || exit 0
 
@@ -42,70 +43,21 @@ HEED_HOOK_GATING="${gating}"
 # endpoint.env (written by init/setup/listener start) sits in the heed root; the spool beside it.
 HEED_HOOK_ENDPOINT_FILE="\${HEED_AGENT_HOOK_ENDPOINT:-\${HEED_AGENT_HOOK_ROOT:-$HOME/.heed}/endpoint.env}"
 
-heed_spool_dir() {
-  printf '%s\\n' "\${HEED_HOOK_ENDPOINT_FILE%/*}/spool"
-}
-
-# Escape a string for embedding inside a JSON document (POSIX awk).
-# Encodes backslash, double quote, tab and CR; newlines are re-encoded per record.
-# Other C0 control chars survive as-is — payloads are harness JSON, and v1
-# treats a best-effort escape as acceptable for spool records.
-json_escape() {
-  printf '%s' "$1" | LC_ALL=C awk '
-    NR > 1 { printf "\\\\n" }
-    {
-      gsub(/\\\\/, "\\\\\\\\")
-      gsub(/"/, "\\\\\\"")
-      gsub(/\\t/, "\\\\t")
-      gsub(/\\r/, "\\\\r")
-      printf "%s", $0
-    }'
-}
-
-spool_hook_event() {
-  _body="\${1:-}"
-  [ -n "$_body" ] || return 0
-  _dir="$(heed_spool_dir)"
-  mkdir -p "$_dir" 2>/dev/null || return 0
-  _key="\${HEED_PANE_KEY:-\${HEED_SESSION:-}}"
-  [ -n "$_key" ] || _key="default"
-  _file="$_dir/pane-$_key.jsonl"
-
-  # 7-day TTL: prune stale pane spool files, and the events set aside after a change of sign-in (other-sign-in/), on every write (cheap).
-  find "$_dir" -type f \\( -name 'pane-*.jsonl*' -o -path '*/other-sign-in/*' \\) -mtime "+$HEED_HOOK_SPOOL_TTL_DAYS" -delete 2>/dev/null || :
-
-  # 5 MB cap: once a pane file is over budget, drop further events (never grow unbounded).
-  if [ -f "$_file" ]; then
-    _size="$(wc -c < "$_file" 2>/dev/null || echo 0)"
-    [ "$_size" -lt "$HEED_HOOK_SPOOL_CAP" ] || return 0
-  fi
-
-  _received="$(date -u +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || date -u)"
-  _envelope="{\\"paneKey\\":\\"$(json_escape "\${HEED_PANE_KEY:-\${HEED_SESSION:-}}")\\""
-  _envelope="$_envelope,\\"tabId\\":\\"$(json_escape "\${HEED_TAB_ID:-}")\\""
-  _envelope="$_envelope,\\"worktreeId\\":\\"$(json_escape "\${HEED_WORKTREE_ID:-}")\\""
-  _envelope="$_envelope,\\"launchToken\\":\\"$(json_escape "\${HEED_LAUNCH_TOKEN:-}")\\""
-  _envelope="$_envelope,\\"source\\":\\"$(json_escape "$HEED_HOOK_AGENT")\\""
-  _envelope="$_envelope,\\"receivedAt\\":\\"$(json_escape "$_received")\\""
-  _envelope="$_envelope,\\"id\\":\\"$(json_escape "\${heed_event_id:-}")\\""
-  _envelope="$_envelope,\\"payload\\":\\"$(json_escape "$_body")\\"}"
-
-  printf '%s\\n' "$_envelope" >> "$_file" 2>/dev/null || return 0
-  chmod 600 "$_file" 2>/dev/null || :
-  return 0
-}
-
-# Nothing listens (connection refused): start the listener in the background, at most one try a
-# minute, so steering comes back by itself after a restart. It replays the spooled event at its start.
-heed_start_listener() {
-  [ "\${HEED_LISTENER_AUTOSTART:-1}" != "0" ] || return 0
-  _root="\${HEED_HOOK_ENDPOINT_FILE%/*}"
-  case "$_root" in */.heed) ;; *) return 0 ;; esac
-  _lock="$_root/listener.starting"
-  find "$_lock" -maxdepth 0 -mmin +1 -exec rmdir {} \\; 2>/dev/null || :
-  mkdir "$_lock" 2>/dev/null || return 0
-  (PATH="$PATH:$HEED_HOOK_NODE_DIR" HEED_HOME="\${_root%/.heed}" nohup npx -y heedvane listener start < /dev/null >> "$_root/listener.log" 2>&1 &) 2>/dev/null || :
-  return 0
+# The listener gave no answer: Heedvane's one fallback keeps the event and adds the notice once a session (see the
+# header of src/dispatchers/posix.ts). Its own failure never blocks the agent: the answer is then $heed_fallback.
+heed_unanswered() {
+  # The Node that last installed the hooks, by its PATH link and then itself; node on PATH once both are gone (brew upgrade, nvm uninstall).
+  heed_node=""
+  { while IFS= read -r heed_candidate || [ -n "$heed_candidate" ]; do
+    if [ -x "$heed_candidate" ]; then heed_node="$heed_candidate"; break; fi
+  done < "\${0%/*}/${HOOK_NODE_FILE}"; } 2>/dev/null || :
+  [ -n "$heed_node" ] || heed_node="$(command -v node 2>/dev/null)" || :
+  # The agent's NODE_OPTIONS are its project's (a --require of its own code), not the fallback's.
+  _answer="$(printf '%s' "$payload" | NODE_OPTIONS='' HEED_HOOK_FALLBACK_ANSWER="$heed_fallback" HEED_HOOK_EVENT_ID="\${heed_event_id:-}" "$heed_node" "\${0%/*}/${FALLBACK_FILE}" ${UNANSWERED_FLAG} "$HEED_HOOK_AGENT"${noticeField === undefined ? "" : ` ${noticeField}`} 2>/dev/null)" || :
+  case "$_answer" in
+    "{"*) heed_answer "$_answer" ;;
+  esac
+  heed_answer "$heed_fallback"
 }
 
 # The hook payload arrives on stdin. command -p keeps cat working under a stripped PATH.
@@ -142,36 +94,40 @@ heed_answer() {
 
 [ -n "$payload" ] || heed_answer '{}'
 
-# Port/token come from endpoint.env (HEED_AGENT_HOOK_PORT / HEED_AGENT_HOOK_TOKEN lines).
+# Port/token: from the environment when both are set, else from endpoint.env (HEED_AGENT_HOOK_PORT / HEED_AGENT_HOOK_TOKEN lines).
 # shellcheck disable=SC1090
-if [ -r "$HEED_HOOK_ENDPOINT_FILE" ]; then
+if { [ -z "\${HEED_AGENT_HOOK_PORT:-}" ] || [ -z "\${HEED_AGENT_HOOK_TOKEN:-}" ]; } && [ -r "$HEED_HOOK_ENDPOINT_FILE" ]; then
   . "$HEED_HOOK_ENDPOINT_FILE" 2>/dev/null || :
 fi
 
-# No listener contract (endpoint env, port, token): spool instead, still exit 0.
+# No listener contract (endpoint env, port, token): the fallback, still exit 0.
 if [ -z "\${HEED_AGENT_HOOK_PORT:-}" ] || [ -z "\${HEED_AGENT_HOOK_TOKEN:-}" ]; then
-  spool_hook_event "$payload"
-  heed_answer "$heed_fallback"
+  heed_unanswered
 fi
 
 # A local answer takes milliseconds. Only a session start waits for Heedvane (its one policy fetch).
-heed_max_time=0.8
+heed_max_time=${HOOK_TIMEOUT_MS / 1000}
 case "$payload" in
-  *'"hook_event_name":"SessionStart"'*|*'"hook_event_name": "SessionStart"'*) heed_max_time=2 ;;
+  *'"hook_event_name":"SessionStart"'*|*'"hook_event_name": "SessionStart"'*) heed_max_time=${SESSION_START_TIMEOUT_MS / 1000} ;;
 esac
 
-reply="$(printf '%s' "$payload" | curl -sS --fail -X POST "http://127.0.0.1:\${HEED_AGENT_HOOK_PORT}/hook/${agentId}" \\
-  --connect-timeout 0.5 --max-time "$heed_max_time" --noproxy 127.0.0.1 \\
+reply="$(printf '%s' "$payload" | curl -sS --fail -D - -X POST "http://127.0.0.1:\${HEED_AGENT_HOOK_PORT}/hook/${agentId}" \\
+  --connect-timeout ${HOOK_CONNECT_TIMEOUT_MS / 1000} --max-time "$heed_max_time" --noproxy 127.0.0.1 \\
+  -H "Expect:" \\
   -H "Content-Type: application/json" \\
   -H "X-Heed-Agent-Hook-Token: \${HEED_AGENT_HOOK_TOKEN}" \\
   -H "X-Heed-Hook-Version: \${HEED_HOOK_VERSION}" \\
   -H "X-Heed-Event-Id: \${heed_event_id:-}" \\
-  --data-binary @- 2>/dev/null)" || {
-  heed_curl_exit=$?
-  spool_hook_event "$payload"
-  [ "$heed_curl_exit" -ne 7 ] || heed_start_listener
-  heed_answer "$heed_fallback"
-}
+  --data-binary @- 2>/dev/null)" || heed_unanswered
+
+# Only this machine's listener names the proof from endpoint.env (0.3.4 on); any other answer goes to the fallback, which
+# keeps the event. A port and token pinned in the environment come without the proof line, unless ${PROOF_KEY} is pinned
+# too: the fallback derives it from the token.
+# shortcut: pinned without ${PROOF_KEY}, every hook pays a Node start and the fallback's ${RETRY_AFTER_MS} ms pause before it asks again (sh has no HMAC that keeps the token off argv); derive the proof here if such setups show up.
+reply="$(printf '%s\\n' "$reply" | tr -d '\\r')"
+heed_proof="$(printf '%s\\n' "$reply" | sed -n '/^$/q; s/^[Xx]-[Hh][Ee][Ee][Dd]-[Ll][Ii][Ss][Tt][Ee][Nn][Ee][Rr]: //p')"
+[ -n "\${${PROOF_KEY}:-}" ] && [ "$heed_proof" = "\$${PROOF_KEY}" ] || heed_unanswered
+reply="$(printf '%s\\n' "$reply" | sed '1,/^$/d')"
 
 # The listener's answer is the agent's hook output (skill check, steering, recalled memory).
 case "$reply" in
@@ -184,21 +140,45 @@ esac
 export function agentHooksDir(home) {
     return join(home, ".heed", "agent-hooks");
 }
-/** Write (or update) the dispatcher script for one agent. Idempotent, mode 0700. */
+/** Write (or update) the dispatcher script for one agent, mode 0700, and the fallback it runs beside it. Idempotent. */
 export async function writeDispatcherScript(home, agent, options = {}) {
     validateAgentId(agent);
     const dir = agentHooksDir(home);
     await mkdir(dir, { recursive: true, mode: 0o700 });
-    const target = join(dir, `${agent}-hook.sh`);
-    const content = dispatcherScript(agent, options);
-    const existing = await currentDispatcherScript(target);
-    if (existing === content)
+    await writeWhenChanged(join(dir, `${agent}-hook.sh`), dispatcherScript(agent, options));
+    await Promise.resolve()
+        .then(() => writeWhenChanged(join(dir, FALLBACK_FILE), guardSource()))
+        .catch(() => undefined); // without its fallback a dispatcher still answers, with the plain fallback answer
+}
+/**
+ * Names the Node running this install in `node` beside the dispatchers, for every hook's fallback (the dispatchers' and
+ * Hermes'). It is the PATH entry that links to that Node when there is one: Homebrew's /opt/homebrew/bin/node outlives
+ * `brew upgrade`, the Cellar path it links to does not. Git Bash on Windows runs C:/… paths, so no backslashes.
+ */
+export async function writeHookNode(home, path = process.env["PATH"] ?? "") {
+    const real = realpathOrNull(process.execPath);
+    const linked = path.split(delimiter).map((dir) => join(dir, basename(process.execPath))).find((candidate) => real !== null && realpathOrNull(candidate) === real);
+    // The link first, as it outlives `brew upgrade`; then the Node itself, which outlives a per-shell link (fnm's ends with its shell).
+    const nodes = [...new Set([linked, real ?? process.execPath])].filter((node) => node !== undefined);
+    await mkdir(agentHooksDir(home), { recursive: true, mode: 0o700 });
+    await writeWhenChanged(join(agentHooksDir(home), HOOK_NODE_FILE), nodes.map((node) => `${node.replaceAll("\\", "/")}\n`).join(""));
+}
+function realpathOrNull(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return null; // not there: not the Node that runs this
+    }
+}
+async function writeWhenChanged(target, content) {
+    if ((await currentText(target)) === content)
         return; // already current
     await writeFileAtomic(target, content, { mode: 0o700 });
     await chmod(target, 0o700);
 }
-/** The dispatcher script's current text, or null when absent (it will be written below). */
-async function currentDispatcherScript(target) {
+/** The file's current text, or null when absent (it will be written). */
+async function currentText(target) {
     try {
         return await readFile(target, "utf8");
     }

package/dist/doctor.d.ts

@@ -34,4 +34,6 @@ export interface DoctorInput {
     /** Desired-entry lookup injection; defaults to the pure planner. */
     desired?: DesiredEntryLookup;
 }
+/** The oldest Node the CLI runs on, as package.json's `engines` states it: 22.5 has path.matchesGlob, which steering rules with file patterns run on. */
+export declare const NODE_FLOOR = "22.5";
 export declare function runDoctor(input: DoctorInput): Promise<DoctorReport>;