@ouro.bot/cli 0.1.0-alpha.726 → 0.1.0-alpha.728

package/dist/heart/streaming.js

@@ -496,14 +496,14 @@ function toResponsesUserContent(content) {
     return parts.length > 0 ? parts : "";
 }
 function toResponsesInput(messages) {
-    let instructions = "";
+    const instructionParts = [];
     const input = [];
     for (const msg of messages) {
         if (msg.role === "system") {
-            if (!instructions) {
-                const sys = msg;
-                instructions = (typeof sys.content === "string" ? sys.content : "") || "";
-            }
+            const sys = msg;
+            const content = (typeof sys.content === "string" ? sys.content : "").trim();
+            if (content)
+                instructionParts.push(content);
             continue;
         }
         if (msg.role === "user") {
@@ -551,7 +551,7 @@ function toResponsesInput(messages) {
             continue;
         }
     }
-    return { instructions, input };
+    return { instructions: instructionParts.join("\n\n"), input };
 }
 function toResponsesTools(ccTools) {
     return ccTools.map((t) => ({

package/dist/heart/versioning/ouro-path-installer.js

@@ -39,28 +39,20 @@ const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
-const WRAPPER_SCRIPT = `#!/bin/sh
-# Check for dev mode — if dev-config.json exists, dispatch to the dev repo
-# Skip dev dispatch for "up" command (explicitly returns to production)
-DEV_CONFIG="$HOME/.ouro-cli/dev-config.json"
-if [ -f "$DEV_CONFIG" ] && [ "$1" != "up" ]; then
-  DEV_REPO=$(node -e "try{console.log(JSON.parse(require('fs').readFileSync('$DEV_CONFIG','utf-8')).repoPath)}catch{}" 2>/dev/null)
-  DEV_ENTRY="$DEV_REPO/dist/heart/daemon/ouro-entry.js"
-  if [ -n "$DEV_REPO" ] && [ -e "$DEV_ENTRY" ]; then
-    exec node "$DEV_ENTRY" "$@"
-  fi
-fi
-# Fall back to installed version
-ENTRY="$HOME/.ouro-cli/CurrentVersion/node_modules/@ouro.bot/cli/dist/heart/daemon/ouro-entry.js"
-if [ ! -e "$ENTRY" ]; then
-  echo "ouro not installed. Run: npx ouro.bot@latest" >&2
-  exit 1
-fi
-exec node "$ENTRY" "$@"
-`;
-function writeWrapperScript(scriptPath, mkdirSync, writeFileSync, chmodSync) {
+const ouro_recovery_launcher_1 = require("./ouro-recovery-launcher");
+const WRAPPER_SCRIPT = ouro_recovery_launcher_1.OURO_WRAPPER_SCRIPT;
+function writeWrapperScript(scriptPath, mkdirSync, writeFileSync, chmodSync, renameSync, existsSync, readFileSync) {
+    const assets = (0, ouro_recovery_launcher_1.resolveOuroRecoveryLauncherAssets)();
     mkdirSync(path.dirname(scriptPath), { recursive: true });
-    writeFileSync(scriptPath, WRAPPER_SCRIPT, { mode: 0o755 });
+    const launcherPath = path.join(path.dirname(scriptPath), "ouro-launcher.js");
+    const launcherTempPath = `${launcherPath}.next-${process.pid}`;
+    writeFileSync(launcherTempPath, assets.launcherScript, { mode: 0o755 });
+    chmodSync(launcherTempPath, 0o755);
+    renameSync(launcherTempPath, launcherPath);
+    if (existsSync(launcherPath) && readFileSync(launcherPath, "utf8") !== assets.launcherScript) {
+        throw new Error("failed to verify installed Ouro recovery launcher");
+    }
+    writeFileSync(scriptPath, assets.wrapperScript, { mode: 0o755 });
     chmodSync(scriptPath, 0o755);
 }
 function detectShellProfile(homeDir, shell, platform) {
@@ -106,6 +98,16 @@ function isWrapperCurrent(scriptPath, existsSync, readFileSync) {
         return false;
     }
 }
+function isRecoveryLauncherCurrent(scriptPath, existsSync, readFileSync) {
+    if (!existsSync(scriptPath))
+        return false;
+    try {
+        return readFileSync(scriptPath, "utf-8") === ouro_recovery_launcher_1.OURO_RECOVERY_LAUNCHER_SCRIPT;
+    }
+    catch {
+        return false;
+    }
+}
 function isOwnedOuroLauncherPath(resolvedPath) {
     const normalized = path.normalize(resolvedPath);
     return (normalized.includes(`${path.sep}node_modules${path.sep}@ouro.bot${path.sep}cli${path.sep}`) ||
@@ -116,7 +118,8 @@ function isOwnedOuroLauncherContent(content) {
         content.includes("ouro.bot@latest") ||
         content.includes("ouro.bot@alpha") ||
         content.includes('exec npx --yes ouro.bot "$@"') ||
-        content.includes("CurrentVersion/node_modules/@ouro.bot/cli"));
+        content.includes("CurrentVersion/node_modules/@ouro.bot/cli") ||
+        content.includes(".ouro-cli/bin/ouro-launcher.js"));
 }
 function canRepairShadowedLauncher(shadowPath, existsSync, readFileSync, realpathSync) {
     if (!existsSync(shadowPath))
@@ -236,6 +239,7 @@ function installOuroCommand(deps = {}) {
     const realpathSync = deps.realpathSync ?? fs.realpathSync;
     const lstatSync = deps.lstatSync ?? fs.lstatSync;
     const unlinkSync = deps.unlinkSync ?? fs.unlinkSync;
+    const renameSync = deps.renameSync ?? fs.renameSync;
     const envPath = deps.envPath ?? process.env.PATH ?? "";
     const shell = deps.shell ?? process.env.SHELL;
     /* v8 ignore stop */
@@ -254,9 +258,11 @@ function installOuroCommand(deps = {}) {
     }
     const binDir = path.join(homeDir, ".ouro-cli", "bin");
     const scriptPath = path.join(binDir, "ouro");
+    const recoveryLauncherPath = path.join(binDir, "ouro-launcher.js");
     const oldScriptPath = path.join(homeDir, ".local", "bin", "ouro");
     const resolvePath = () => diagnoseOuroPath({ homeDir, envPath, existsSync, readFileSync });
-    const modernCurrent = isWrapperCurrent(scriptPath, existsSync, readFileSync);
+    const modernCurrent = isWrapperCurrent(scriptPath, existsSync, readFileSync)
+        && isRecoveryLauncherCurrent(recoveryLauncherPath, existsSync, readFileSync);
     const oldExists = existsSync(oldScriptPath);
     const oldCurrent = oldExists && isWrapperCurrent(oldScriptPath, existsSync, readFileSync);
     // ── Repair old ~/.local/bin/ouro launcher ──
@@ -332,7 +338,7 @@ function installOuroCommand(deps = {}) {
     });
     try {
         if (!modernCurrent) {
-            writeWrapperScript(scriptPath, mkdirSync, writeFileSync, chmodSync);
+            writeWrapperScript(scriptPath, mkdirSync, writeFileSync, chmodSync, renameSync, existsSync, readFileSync);
         }
     }
     catch (error) {

package/dist/heart/versioning/ouro-recovery-launcher.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OURO_WRAPPER_SCRIPT = exports.OURO_RECOVERY_LAUNCHER_SCRIPT = void 0;
+exports.resolveOuroRecoveryLauncherAssets = resolveOuroRecoveryLauncherAssets;
+const runtime_1 = require("../../nerves/runtime");
+exports.OURO_RECOVERY_LAUNCHER_SCRIPT = `#!/usr/bin/env node
+"use strict";
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const cp = require("child_process");
+const home = path.join(os.homedir(), ".ouro-cli");
+const current = path.join(home, "CurrentVersion");
+const intentPath = path.join(home, "version-intent.json");
+const entryRel = "node_modules/@ouro.bot/cli/dist/heart/daemon/ouro-entry.js";
+let intent = null;
+try {
+  intent = JSON.parse(fs.readFileSync(intentPath, "utf8"));
+  if (intent.schemaVersion !== 1 || !["pinned", "latest"].includes(intent.mode) || !intent.targetVersion) throw new Error("invalid fields");
+} catch (error) {
+  if (error && error.code !== "ENOENT") {
+    process.stderr.write("invalid Ouro version intent: " + error.message + "\\n");
+    process.exit(1);
+  }
+}
+if (intent) {
+  const target = path.join(home, "versions", intent.targetVersion);
+  const targetEntry = path.join(target, entryRel);
+  if (!fs.existsSync(targetEntry)) {
+    process.stderr.write("Ouro version intent target is not installed: " + intent.targetVersion + "\\n");
+    process.exit(1);
+  }
+  let active = null;
+  try { active = path.basename(fs.readlinkSync(current)); } catch {}
+  if (active !== intent.targetVersion) {
+    const next = current + ".next-" + process.pid;
+    try { fs.unlinkSync(next); } catch {}
+    fs.symlinkSync(target, next);
+    fs.renameSync(next, current);
+  }
+}
+const entry = path.join(current, entryRel);
+if (!fs.existsSync(entry)) {
+  process.stderr.write("ouro not installed. Run: npx ouro.bot@latest\\n");
+  process.exit(1);
+}
+const result = cp.spawnSync(process.execPath, [entry, ...process.argv.slice(2)], { stdio: "inherit" });
+if (result.error) throw result.error;
+if (result.signal) process.kill(process.pid, result.signal);
+process.exit(result.status == null ? 1 : result.status);
+`;
+exports.OURO_WRAPPER_SCRIPT = `#!/bin/sh
+# Check for dev mode — if dev-config.json exists, dispatch to the dev repo.
+# Skip dev dispatch for "up" command (explicitly returns to production).
+DEV_CONFIG="$HOME/.ouro-cli/dev-config.json"
+if [ -f "$DEV_CONFIG" ] && [ "$1" != "up" ]; then
+  DEV_REPO=$(node -e "try{console.log(JSON.parse(require('fs').readFileSync('$DEV_CONFIG','utf-8')).repoPath)}catch{}" 2>/dev/null)
+  DEV_ENTRY="$DEV_REPO/dist/heart/daemon/ouro-entry.js"
+  if [ -n "$DEV_REPO" ] && [ -e "$DEV_ENTRY" ]; then
+    exec node "$DEV_ENTRY" "$@"
+  fi
+fi
+exec node "$HOME/.ouro-cli/bin/ouro-launcher.js" "$@"
+`;
+function resolveOuroRecoveryLauncherAssets() {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.ouro_recovery_launcher_assets_resolved",
+        message: "resolved stable CLI recovery launcher assets",
+        meta: { launcher: "ouro-launcher.js", wrapper: "ouro" },
+    });
+    return {
+        launcherScript: exports.OURO_RECOVERY_LAUNCHER_SCRIPT,
+        wrapperScript: exports.OURO_WRAPPER_SCRIPT,
+    };
+}

package/dist/heart/versioning/version-intent.js

@@ -0,0 +1,114 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.versionIntentPath = versionIntentPath;
+exports.readVersionIntent = readVersionIntent;
+exports.writeVersionIntent = writeVersionIntent;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+function versionIntentPath(homeDir = os.homedir()) {
+    return path.join(homeDir, ".ouro-cli", "version-intent.json");
+}
+function parseVersionIntent(raw) {
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        throw new Error("invalid version intent: malformed JSON");
+    }
+    if (!value
+        || typeof value !== "object"
+        || value.schemaVersion !== 1
+        || !["pinned", "latest"].includes(String(value.mode))
+        || typeof value.targetVersion !== "string"
+        || !value.targetVersion) {
+        throw new Error("invalid version intent: expected schemaVersion=1, mode, and targetVersion");
+    }
+    return value;
+}
+function readVersionIntent(deps = {}) {
+    const readFileSync = deps.readFileSync ?? fs.readFileSync;
+    try {
+        return parseVersionIntent(readFileSync(versionIntentPath(deps.homeDir), "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+function writeVersionIntent(intent, deps = {}) {
+    const mkdirSync = deps.mkdirSync ?? fs.mkdirSync;
+    const writeFileSync = deps.writeFileSync ?? fs.writeFileSync;
+    const renameSync = deps.renameSync ?? fs.renameSync;
+    const unlinkSync = deps.unlinkSync ?? fs.unlinkSync;
+    const randomUUID = deps.randomUUID ?? (() => `${process.pid}-${Date.now()}`);
+    const destination = versionIntentPath(deps.homeDir);
+    const temporary = `${destination}.${randomUUID()}.tmp`;
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.version_intent_write_start",
+        message: "writing CLI version intent",
+        meta: { mode: intent.mode, targetVersion: intent.targetVersion },
+    });
+    try {
+        mkdirSync(path.dirname(destination), { recursive: true });
+        writeFileSync(temporary, `${JSON.stringify(intent, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+        renameSync(temporary, destination);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.version_intent_write_end",
+            message: "CLI version intent written",
+            meta: { mode: intent.mode, targetVersion: intent.targetVersion },
+        });
+    }
+    catch (error) {
+        try {
+            unlinkSync(temporary);
+        }
+        catch { /* best-effort temporary cleanup */ }
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.version_intent_write_error",
+            level: "error",
+            message: "failed to write CLI version intent",
+            meta: { mode: intent.mode, targetVersion: intent.targetVersion, error: error instanceof Error ? error.message : String(error) },
+        });
+        throw error;
+    }
+}

package/dist/mind/prompt-budget.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROMPT_BUDGET_FALLBACK_CONTEXT_WINDOW_TOKENS = exports.PROMPT_BUDGET_POLICY_VERSION = void 0;
 exports.estimatePromptBudgetTokensForMessage = estimatePromptBudgetTokensForMessage;
 exports.estimatePromptBudgetTokens = estimatePromptBudgetTokens;
+exports.assessRequiredPromptEvidenceBudget = assessRequiredPromptEvidenceBudget;
 exports.applyPromptBudget = applyPromptBudget;
 const runtime_1 = require("../nerves/runtime");
 exports.PROMPT_BUDGET_POLICY_VERSION = "prompt-budget/v1";
@@ -89,6 +90,42 @@ function itemTokens(item) {
 function cloneMessage(message) {
     return { ...message };
 }
+function requiredMessagesByIdentity(input) {
+    const evidence = input.requiredPromptEvidence;
+    if (!evidence)
+        return [];
+    const current = evidence.currentUserMessage;
+    if (current.role !== "user") {
+        throw new Error("required current user message must have role=user");
+    }
+    const currentMatches = input.messages.filter((message) => message === current);
+    if (currentMatches.length !== 1) {
+        throw new Error(currentMatches.length === 0
+            ? "required current user message is not present by identity"
+            : "required current user message must appear exactly once by identity");
+    }
+    const predecessor = evidence.verifiedPredecessorMessage;
+    if (predecessor) {
+        if (predecessor === current)
+            throw new Error("required predecessor and current user message must be distinct objects");
+        if (predecessor.role !== "system") {
+            throw new Error("required verified predecessor message must have role=system");
+        }
+        const predecessorMatches = input.messages.filter((message) => message === predecessor);
+        if (predecessorMatches.length !== 1) {
+            throw new Error(predecessorMatches.length === 0
+                ? "required verified predecessor message is not present by identity"
+                : "required verified predecessor message must appear exactly once by identity");
+        }
+        if (input.messages.indexOf(predecessor) !== input.messages.indexOf(current) - 1) {
+            throw new Error("required verified predecessor message must be immediately before the current user message");
+        }
+    }
+    return input.messages.filter((message) => message === current || message === predecessor);
+}
+function cloneUnlessRequired(message, requiredMessages) {
+    return requiredMessages.has(message) ? message : cloneMessage(message);
+}
 function messageText(message) {
     return typeof message.content === "string" ? message.content : "";
 }
@@ -197,11 +234,35 @@ function nonSystemSourceFor(messages) {
         return "diagnostics";
     return "recent-session-tail";
 }
-function buildPromptBudgetItems(messages) {
+function buildPromptBudgetItems(messages, requiredPromptEvidence) {
     const rawItems = [];
     let index = 0;
     while (index < messages.length) {
         const message = messages[index];
+        if (message === requiredPromptEvidence?.currentUserMessage) {
+            rawItems.push({
+                id: `required:${index}:current`,
+                priority: 1,
+                source: "current-user-message",
+                messages: [message],
+                originalMessageCount: 1,
+                required: "current-user",
+            });
+            index += 1;
+            continue;
+        }
+        if (message === requiredPromptEvidence?.verifiedPredecessorMessage) {
+            rawItems.push({
+                id: `required:${index}:predecessor`,
+                priority: 1,
+                source: "required-current-turn-state",
+                messages: [message],
+                originalMessageCount: 1,
+                required: "verified-predecessor",
+            });
+            index += 1;
+            continue;
+        }
         if (message.role === "system") {
             rawItems.push(...systemItems(message, index));
             index += 1;
@@ -236,6 +297,8 @@ function buildPromptBudgetItems(messages) {
     const lastUserItemIndex = rawItems.findLastIndex((item) => item.messages.some((message) => message.role === "user"));
     const latestToolItemIndex = rawItems.findLastIndex((item) => item.messages.some((message) => message.role === "tool" || assistantHasToolCalls(message)));
     return rawItems.map((item, itemIndex) => {
+        if (item.required)
+            return item;
         if (itemIndex === lastUserItemIndex) {
             return { ...item, priority: 1, source: "current-user-message" };
         }
@@ -254,7 +317,7 @@ function buildPromptBudgetItems(messages) {
     });
 }
 function flattenItems(items) {
-    return items.flatMap((item) => item.messages.map(cloneMessage));
+    return items.flatMap((item) => item.messages.map((message) => item.required ? message : cloneMessage(message)));
 }
 function budgetFor(input) {
     const contextWindowTokens = typeof input.contextWindowTokens === "number" && Number.isFinite(input.contextWindowTokens) && input.contextWindowTokens > 0
@@ -273,6 +336,19 @@ function budgetFor(input) {
         inputTokenLimit: Math.max(0, contextWindowTokens - outputReserveTokens - protocolReserveTokens),
     };
 }
+function assessRequiredPromptEvidenceBudget(input) {
+    const budget = budgetFor(input);
+    const messages = requiredMessagesByIdentity(input);
+    const estimatedTokens = estimatePromptBudgetTokens(messages);
+    return {
+        status: messages.length > 0 && estimatedTokens > budget.inputTokenLimit
+            ? "required_evidence_over_budget"
+            : "within_budget",
+        messages,
+        estimatedTokens,
+        budget,
+    };
+}
 function totalItemTokens(items) {
     return estimatePromptBudgetTokens(flattenItems(items));
 }
@@ -304,15 +380,38 @@ function emitPromptBudgetEvent(result) {
     });
 }
 function applyPromptBudget(input) {
-    const budget = budgetFor(input);
+    const requiredAssessment = assessRequiredPromptEvidenceBudget(input);
+    const budget = requiredAssessment.budget;
     const estimatedBeforeTokens = estimatePromptBudgetTokens(input.messages);
     const truncations = [];
+    const requiredMessages = requiredAssessment.messages;
+    const requiredMessageSet = new Set(requiredMessages);
     let droppedMessages = 0;
+    const requiredTokens = requiredAssessment.estimatedTokens;
+    if (requiredAssessment.status === "required_evidence_over_budget") {
+        droppedMessages = input.messages.length - requiredMessages.length;
+        const result = {
+            policyVersion: exports.PROMPT_BUDGET_POLICY_VERSION,
+            status: "required_evidence_over_budget",
+            messages: requiredMessages,
+            budget,
+            stats: {
+                estimatedBeforeTokens,
+                estimatedAfterTokens: requiredTokens,
+                originalMessages: input.messages.length,
+                finalMessages: requiredMessages.length,
+                droppedMessages,
+                truncations,
+            },
+        };
+        emitPromptBudgetEvent(result);
+        return result;
+    }
     if (estimatedBeforeTokens <= budget.inputTokenLimit) {
         const result = {
             policyVersion: exports.PROMPT_BUDGET_POLICY_VERSION,
             status: "within_budget",
-            messages: input.messages.map(cloneMessage),
+            messages: input.messages.map((message) => cloneUnlessRequired(message, requiredMessageSet)),
             budget,
             stats: {
                 estimatedBeforeTokens,
@@ -326,7 +425,7 @@ function applyPromptBudget(input) {
         emitPromptBudgetEvent(result);
         return result;
     }
-    let items = buildPromptBudgetItems(input.messages);
+    let items = buildPromptBudgetItems(input.messages, input.requiredPromptEvidence);
     for (const priority of [8, 7, 6, 5, 4, 3]) {
         if (totalItemTokens(items) <= budget.inputTokenLimit)
             break;

package/dist/repertoire/tools.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.surfaceToolDef = exports.speakTool = exports.restTool = exports.ponderTool = exports.observeTool = exports.settleTool = exports.tools = void 0;
 exports.resetMcpDefinitions = resetMcpDefinitions;
 exports.getToolsForChannel = getToolsForChannel;
-exports.getRestrictedReactionFeedbackTools = getRestrictedReactionFeedbackTools;
 exports.resolveToolDefinition = resolveToolDefinition;
 exports.shellRiskProfile = shellRiskProfile;
 exports.riskProfileForTool = riskProfileForTool;
@@ -127,15 +126,6 @@ function getToolsForChannel(capabilities, toolPreferences, _context, providerCap
     }
     return filterByCapability(result, providerCapabilities);
 }
-/**
- * The complete provider-facing tool surface for trusted reaction feedback.
- * Keep these schemas sourced from the normal registry so restricted turns
- * cannot drift onto lookalike definitions or inherit channel/MCP tools.
- */
-function getRestrictedReactionFeedbackTools() {
-    const orientationGetTool = tools_base_1.baseToolDefinitions.find((definition) => definition.tool.function.name === "orientation_get").tool;
-    return [tools_base_1.settleTool, tools_base_1.observeTool, orientationGetTool];
-}
 // Look up a tool definition from the live combined registry (native + MCP).
 // The base registry is intentionally consulted at call time so tests and
 // runtime extensions cannot leave execution metadata behind a stale snapshot.