@ouro.bot/cli 0.1.0-alpha.62 → 0.1.0-alpha.636

package/dist/repertoire/plugins.js

@@ -0,0 +1,253 @@
+"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.getPluginsRoot = getPluginsRoot;
+exports.getPluginDir = getPluginDir;
+exports.getPluginSkillsDir = getPluginSkillsDir;
+exports.listPlugins = listPlugins;
+exports.listEnabledPlugins = listEnabledPlugins;
+exports.listPluginSkills = listPluginSkills;
+exports.loadPluginSkill = loadPluginSkill;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const identity_1 = require("../heart/identity");
+const ouro_version_manager_1 = require("../heart/versioning/ouro-version-manager");
+const runtime_1 = require("../nerves/runtime");
+/**
+ * Plugin support for ouroboros (W5.2 of the worker-generalization extraction).
+ *
+ * Plugins are installed machine-locally at `~/.ouro-cli/plugins/<plugin-id>/`
+ * via `ouro plugin install` (W5.3). Each agent's bundle declares which plugins
+ * it has enabled via the `plugins[]` field in agent.json (W5.1).
+ *
+ * This module exposes the loader half: list installed plugins, list the skills
+ * a plugin provides, and load a specific plugin skill's body. Mirrors
+ * `src/repertoire/skills.ts` priority-chain pattern.
+ *
+ * Integration with prompt assembly (W5.4): `listPluginSkills(enabledPlugins)`
+ * is called from `src/mind/prompt.ts` alongside `listSkills()` so plugin
+ * skills appear in the agent's skill index via the same `load_skill` tool.
+ */
+/** ~/.ouro-cli/plugins/ — machine-scoped plugin install root. */
+function getPluginsRoot(homeDir) {
+    return path.join((0, ouro_version_manager_1.getOuroCliHome)(homeDir), "plugins");
+}
+/** ~/.ouro-cli/plugins/<plugin-id>/ — install dir for a specific plugin. */
+function getPluginDir(pluginId, homeDir) {
+    return path.join(getPluginsRoot(homeDir), pluginId);
+}
+/** ~/.ouro-cli/plugins/<plugin-id>/skills/ — the plugin's skill directory. */
+function getPluginSkillsDir(pluginId, homeDir) {
+    return path.join(getPluginDir(pluginId, homeDir), "skills");
+}
+function listSkillDirNames(dir) {
+    // Industry-standard plugin skill layout: each skill is a directory under
+    // `skills/`, containing a `SKILL.md` (Claude Code + Copilot CLI convention;
+    // SKILL.md is the cross-vendor "agent skill" format with YAML frontmatter +
+    // markdown body). Older flat-file layouts (`skills/<name>.md`) are not part
+    // of the spec and not supported.
+    if (!fs.existsSync(dir))
+        return [];
+    return fs
+        .readdirSync(dir)
+        .filter((name) => {
+        const candidate = path.join(dir, name);
+        try {
+            if (!fs.statSync(candidate).isDirectory())
+                return false;
+            return fs.existsSync(path.join(candidate, "SKILL.md"));
+        }
+        catch {
+            return false;
+        }
+    })
+        .sort();
+}
+/**
+ * List installed plugins under ~/.ouro-cli/plugins/.
+ *
+ * Returns plugin IDs — directory names under the plugins root. Does NOT
+ * filter by enabled-for-this-agent; that's `listEnabledPlugins()`'s job.
+ */
+function listPlugins(homeDir) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "plugins.list_start",
+        component: "repertoire",
+        message: "listing installed plugins",
+        meta: { operation: "listPlugins" },
+    });
+    const root = getPluginsRoot(homeDir);
+    if (!fs.existsSync(root)) {
+        (0, runtime_1.emitNervesEvent)({
+            event: "plugins.list_end",
+            component: "repertoire",
+            message: "no plugins root yet",
+            meta: { operation: "listPlugins", count: 0, root },
+        });
+        return [];
+    }
+    const plugins = fs
+        .readdirSync(root)
+        .filter((name) => {
+        const fullPath = path.join(root, name);
+        try {
+            return fs.statSync(fullPath).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    })
+        .sort();
+    (0, runtime_1.emitNervesEvent)({
+        event: "plugins.list_end",
+        component: "repertoire",
+        message: "listed installed plugins",
+        meta: { operation: "listPlugins", count: plugins.length },
+    });
+    return plugins;
+}
+/**
+ * List plugins this agent has enabled via agent.json `plugins[]`.
+ *
+ * Reads the agent config + filters to entries with `enabled: true` whose
+ * plugin directory actually exists under ~/.ouro-cli/plugins/. Returns
+ * the matched PluginConfig entries (not just IDs) so callers have access
+ * to source + version metadata.
+ */
+function listEnabledPlugins(homeDir) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "plugins.list_enabled_start",
+        component: "repertoire",
+        message: "listing enabled plugins for agent",
+        meta: { operation: "listEnabledPlugins" },
+    });
+    const config = (0, identity_1.loadAgentConfig)();
+    const declared = config.plugins ?? [];
+    const installed = new Set(listPlugins(homeDir));
+    const enabled = declared.filter((p) => p.enabled && installed.has(p.id));
+    (0, runtime_1.emitNervesEvent)({
+        event: "plugins.list_enabled_end",
+        component: "repertoire",
+        message: "filtered to enabled + installed plugins",
+        meta: {
+            operation: "listEnabledPlugins",
+            declared: declared.length,
+            enabled: enabled.length,
+        },
+    });
+    return enabled;
+}
+/**
+ * List skill names provided by the given enabled plugins.
+ *
+ * Walks each plugin's `skills/` directory using the industry-standard
+ * directory-per-skill layout (`skills/<name>/SKILL.md`). The SKILL.md
+ * convention is shared across Claude Code and Copilot CLI.
+ *
+ * Returns a deduplicated sorted list across all plugins. If two plugins
+ * declare a skill with the same name, the later-sorted plugin's skill wins
+ * (Set dedupe by name; callers concerned with collision can call this per
+ * plugin instead).
+ */
+function listPluginSkills(enabledPlugins, homeDir) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "plugins.list_skills_start",
+        component: "repertoire",
+        message: "listing skills across enabled plugins",
+        meta: { operation: "listPluginSkills", pluginCount: enabledPlugins.length },
+    });
+    const all = [];
+    for (const plugin of enabledPlugins) {
+        const skillsDir = getPluginSkillsDir(plugin.id, homeDir);
+        const skills = listSkillDirNames(skillsDir);
+        all.push(...skills);
+    }
+    const deduped = [...new Set(all)].sort();
+    (0, runtime_1.emitNervesEvent)({
+        event: "plugins.list_skills_end",
+        component: "repertoire",
+        message: "listed plugin skills",
+        meta: {
+            operation: "listPluginSkills",
+            pluginCount: enabledPlugins.length,
+            skillCount: deduped.length,
+        },
+    });
+    return deduped;
+}
+/**
+ * Load the body of a specific skill from a specific plugin.
+ *
+ * Resolves the industry-standard directory-per-skill layout:
+ * `skills/<skillName>/SKILL.md`. Throws if not found.
+ */
+function loadPluginSkill(pluginId, skillName, homeDir) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "plugins.load_skill_start",
+        component: "repertoire",
+        message: "loading plugin skill",
+        meta: { operation: "loadPluginSkill", plugin: pluginId, skill: skillName },
+    });
+    const skillsDir = getPluginSkillsDir(pluginId, homeDir);
+    const skillPath = path.join(skillsDir, skillName, "SKILL.md");
+    if (!fs.existsSync(skillPath)) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "plugins.load_skill_error",
+            component: "repertoire",
+            message: "plugin skill not found",
+            meta: {
+                operation: "loadPluginSkill",
+                plugin: pluginId,
+                skill: skillName,
+                checkedPath: skillPath,
+            },
+        });
+        throw new Error(`plugin skill '${pluginId}:${skillName}' not found at ${skillPath}`);
+    }
+    const content = fs.readFileSync(skillPath, "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        event: "plugins.load_skill_end",
+        component: "repertoire",
+        message: "loaded plugin skill",
+        meta: {
+            operation: "loadPluginSkill",
+            plugin: pluginId,
+            skill: skillName,
+            path: skillPath,
+        },
+    });
+    return content;
+}

package/dist/repertoire/shell-sessions.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spawnBackgroundShell = spawnBackgroundShell;
+exports.getShellSession = getShellSession;
+exports.listShellSessions = listShellSessions;
+exports.tailShellSession = tailShellSession;
+exports.resetShellSessions = resetShellSessions;
+exports.detectDestructivePatterns = detectDestructivePatterns;
+const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
+const runtime_1 = require("../nerves/runtime");
+const sessions = new Map();
+const MAX_OUTPUT_LINES = 200;
+function spawnBackgroundShell(command) {
+    const id = (0, crypto_1.randomUUID)();
+    const proc = (0, child_process_1.spawn)("sh", ["-c", command], {
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    const session = {
+        process: proc,
+        info: {
+            id,
+            command,
+            status: "running",
+            exitCode: null,
+            pid: proc.pid,
+            startedAt: Date.now(),
+            output: [],
+        },
+    };
+    const appendOutput = (data) => {
+        const lines = data.toString().split("\n");
+        for (const line of lines) {
+            if (line.length > 0 || session.info.output.length > 0) {
+                session.info.output.push(line);
+            }
+        }
+        // Keep only the last MAX_OUTPUT_LINES
+        if (session.info.output.length > MAX_OUTPUT_LINES) {
+            session.info.output = session.info.output.slice(-MAX_OUTPUT_LINES);
+        }
+    };
+    proc.stdout?.on("data", appendOutput);
+    proc.stderr?.on("data", appendOutput);
+    proc.on("close", (code) => {
+        session.info.status = "exited";
+        session.info.exitCode = code;
+        (0, runtime_1.emitNervesEvent)({
+            component: "repertoire",
+            event: "repertoire.shell.process_exit",
+            message: "background shell process exited",
+            meta: { id, command, exitCode: code, pid: proc.pid },
+        });
+    });
+    sessions.set(id, session);
+    (0, runtime_1.emitNervesEvent)({
+        component: "repertoire",
+        event: "repertoire.shell.spawn",
+        message: "spawned background shell session",
+        meta: { id, command, pid: proc.pid },
+    });
+    return { ...session.info };
+}
+function getShellSession(id) {
+    const session = sessions.get(id);
+    if (!session)
+        return undefined;
+    (0, runtime_1.emitNervesEvent)({
+        component: "repertoire",
+        event: "repertoire.shell.status_check",
+        message: "checked shell session status",
+        meta: { id, status: session.info.status, exitCode: session.info.exitCode },
+    });
+    return { ...session.info };
+}
+function listShellSessions() {
+    return Array.from(sessions.values()).map((s) => ({
+        id: s.info.id,
+        command: s.info.command,
+        status: s.info.status,
+        exitCode: s.info.exitCode,
+        pid: s.info.pid,
+        startedAt: s.info.startedAt,
+        output: [], // Don't include full output in listing
+    }));
+}
+function tailShellSession(id, lines = 50) {
+    const session = sessions.get(id);
+    if (!session)
+        return undefined;
+    const tail = session.info.output.slice(-lines);
+    (0, runtime_1.emitNervesEvent)({
+        component: "repertoire",
+        event: "repertoire.shell.tail",
+        message: "tailed shell session output",
+        meta: { id, requestedLines: lines, returnedLines: tail.length },
+    });
+    return tail.join("\n");
+}
+/** Reset all sessions (for testing) */
+function resetShellSessions() {
+    for (const session of sessions.values()) {
+        if (session.info.status === "running") {
+            session.process.kill();
+        }
+    }
+    sessions.clear();
+}
+const DESTRUCTIVE_PATTERNS = [
+    { name: "rm -rf root/home", regex: /rm\s+-rf\s+[/~]/ },
+    { name: "git push --force", regex: /git\s+push\s+--force/ },
+    { name: "git reset --hard", regex: /git\s+reset\s+--hard/ },
+    { name: "git clean -f", regex: /git\s+clean\s+-f/ },
+    { name: "git branch -D", regex: /git\s+branch\s+-D/ },
+    { name: "fork bomb", regex: /:\(\)\s*\{/ },
+    { name: "write to raw device", regex: />\s*\/dev\/sd/ },
+    { name: "git checkout .", regex: /git\s+checkout\s+\./ },
+    { name: "git stash drop", regex: /git\s+stash\s+drop/ },
+];
+/**
+ * Detect destructive patterns in a shell command.
+ * Returns list of matched pattern names. Empty array = safe.
+ * This is a friction layer, not a hard block.
+ */
+function detectDestructivePatterns(command) {
+    const matched = [];
+    for (const pattern of DESTRUCTIVE_PATTERNS) {
+        if (pattern.regex.test(command)) {
+            matched.push(pattern.name);
+        }
+    }
+    return matched;
+}

package/dist/repertoire/skills.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSkillsDir = getSkillsDir;
+exports.getHarnessSkillsDir = getHarnessSkillsDir;
 exports.listSkills = listSkills;
 exports.loadSkill = loadSkill;
 exports.getLoadedSkills = getLoadedSkills;
@@ -42,6 +43,7 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const identity_1 = require("../heart/identity");
 const runtime_1 = require("../nerves/runtime");
+const plugins_1 = require("./plugins");
 // Skills live in {agentRoot}/skills/ directory
 function getSkillsDir() {
     return path.join((0, identity_1.getAgentRoot)(), "skills");
@@ -50,6 +52,10 @@ function getSkillsDir() {
 function getProtocolMirrorDir() {
     return path.join(getSkillsDir(), "protocols");
 }
+// Harness-level skills live in {repoRoot}/skills/ directory.
+function getHarnessSkillsDir() {
+    return path.join((0, identity_1.getRepoRoot)(), "skills");
+}
 function listMarkdownBasenames(dir) {
     if (!fs.existsSync(dir))
         return [];
@@ -59,7 +65,7 @@ function listMarkdownBasenames(dir) {
         .map((f) => path.basename(f, ".md"))
         .sort();
 }
-// in-memory store for loaded skills
+// process-local store for loaded skills
 const loadedSkills = [];
 function listSkills() {
     (0, runtime_1.emitNervesEvent)({
@@ -70,7 +76,14 @@ function listSkills() {
     });
     const baseSkills = listMarkdownBasenames(getSkillsDir());
     const protocolMirrors = listMarkdownBasenames(getProtocolMirrorDir());
-    const skills = [...new Set([...baseSkills, ...protocolMirrors])].sort();
+    const harnessSkills = listMarkdownBasenames(getHarnessSkillsDir());
+    const pluginSkills = (0, plugins_1.listPluginSkills)((0, plugins_1.listEnabledPlugins)());
+    // Agent skills (base + protocol) come first; harness skills are fallback;
+    // plugin skills surface after harness skills. Set deduplicates by name —
+    // agent overrides harness overrides plugins.
+    const skills = [
+        ...new Set([...baseSkills, ...protocolMirrors, ...harnessSkills, ...pluginSkills]),
+    ].sort();
     (0, runtime_1.emitNervesEvent)({
         event: "repertoire.load_end",
         component: "repertoire",
@@ -88,6 +101,7 @@ function loadSkill(skillName) {
     });
     const directSkillPath = path.join(getSkillsDir(), `${skillName}.md`);
     const protocolMirrorPath = path.join(getProtocolMirrorDir(), `${skillName}.md`);
+    const harnessSkillPath = path.join(getHarnessSkillsDir(), `${skillName}.md`);
     let resolvedPath = null;
     // 1) Direct agent skill.
     if (fs.existsSync(directSkillPath)) {
@@ -97,6 +111,35 @@ function loadSkill(skillName) {
     else if (fs.existsSync(protocolMirrorPath)) {
         resolvedPath = protocolMirrorPath;
     }
+    // 3) Harness-level skill (ships with npm package).
+    else if (fs.existsSync(harnessSkillPath)) {
+        resolvedPath = harnessSkillPath;
+    }
+    // 4) Plugin skill fallback. Iterate enabled plugins; first match wins.
+    if (!resolvedPath) {
+        for (const plugin of (0, plugins_1.listEnabledPlugins)()) {
+            try {
+                const content = (0, plugins_1.loadPluginSkill)(plugin.id, skillName);
+                if (!loadedSkills.includes(skillName)) {
+                    loadedSkills.push(skillName);
+                }
+                (0, runtime_1.emitNervesEvent)({
+                    event: "repertoire.load_end",
+                    component: "repertoire",
+                    message: "loaded skill",
+                    meta: {
+                        operation: "loadSkill",
+                        skill: skillName,
+                        path: `plugin:${plugin.id}`,
+                    },
+                });
+                return content;
+            }
+            catch {
+                // try next plugin
+            }
+        }
+    }
     if (!resolvedPath) {
         (0, runtime_1.emitNervesEvent)({
             level: "error",
@@ -106,12 +149,13 @@ function loadSkill(skillName) {
             meta: {
                 operation: "loadSkill",
                 skill: skillName,
-                checkedPaths: [directSkillPath, protocolMirrorPath],
+                checkedPaths: [directSkillPath, protocolMirrorPath, harnessSkillPath],
             },
         });
         throw new Error(`skill '${skillName}' not found in:\n` +
             `- ${directSkillPath}\n` +
-            `- ${protocolMirrorPath}`);
+            `- ${protocolMirrorPath}\n` +
+            `- ${harnessSkillPath}`);
     }
     const content = fs.readFileSync(resolvedPath, "utf-8");
     if (!loadedSkills.includes(skillName)) {

package/dist/repertoire/stripe-client.js

@@ -0,0 +1,131 @@
+"use strict";
+/**
+ * Thin wrapper around the Stripe Issuing API.
+ *
+ * Initializes with a restricted API key from the agent's vault.
+ * Card numbers are NEVER included in nerves events or log output.
+ * The `getCardDetails` method exists only for internal payment flows
+ * (e.g., passing card details to Duffel) — the returned data must
+ * never escape the calling function's scope.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStripeClient = createStripeClient;
+const stripe_1 = __importDefault(require("stripe"));
+const credential_access_1 = require("./credential-access");
+const runtime_1 = require("../nerves/runtime");
+// ---------------------------------------------------------------------------
+// Implementation
+// ---------------------------------------------------------------------------
+function toCardInfo(card) {
+    return {
+        cardId: card.id,
+        last4: card.last4,
+        status: card.status,
+    };
+}
+/**
+ * Create a Stripe client initialized with a restricted key from the vault.
+ */
+async function createStripeClient() {
+    const store = (0, credential_access_1.getCredentialStore)();
+    const apiKey = await store.getRawSecret("stripe.com", "restrictedKey");
+    // StripeConstructor is a callable (not a class), cast the result
+    const stripe = (0, stripe_1.default)(apiKey);
+    return {
+        async createVirtualCard(opts) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.stripe_card_create_start",
+                message: "creating virtual card",
+                meta: { type: opts.type, currency: opts.currency },
+            });
+            const spendingControls = {
+                spending_limits: [
+                    {
+                        amount: opts.spendLimit * 100, // Stripe uses cents
+                        interval: opts.type === "single_use" ? "all_time" : "monthly",
+                    },
+                ],
+                ...(opts.merchantCategories
+                    ? { allowed_categories: opts.merchantCategories }
+                    : {}),
+            };
+            const card = await stripe.issuing.cards.create({
+                type: "virtual",
+                currency: opts.currency,
+                spending_controls: spendingControls,
+                status: "active",
+            });
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.stripe_card_create_end",
+                message: "virtual card created",
+                meta: { cardId: card.id, last4: card.last4 },
+            });
+            return toCardInfo(card);
+        },
+        async getCard(cardId) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.stripe_card_get",
+                message: "retrieving card info",
+                meta: { cardId },
+            });
+            const card = await stripe.issuing.cards.retrieve(cardId);
+            return toCardInfo(card);
+        },
+        async updateCard(cardId, updates) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.stripe_card_update",
+                message: "updating card",
+                meta: { cardId },
+            });
+            const card = await stripe.issuing.cards.update(cardId, updates);
+            return toCardInfo(card);
+        },
+        async deactivateCard(cardId) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.stripe_card_deactivate",
+                message: "deactivating card",
+                meta: { cardId },
+            });
+            const card = await stripe.issuing.cards.update(cardId, { status: "canceled" });
+            return toCardInfo(card);
+        },
+        async listCards() {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.stripe_cards_list",
+                message: "listing cards",
+                meta: {},
+            });
+            const result = await stripe.issuing.cards.list();
+            return result.data.map(toCardInfo);
+        },
+        async getCardDetails(cardId) {
+            // This method retrieves sensitive card details for payment flows.
+            // The data must NEVER be logged, emitted, or returned to the model.
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.stripe_card_details_get",
+                message: "retrieving card details for payment flow",
+                meta: { cardId },
+            });
+            const card = await stripe.issuing.cards.retrieve(cardId, {
+                expand: ["number", "cvc"],
+            });
+            return {
+                cardId: card.id,
+                number: card.number,
+                cvc: card.cvc,
+                expMonth: card.exp_month,
+                expYear: card.exp_year,
+            };
+        },
+    };
+}

package/dist/repertoire/tool-results.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.okToolResult = okToolResult;
+exports.frictionToolResult = frictionToolResult;
+const runtime_1 = require("../nerves/runtime");
+function okToolResult(tool, data) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "tools",
+        event: "tool.structured_ok",
+        message: "tool returned structured result",
+        meta: { tool },
+    });
+    return JSON.stringify({ ok: true, tool, data }, null, 2);
+}
+function frictionToolResult(tool, friction) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "tools",
+        event: "tool.structured_friction",
+        message: "tool returned structured result",
+        meta: {
+            tool,
+            kind: friction.kind,
+            recoverability: friction.recoverability,
+            signature: friction.signature,
+        },
+    });
+    return JSON.stringify({ ok: false, tool, friction }, null, 2);
+}