@ouro.bot/cli 0.1.0-alpha.897 → 0.1.0-alpha.898

package/changelog.json

@@ -1,6 +1,13 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.898",
+      "changes": [
+        "Shepherd now also runs on Herdr. A return is a pane leaving 'working' for 'idle', 'done' or 'blocked' in Herdr's own pane.agent_status_changed events and still there after a 3-second grace period, keyed by Herdr's state_change_seq. Replies go through agent.prompt (pasted, then Enter) and pane.send_keys, and Shepherd's status shows as the pane's state label. Attach it with a 'herdr' record in the machine runtime config (optional herdr.socketPath, default ~/.config/herdr/herdr.sock); cmux wins when both are set. Herdr's states do not say whether background work is running, so on Herdr the judge decides 'working' from the screen.",
+        "Review fixes: Shepherd reads only Herdr's visible screen (reading scrollback scrolled the agent's UI), presses keys with agent.send_keys, ignores a passing 'unknown' state, rebuilds its state from pane.list on every new subscription (so a pane that stopped while unsubscribed is still a return), follows a pane that moved to a new id, and never types into the focused pane. The repair hint now names the Herdr record too."
+      ]
+    },
     {
       "version": "0.1.0-alpha.897",
       "changes": [

package/deploy/unraid/sanctuary.ouro/bundle-meta.json

@@ -1,5 +1,5 @@
 {
-  "runtimeVersion": "0.1.0-alpha.897",
+  "runtimeVersion": "0.1.0-alpha.898",
   "bundleSchemaVersion": 3,
   "lastUpdated": "2026-09-03T00:00:00.000Z"
 }

package/deploy/unraid/sanctuary.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0"?>
 <Container version="2">
   <Name>ouro-butler</Name>
-  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.897</Repository>
+  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.898</Repository>
   <Registry>https://github.com/ourostack/ouroboros/pkgs/container/ouroboros-butler</Registry>
   <Network>host</Network>
   <Shell>sh</Shell>

package/dist/heart/shepherd-config.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.shepherdRepairHint = shepherdRepairHint;
 exports.shepherdConfigFacts = shepherdConfigFacts;
 exports.shepherdSenseStatus = shepherdSenseStatus;
+exports.defaultHerdrSocketPath = defaultHerdrSocketPath;
 exports.defaultCmuxSocketPath = defaultCmuxSocketPath;
 exports.resolveShepherdConnection = resolveShepherdConnection;
 const fs = __importStar(require("node:fs"));
@@ -43,7 +44,7 @@ const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const runtime_1 = require("../nerves/runtime");
 function shepherdRepairHint(agent) {
-    return `human-required: in a cmux terminal run 'ouro vault config set --agent ${agent} --scope machine --key cmux.socketCapability --value "$CMUX_SOCKET_CAPABILITY"' (or set cmux.socketPassword when cmux is in password mode), then 'ouro up'.`;
+    return `human-required: in a cmux terminal run 'ouro vault config set --agent ${agent} --scope machine --key cmux.socketCapability --value "$CMUX_SOCKET_CAPABILITY"' (or set cmux.socketPassword when cmux is in password mode), then 'ouro up'. On Herdr instead: 'ouro vault config set --agent ${agent} --scope machine --key herdr.socketPath --value "$HOME/.config/herdr/herdr.sock"', then 'ouro up'.`;
 }
 function text(record, key) {
     const value = record?.[key];
@@ -67,6 +68,8 @@ function cmuxAuth(cmux) {
 function shepherdConfigFacts(machinePayload) {
     const cmux = hostRecord(machinePayload, "cmux");
     const auth = cmuxAuth(cmux);
+    if (!auth && hostRecord(machinePayload, "herdr"))
+        return { configured: true, detail: "herdr socket" };
     if (!auth)
         return cmux ? { configured: false, detail: "missing cmux.socketCapability" } : { configured: false, optional: true, detail: "no terminal host attached on this machine" };
     return { configured: true, detail: `cmux socket auth: ${auth.kind === "none" ? "automation mode" : auth.kind}` };
@@ -80,6 +83,10 @@ function shepherdSenseStatus(enabled, machinePayload) {
         return "ready";
     return facts.optional ? "not_attached" : "needs_config";
 }
+/** Herdr's default session socket. */
+function defaultHerdrSocketPath(homeDir = os.homedir()) {
+    return path.join(homeDir, ".config", "herdr", "herdr.sock");
+}
 /** cmux's own default: `~/.local/state/cmux/cmux-<uid>.sock`, then the older unscoped `cmux.sock`. */
 function defaultCmuxSocketPath(homeDir = os.homedir(), uid = process.getuid?.() ?? 0, exists = fs.existsSync) {
     const dir = path.join(homeDir, ".local", "state", "cmux");
@@ -89,14 +96,18 @@ function defaultCmuxSocketPath(homeDir = os.homedir(), uid = process.getuid?.()
 }
 function resolveShepherdConnection(agent, machinePayload, defaultSocketPath = defaultCmuxSocketPath) {
     const cmux = hostRecord(machinePayload, "cmux");
+    const herdr = hostRecord(machinePayload, "herdr");
     const auth = cmuxAuth(cmux);
+    const host = auth ? "cmux" : herdr ? "herdr" : "none";
     (0, runtime_1.emitNervesEvent)({
         component: "senses",
         event: "senses.shepherd_connection_resolved",
         message: "resolved Shepherd terminal host connection settings",
-        meta: { agent, host: auth ? "cmux" : "none", auth: auth?.kind ?? "missing" },
+        meta: { agent, host, auth: auth?.kind ?? "missing" },
     });
-    if (!auth)
-        return { ok: false, error: `no terminal host is attached on this machine; ${shepherdRepairHint(agent)}` };
-    return { ok: true, connection: { host: "cmux", socketPath: text(cmux, "socketPath") || defaultSocketPath(), auth } };
+    if (auth)
+        return { ok: true, connection: { host: "cmux", socketPath: text(cmux, "socketPath") || defaultSocketPath(), auth } };
+    if (herdr)
+        return { ok: true, connection: { host: "herdr", socketPath: text(herdr, "socketPath") || defaultHerdrSocketPath() } };
+    return { ok: false, error: `no terminal host is attached on this machine; ${shepherdRepairHint(agent)}` };
 }

package/dist/repertoire/tools-shepherd.js

@@ -40,8 +40,7 @@ const path = __importStar(require("node:path"));
 const runtime_credentials_1 = require("../heart/runtime-credentials");
 const shepherd_config_1 = require("../heart/shepherd-config");
 const runtime_1 = require("../nerves/runtime");
-const client_1 = require("../senses/shepherd/client");
-const cmux_1 = require("../senses/shepherd/cmux");
+const host_1 = require("../senses/shepherd/host");
 const redact_1 = require("../senses/shepherd/redact");
 const returns_1 = require("../senses/shepherd/returns");
 /**
@@ -68,7 +67,7 @@ function shepherdToolsEnabled(agentRoot) {
 function hostFor(agentName) {
     const machine = (0, runtime_credentials_1.readMachineRuntimeCredentialConfig)(agentName);
     const resolved = (0, shepherd_config_1.resolveShepherdConnection)(agentName, machine.ok ? machine.config : {});
-    return resolved.ok ? (0, cmux_1.createCmuxHost)((0, client_1.createCmuxClient)(resolved.connection, { agentName })) : resolved.error;
+    return resolved.ok ? (0, host_1.createShepherdHost)(resolved.connection, { agentName }) : resolved.error;
 }
 async function withHost(tool, ctx, run) {
     if (!ctx?.agentName || !ctx.agentRoot)

package/dist/senses/shepherd/herdr.js

@@ -0,0 +1,311 @@
+"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.HERDR_METADATA_SOURCE = void 0;
+exports.herdrRequest = herdrRequest;
+exports.createHerdrHost = createHerdrHost;
+const net = __importStar(require("node:net"));
+const runtime_1 = require("../../nerves/runtime");
+const cmux_1 = require("./cmux");
+/**
+ * The Herdr host. Herdr detects every agent in its panes itself and publishes each change of its
+ * semantic state as `pane.agent_status_changed` (idle, working, blocked, done, unknown). A return is
+ * a pane leaving `working` for `idle`, `done` or `blocked` and still there after the grace period,
+ * keyed by Herdr's own `state_change_seq`. Herdr types a prompt with `agent.prompt` (bracketed paste
+ * then Enter) and shows Shepherd's status as the pane's state label.
+ */
+exports.HERDR_METADATA_SOURCE = "ouro.shepherd";
+const GRACE_MS = 3_000;
+const TIMEOUT_MS = 10_000;
+const RETURN_STATES = new Set(["idle", "done", "blocked"]);
+const RECONNECT_DELAYS_MS = [1_000, 2_000, 5_000, 10_000, 30_000];
+const HERDR_KEYS = { enter: "enter", escape: "esc", up: "up", down: "down", tab: "tab", 1: "1", 2: "2", 3: "3", 4: "4", 5: "5", 6: "6", 7: "7", 8: "8", 9: "9", y: "y", n: "n" };
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function str(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+/** One NDJSON connection: each line Herdr sends goes to `onLine` until the socket closes. */
+function connectLines(socketPath, onLine, onClose) {
+    const socket = net.createConnection(socketPath);
+    let buffer = "";
+    let failure;
+    socket.setEncoding("utf-8");
+    socket.on("data", (chunk) => {
+        buffer += chunk;
+        let newline = buffer.indexOf("\n");
+        while (newline >= 0) {
+            const raw = buffer.slice(0, newline);
+            buffer = buffer.slice(newline + 1);
+            newline = buffer.indexOf("\n");
+            try {
+                const parsed = JSON.parse(raw);
+                if (isRecord(parsed))
+                    onLine(parsed);
+            }
+            catch {
+                // A line that is not JSON is ignored.
+            }
+        }
+    });
+    socket.on("error", (error) => { failure = error; });
+    socket.on("close", () => onClose(failure));
+    return { send: (line) => socket.write(`${JSON.stringify(line)}\n`), close: () => socket.destroy() };
+}
+let requestCount = 0;
+/** One request on its own connection. */
+function herdrRequest(socketPath, method, params, timeoutMs = TIMEOUT_MS) {
+    return new Promise((resolve, reject) => {
+        const id = `ouro_${++requestCount}`;
+        let settled = false;
+        const settle = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            connection.close();
+            fn();
+        };
+        const timer = setTimeout(() => settle(() => reject(new Error(`herdr ${method} timed out`))), timeoutMs);
+        const connection = connectLines(socketPath, (line) => {
+            if (line.id !== id)
+                return;
+            const error = isRecord(line.error) ? line.error : null;
+            settle(() => error ? reject(new Error(`herdr ${method}: ${str(error.message) ?? str(error.code) ?? "error"}`)) : resolve(isRecord(line.result) ? line.result : {}));
+        }, (error) => settle(() => reject(new Error(`herdr ${method}: ${error?.message ?? "connection closed"}`))));
+        connection.send({ id, method, params });
+    });
+}
+function createHerdrHost(connection, options = {}) {
+    const schedule = options.schedule ?? cmux_1.realSchedule;
+    const call = (method, params) => herdrRequest(connection.socketPath, method, params);
+    async function panes() {
+        const result = await call("pane.list", {});
+        return Array.isArray(result.panes) ? result.panes.filter(isRecord) : [];
+    }
+    return {
+        name: "herdr",
+        async list() {
+            return (await panes()).map((pane) => ({
+                id: str(pane.pane_id) ?? "",
+                ref: str(pane.pane_id) ?? "",
+                workspace: str(pane.workspace_id),
+                title: str(pane.title) ?? str(pane.terminal_title_stripped) ?? str(pane.label) ?? "",
+                agent: str(pane.agent),
+                focused: pane.focused === true,
+            }));
+        },
+        async read(sessionId) {
+            // The visible screen only: reading recent scrollback makes Herdr scroll the agent's UI.
+            const result = await call("pane.read", { pane_id: sessionId, source: "visible", strip_ansi: true });
+            const read = isRecord(result.read) ? result.read : {};
+            return typeof read.text === "string" ? read.text : "";
+        },
+        async prompt(sessionId, line) {
+            // Herdr pastes the text as one block and then presses Enter; a blocked agent is refused without input.
+            await call("agent.prompt", { target: sessionId, text: line });
+            (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.shepherd_herdr_prompted", message: "typed a line into a Herdr pane", meta: { chars: line.length } });
+        },
+        async key(sessionId, key) {
+            await call("agent.send_keys", { target: sessionId, keys: [HERDR_KEYS[key]] });
+        },
+        async signal(sessionId, status, notification) {
+            await call("pane.report_metadata", status
+                ? { pane_id: sessionId, source: exports.HERDR_METADATA_SOURCE, state_labels: { idle: status, done: status, blocked: status }, tokens: { ouro: status } }
+                : { pane_id: sessionId, source: exports.HERDR_METADATA_SOURCE, clear_state_labels: true, tokens: { ouro: null } });
+            if (notification)
+                await call("notification.show", { title: notification.title, body: notification.body });
+        },
+        watch(handlers) {
+            let closed = false;
+            let attempt = 0;
+            let stream = null;
+            let cancelReconnect = null;
+            let refresh = false;
+            const status = new Map();
+            const pending = new Map();
+            const cancelPending = (paneId) => {
+                pending.get(paneId)?.();
+                pending.delete(paneId);
+            };
+            /** A return only if the pane is still out of `working` after the grace period, keyed by Herdr's own sequence. */
+            const settled = (paneId) => {
+                cancelPending(paneId);
+                pending.set(paneId, schedule(() => {
+                    pending.delete(paneId);
+                    void call("agent.get", { target: paneId }).then((result) => {
+                        const agent = isRecord(result.agent) ? result.agent : {};
+                        if (!RETURN_STATES.has(str(agent.agent_status) ?? ""))
+                            return;
+                        const seq = typeof agent.state_change_seq === "number" ? agent.state_change_seq : null;
+                        handlers.returned({
+                            sessionId: paneId,
+                            transitionId: `herdr:${paneId}:${seq ?? `t${Date.now()}`}`,
+                            agent: str(agent.agent),
+                            cwd: str(agent.foreground_cwd) ?? str(agent.cwd),
+                            lastBody: null,
+                            // Herdr's states do not say whether background work is running; the judge reads the screen.
+                            backgroundWork: null,
+                        });
+                    }, (error) => {
+                        (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.shepherd_herdr_read_error", message: "could not read a Herdr agent after it stopped", meta: { error: error.message } });
+                    });
+                }, GRACE_MS));
+            };
+            /**
+             * The cache keeps each pane's last known state; `unknown` (a passing detection gap) changes nothing, so working, unknown,
+             * idle still counts as working to idle.
+             */
+            const observed = (paneId, next) => {
+                if (next === "unknown")
+                    return;
+                const previous = status.get(paneId);
+                status.set(paneId, next);
+                if (next === "working")
+                    cancelPending(paneId);
+                else if (previous === "working" && RETURN_STATES.has(next))
+                    settled(paneId);
+            };
+            const onEvent = (line) => {
+                // Herdr names events `pane.focused` in subscriptions and `pane_focused` on the wire; both are accepted.
+                const name = (str(line.event) ?? "").replace(".", "_");
+                const data = isRecord(line.data) ? line.data : {};
+                if (name === "pane_moved") {
+                    // A moved pane can get a new id: carry its state over and subscribe again under the new id.
+                    const from = str(data.previous_pane_id);
+                    const to = isRecord(data.pane) ? str(data.pane.pane_id) : null;
+                    if (from && to && from !== to) {
+                        cancelPending(from);
+                        const known = status.get(from);
+                        status.delete(from);
+                        if (known)
+                            status.set(to, known);
+                    }
+                    refresh = true;
+                    stream?.close();
+                    return;
+                }
+                const paneId = str(data.pane_id);
+                if (!paneId)
+                    return;
+                if (name === "pane_focused")
+                    return handlers.focused(paneId);
+                if (name === "pane_created" || name === "pane_closed") {
+                    if (name === "pane_closed") {
+                        cancelPending(paneId);
+                        status.delete(paneId);
+                    }
+                    // Agent-status subscriptions name each pane, so a new or closed pane needs a new subscription.
+                    refresh = true;
+                    stream?.close();
+                    return;
+                }
+                if (name !== "pane_agent_status_changed")
+                    return;
+                observed(paneId, str(data.agent_status) ?? "unknown");
+            };
+            const reconnect = (error) => {
+                stream = null;
+                if (closed)
+                    return;
+                if (refresh) {
+                    refresh = false;
+                    return void subscribe();
+                }
+                const delay = RECONNECT_DELAYS_MS[Math.min(attempt, RECONNECT_DELAYS_MS.length - 1)];
+                attempt += 1;
+                (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.shepherd_herdr_closed", message: "Herdr event subscription closed; resubscribing", meta: { delay, error: error?.message ?? null } });
+                cancelReconnect = schedule(() => void subscribe(), delay);
+            };
+            const subscribe = async () => {
+                cancelReconnect = null;
+                let current;
+                try {
+                    current = await panes();
+                }
+                catch (error) {
+                    return reconnect(error);
+                }
+                if (closed)
+                    return;
+                // Status changes while unsubscribed are not replayed: the fresh list replaces the cache, and a pane that stopped
+                // working in the gap is handled as if its event had arrived.
+                const ids = new Set(current.flatMap((pane) => str(pane.pane_id) ?? []));
+                for (const id of [...status.keys()]) {
+                    if (ids.has(id))
+                        continue;
+                    status.delete(id);
+                    cancelPending(id);
+                }
+                for (const pane of current) {
+                    const id = str(pane.pane_id);
+                    if (!id)
+                        continue;
+                    const next = str(pane.agent_status) ?? "unknown";
+                    if (status.has(id))
+                        observed(id, next);
+                    else if (next !== "unknown")
+                        status.set(id, next);
+                }
+                const subscriptions = [
+                    { type: "pane.created" }, { type: "pane.closed" }, { type: "pane.focused" }, { type: "pane.moved" },
+                    ...current.flatMap((pane) => str(pane.pane_id) ? [{ type: "pane.agent_status_changed", pane_id: pane.pane_id }] : []),
+                ];
+                stream = connectLines(connection.socketPath, (line) => {
+                    if (isRecord(line.result) && line.result.type === "subscription_started") {
+                        attempt = 0;
+                        (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.shepherd_herdr_connected", message: "Herdr event subscription started", meta: { panes: subscriptions.length - 4 } });
+                        return;
+                    }
+                    // `events_lost` or a rejected subscription closes the connection; the reconnect reads panes again.
+                    if (line.event !== undefined)
+                        onEvent(line);
+                }, reconnect);
+                stream.send({ id: "ouro_events", method: "events.subscribe", params: { subscriptions } });
+            };
+            void subscribe();
+            return {
+                close() {
+                    closed = true;
+                    cancelReconnect?.();
+                    for (const cancel of pending.values())
+                        cancel();
+                    stream?.close();
+                },
+            };
+        },
+    };
+}

package/dist/senses/shepherd/host.js

@@ -1,2 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createShepherdHost = createShepherdHost;
+const runtime_1 = require("../../nerves/runtime");
+const client_1 = require("./client");
+const cmux_1 = require("./cmux");
+const herdr_1 = require("./herdr");
+/** The host for this machine's connection. */
+function createShepherdHost(connection, options) {
+    (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.shepherd_host_created", message: "opened the Shepherd terminal host", meta: { host: connection.host } });
+    return connection.host === "herdr"
+        ? (0, herdr_1.createHerdrHost)(connection, { schedule: options.schedule })
+        : (0, cmux_1.createCmuxHost)((0, client_1.createCmuxClient)(connection, { agentName: options.agentName }), { now: options.now, schedule: options.schedule });
+}

package/dist/senses/shepherd/sense.js

@@ -51,8 +51,8 @@ const runtime_credentials_1 = require("../../heart/runtime-credentials");
 const shepherd_config_1 = require("../../heart/shepherd-config");
 const pending_1 = require("../../mind/pending");
 const runtime_1 = require("../../nerves/runtime");
-const client_1 = require("./client");
 const cmux_1 = require("./cmux");
+const host_1 = require("./host");
 const judge_1 = require("./judge");
 const redact_1 = require("./redact");
 const returns_1 = require("./returns");
@@ -161,7 +161,7 @@ async function startShepherdSenseApp(options) {
     const resolved = (0, shepherd_config_1.resolveShepherdConnection)(agent, machine.ok ? machine.config : {});
     if (!resolved.ok)
         throw new Error(resolved.error);
-    const host = (options.createHost ?? ((connection) => (0, cmux_1.createCmuxHost)((0, client_1.createCmuxClient)(connection, { agentName: agent }), { now, schedule })))(resolved.connection);
+    const host = (options.createHost ?? ((connection) => (0, host_1.createShepherdHost)(connection, { agentName: agent, now, schedule })))(resolved.connection);
     const judge = options.judge ?? (0, judge_1.createShepherdJudge)(() => (0, core_1.getProviderRuntime)("agent", { agentName: agent, agentRoot }), exports.JUDGE_TIMEOUT_MS);
     const escalate = options.escalate ?? ((content) => queueEscalation(agent, content, now()));
     const wake = options.wake ?? ((ids) => wakeForEscalations(agent, ids));

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.897",
+  "version": "0.1.0-alpha.898",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@ouro.bot/cli",
-      "version": "0.1.0-alpha.897",
+      "version": "0.1.0-alpha.898",
       "dependencies": {
         "@anthropic-ai/sdk": "^0.78.0",
         "@azure/identity": "^4.13.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.897",
+  "version": "0.1.0-alpha.898",
   "engines": {
     "node": ">=22"
   },