@ouro.bot/cli 0.1.0-alpha.864 → 0.1.0-alpha.866

package/dist/a2a/replay-harness.js

@@ -0,0 +1,147 @@
+"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.REPLAY_WINDOW_MAX_MS = void 0;
+exports.replayWindowPath = replayWindowPath;
+exports.replaySinkPath = replaySinkPath;
+exports.isReplayWindowOpen = isReplayWindowOpen;
+exports.appendReplayNotice = appendReplayNotice;
+exports.replayNoticeRecorded = replayNoticeRecorded;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+/**
+ * The replay gate drives the Butler over its real A2A path to check its behaviour after an upgrade. Every delegated
+ * command and every A2A-filed await would otherwise post to the owner's Telegram chat. While the host's gate holds a
+ * replay window open for a peer, those notices are appended to a local sink instead.
+ *
+ * The window narrows where a notice goes, never whether a command is authorized: the grant, family trust, sole owner
+ * and notify-before-run checks are unchanged, and "notify" means "the sink write succeeded". The window file lives
+ * under the bundle's state directory, is written by the host's gate and cleared when its run ends, and every entry
+ * expires on its own (and is ignored if it claims to last longer than the cap).
+ */
+exports.REPLAY_WINDOW_MAX_MS = 2 * 60 * 60 * 1000;
+function replayDir(agentRoot) {
+    return path.join(agentRoot, "state", "replay");
+}
+function replayWindowPath(agentRoot) {
+    return path.join(replayDir(agentRoot), "window.json");
+}
+function replaySinkPath(agentRoot) {
+    return path.join(replayDir(agentRoot), "notices.ndjson");
+}
+/** A root-controlled directory: a real directory (no symlink), owned by the trusted uid, writable by neither group nor other. */
+function isTrustedDirectory(target, trustedUid) {
+    try {
+        const stat = fs.lstatSync(target);
+        return stat.isDirectory() && !stat.isSymbolicLink() && stat.uid === trustedUid && (stat.mode & 0o022) === 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Reads the window file only if the file actually opened is trusted. The path is opened once with O_NOFOLLOW, then the
+ * descriptor itself is checked (regular file, trusted owner, not group- or other-writable) and read, so a rename loop on
+ * the Butler's own state directory cannot swap a different file in between the check and the read. Any error is "no window".
+ */
+function readTrustedWindow(file, trustedUid) {
+    let fd;
+    try {
+        fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+        const stat = fs.fstatSync(fd);
+        if (!stat.isFile() || stat.uid !== trustedUid || (stat.mode & 0o022) !== 0)
+            return undefined;
+        return JSON.parse(fs.readFileSync(fd, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        if (fd !== undefined)
+            fs.closeSync(fd);
+    }
+}
+/**
+ * True only when the window file lists `friendId` with an expiry that is in the future and within the cap. Any unreadable or malformed file means "closed".
+ * The state directory is the Butler's own, so it could swap in a directory and window of its own making: only a replay
+ * directory and window file that root owns, and nobody else can write, count; anything else fails toward Telegram.
+ */
+function isReplayWindowOpen(agentRoot, friendId, now = Date.now(), trustedUid = 0) {
+    if (!isTrustedDirectory(replayDir(agentRoot), trustedUid))
+        return false;
+    const parsed = readTrustedWindow(replayWindowPath(agentRoot), trustedUid);
+    const friends = parsed?.friends;
+    if (!friends || typeof friends !== "object")
+        return false;
+    const entry = friends[friendId];
+    const expiresAt = typeof entry?.expiresAt === "string"
+        ? Date.parse(entry.expiresAt)
+        : Number.NaN;
+    return Number.isFinite(expiresAt) && expiresAt > now && expiresAt <= now + exports.REPLAY_WINDOW_MAX_MS;
+}
+/** Appends one notice to the sink; throws when it cannot be written, so the caller refuses exactly as a failed Telegram send does. */
+function appendReplayNotice(agentRoot, notice, now = Date.now()) {
+    fs.mkdirSync(replayDir(agentRoot), { recursive: true });
+    const line = JSON.stringify({ at: new Date(now).toISOString(), ...notice });
+    fs.appendFileSync(replaySinkPath(agentRoot), `${line}\n`, { mode: 0o600 });
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.a2a_replay_notice_sunk",
+        message: "wrote an owner notice to the replay sink instead of Telegram",
+        meta: { noticeId: notice.noticeId, friendId: notice.friendId },
+    });
+}
+/** True when the sink holds a notice with this id for this friend (a missing sink is "no"). The sink is Butler-writable: callers must also require a trusted window. */
+function replayNoticeRecorded(agentRoot, noticeId, friendId) {
+    let raw;
+    try {
+        raw = fs.readFileSync(replaySinkPath(agentRoot), "utf8");
+    }
+    catch {
+        return false;
+    }
+    return raw.split("\n").some((line) => {
+        if (!line)
+            return false;
+        try {
+            const entry = JSON.parse(line);
+            return entry.noticeId === noticeId && entry.friendId === friendId;
+        }
+        catch {
+            return false;
+        }
+    });
+}

package/dist/heart/awaiting/a2a-await-delivery.js

@@ -37,6 +37,7 @@ exports.createA2AAwaitOwnerDeliverer = createA2AAwaitOwnerDeliverer;
 const path = __importStar(require("path"));
 const friends_1 = require("@ouro.bot/friends");
 const identity_1 = require("../identity");
+const replay_harness_1 = require("../../a2a/replay-harness");
 const runtime_1 = require("../../nerves/runtime");
 /**
  * An A2A peer is a client that calls this agent's server; there is no channel back to it. When an await filed from
@@ -52,6 +53,11 @@ function createA2AAwaitOwnerDeliverer(agentName, notifyOwner = defaultNotifyOwne
         }
         try {
             const peer = await new friends_1.FileFriendStore(path.join((0, identity_1.getAgentRoot)(agentName), "friends")).get(request.friendId);
+            const agentRoot = (0, identity_1.getAgentRoot)(agentName);
+            if ((0, replay_harness_1.isReplayWindowOpen)(agentRoot, request.friendId)) {
+                (0, replay_harness_1.appendReplayNotice)(agentRoot, { noticeId: request.deliveryId, text: request.content, friendId: request.friendId });
+                return { status: "delivered_now", detail: "written to the replay sink (replay window open for this peer)" };
+            }
             const from = peer?.name ?? "a connected agent";
             await notifyOwner({ noticeId: request.deliveryId, text: `Follow-up on a request from ${from}: ${request.content}` });
             return { status: "delivered_now", detail: "sent to the owner's Telegram chat as the agent" };

package/dist/heart/daemon/sanctuary-authority-root-lifecycle.js

@@ -73,6 +73,10 @@ const DIGEST = /^sha256:[a-f0-9]{64}$/u;
 // page cache on Unraid's array that takes minutes, so readiness gets a generous budget
 // (a 120 s budget failed a real rollback on 2026-09-24).
 const GATEWAY_READY_TIMEOUT_MS = 900_000;
+const GATEWAY_START_BACKOFF_MS = [2_000, 10_000, 30_000];
+const GATEWAY_LOG_TAIL_CHARS = 2_000;
+// Read more than is shown, so masking sees whole tokens before the tail is cut.
+const GATEWAY_LOG_READ_BYTES = 4_096;
 const GATEWAY_LOG_MAX_BYTES = 5 * 1024 * 1024;
 const TEMPLATE_JOURNAL = "/boot/config/custom/ouro-butler/docker-man-template-transaction.json";
 // In-place upgrade of an installed authority: same epoch (token, issuer, cursor,
@@ -536,29 +540,69 @@ class SanctuaryAuthorityRootLifecycle {
         if (!this.#tokensAbsent() || !this.#rotated())
             throw new Error("Sanctuary root token custody is not exclusive");
         if (this.#pid() === null) {
-            this.#remove(`${this.#epochRoot()}/readiness.json`);
-            const log = this.#gatewayLog();
-            let child;
-            try {
-                child = (0, node_child_process_1.spawn)(this.#p("/usr/local/bin/node"), [this.#p(`${ROOT}/package/dist/heart/daemon/sanctuary-telegram-authority-entry.js`), "--config", this.#p(`${ROOT}/active.json`)], {
-                    cwd: "/", env: { PATH: "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin" }, detached: true, stdio: ["ignore", log, log],
-                });
-            }
-            finally {
-                fs.closeSync(log);
+            // The gateway can exit within seconds of launch (a transient Telegram network error at
+            // getMe did, 863 -> 864). Retry the launch with backoff, and when every attempt fails
+            // say so now, with the gateway's own output, instead of waiting out the readiness budget.
+            // One deadline bounds every launch: a relaunch only gets the budget that remains.
+            const deadline = Date.now() + GATEWAY_READY_TIMEOUT_MS;
+            for (let attempt = 0;; attempt += 1) {
+                const failure = await this.#launchGatewayOnce(deadline - Date.now());
+                if (failure === null)
+                    return;
+                if (attempt >= GATEWAY_START_BACKOFF_MS.length || Date.now() + GATEWAY_START_BACKOFF_MS[attempt] >= deadline) {
+                    throw new Error(`Sanctuary gateway ${failure} before readiness after ${attempt + 1} attempts; gateway.log tail:\n${this.#gatewayLogTail()}`);
+                }
+                (0, runtime_1.emitNervesEvent)({ level: "warn", component: "daemon", event: "daemon.sanctuary_gateway_start_retry", message: "Sanctuary gateway exited before readiness; retrying launch", meta: { attempt: attempt + 1, delayMs: GATEWAY_START_BACKOFF_MS[attempt], failure } });
+                await new Promise((resolve) => setTimeout(resolve, GATEWAY_START_BACKOFF_MS[attempt]));
             }
-            child.unref();
-            let failed = false;
-            child.once("error", () => { failed = true; });
-            await this.#wait(async () => {
-                if (failed)
-                    throw new Error("Sanctuary gateway launch failed");
-                return this.#ready();
-            }, GATEWAY_READY_TIMEOUT_MS);
         }
         else
             await this.#wait(() => this.#ready(), GATEWAY_READY_TIMEOUT_MS);
     }
+    /** One launch: resolves null once the gateway is ready, or "exited"/"failed to launch" if the process ends first. */
+    async #launchGatewayOnce(budgetMs) {
+        this.#remove(`${this.#epochRoot()}/readiness.json`);
+        const log = this.#gatewayLog();
+        let child;
+        try {
+            child = (0, node_child_process_1.spawn)(this.#p("/usr/local/bin/node"), [this.#p(`${ROOT}/package/dist/heart/daemon/sanctuary-telegram-authority-entry.js`), "--config", this.#p(`${ROOT}/active.json`)], {
+                cwd: "/", env: { PATH: "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin" }, detached: true, stdio: ["ignore", log, log],
+            });
+        }
+        finally {
+            fs.closeSync(log);
+        }
+        child.unref();
+        let ended = null;
+        child.once("error", () => { ended = "failed to launch"; });
+        child.once("exit", (code, signal) => { ended = `exited (${signal ?? `code ${code}`})`; });
+        let readiness = "ready";
+        await this.#wait(async () => {
+            if (ended !== null) {
+                readiness = "ended";
+                return true;
+            }
+            return this.#ready();
+        }, budgetMs);
+        return readiness === "ended" ? ended : null;
+    }
+    /** The last of gateway.log, with anything token-shaped masked, for an error message. */
+    #gatewayLogTail() {
+        const file = this.#p(`${ROOT}/gateway.log`);
+        if (!fs.existsSync(file))
+            return "(no gateway.log)";
+        const size = fs.statSync(file).size;
+        const fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+        try {
+            const length = Math.min(size, GATEWAY_LOG_READ_BYTES);
+            const buffer = Buffer.alloc(length);
+            fs.readSync(fd, buffer, 0, length, size - length);
+            return buffer.toString("utf8").replace(/[0-9]{5,}:[A-Za-z0-9_-]{20,}/gu, "[token]").slice(-GATEWAY_LOG_TAIL_CHARS).trim() || "(gateway.log is empty)";
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
     /** The gateway's own output, kept root-only beside the token it guards and capped at two
      * generations. It used to go nowhere, so a gateway that exited at startup said nothing
      * (D-036: finding "host cgroup entry is invalid" took a hand-run gateway). */
@@ -765,6 +809,10 @@ class SanctuaryAuthorityRootLifecycle {
             if (input.failAfter === step)
                 throw new Error(`Sanctuary upgrade rehearsal stopped after ${step}`);
         }
+        // A held upgrade is live but uncommitted: its journal and the predecessor's records stay, so `upgrade-rollback`
+        // still undoes it exactly. Running `upgrade` again without the hold commits it. A completed upgrade cannot be rolled back.
+        if (input.holdCommit)
+            return;
         target().#bundle(["--operation", "commit"]);
         // A copy of the live token must not linger as if it were a fresh rotation (D-044).
         this.#remove(`${ROOT}/incoming-token`);
@@ -1128,10 +1176,11 @@ async function runSanctuaryAuthorityRootCli(argv, write = (text) => process.stdo
         return;
     }
     const repin = argv.length === 3 && argv[0] === "repin-execution";
-    const upgrade = argv[0] === "upgrade" && (argv.length === 3 || (argv.length === 5 && argv[3] === "--fail-after"));
+    const holdCommit = argv[0] === "upgrade" && argv.length === 4 && argv[3] === "--hold-commit";
+    const upgrade = argv[0] === "upgrade" && (argv.length === 3 || holdCommit || (argv.length === 5 && argv[3] === "--fail-after"));
     const rollback = argv.length === 1 && argv[0] === "upgrade-rollback";
     if (!repin && !upgrade && !rollback && (argv.length !== 1 || argv[0] !== "boot"))
-        throw new Error("Usage: sanctuary-authority-root-lifecycle <boot|repin-execution <prlimit-sha256> <setsid-sha256>|upgrade <target-image-id> <image-reference> [--fail-after <step>]|upgrade-rollback|vault snapshot|vault presence|vault remove|vault restore>");
+        throw new Error("Usage: sanctuary-authority-root-lifecycle <boot|repin-execution <prlimit-sha256> <setsid-sha256>|upgrade <target-image-id> <image-reference> [--fail-after <step>|--hold-commit]|upgrade-rollback|vault snapshot|vault presence|vault remove|vault restore>");
     // Boot never waits: the host keeper retries it. An operator upgrade waits out a boot in flight.
     await (0, session_transaction_1.withSessionTurnLease)(TEMPLATE_JOURNAL, async () => {
         const activationPath = `${ROOT}/activation.json`;
@@ -1147,8 +1196,8 @@ async function runSanctuaryAuthorityRootCli(argv, write = (text) => process.stdo
             write('{"repinned":true,"gatewayRestartRequired":true}\n');
         }
         else if (upgrade) {
-            await lifecycle.upgrade({ targetImageId: argv[1], imageReference: argv[2], ...(argv[4] ? { failAfter: argv[4] } : {}) });
-            write(`${JSON.stringify({ upgraded: argv[2] })}\n`);
+            await lifecycle.upgrade({ targetImageId: argv[1], imageReference: argv[2], ...(argv[4] ? { failAfter: argv[4] } : {}), ...(holdCommit ? { holdCommit: true } : {}) });
+            write(`${JSON.stringify({ upgraded: argv[2], ...(holdCommit ? { held: true } : {}) })}\n`);
         }
         else if (rollback) {
             write(`${JSON.stringify({ rolledBack: await lifecycle.rollbackUpgrade() })}\n`);

package/dist/heart/daemon/sanctuary-telegram-authority-entry.js

@@ -199,6 +199,36 @@ async function readBoundedFileResponse(response) {
     const contentType = response.headers.get("content-type");
     return { body: Buffer.concat(chunks, total), ...(contentType ? { contentType } : {}) };
 }
+const GET_ME_BACKOFF_MS = [5_000, 10_000, 20_000, 30_000];
+const NETWORK_FAILURE = /fetch failed|ECONNRESET|ECONNREFUSED|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|ENETUNREACH|EHOSTUNREACH|EPIPE|socket hang up|network|timed out/iu;
+/** A getMe failure worth another try: Telegram 5xx, or no HTTP answer at all (the client reports a
+ * transport failure as a status-less TelegramApiError). Auth and other 4xx answers are never retried. */
+function isTransientTelegramFailure(error) {
+    if (!(error instanceof telegram_client_1.TelegramApiError))
+        return false;
+    if (error.status !== null)
+        return error.status >= 500;
+    return error.errorCode === null && NETWORK_FAILURE.test(error.message);
+}
+async function getMeWithRetry(api, sleep) {
+    for (let attempt = 0;; attempt += 1) {
+        try {
+            return await api.request("getMe", {});
+        }
+        catch (error) {
+            if (attempt >= GET_ME_BACKOFF_MS.length || !isTransientTelegramFailure(error))
+                throw error;
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.sanctuary_authority_getme_retry",
+                message: "Telegram getMe failed with a transient error; retrying",
+                meta: { attempt: attempt + 1, delayMs: GET_ME_BACKOFF_MS[attempt] },
+            });
+            await sleep(GET_ME_BACKOFF_MS[attempt]);
+        }
+    }
+}
 async function startSanctuaryTelegramAuthority(options) {
     (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.sanctuary_authority_boot_requested", message: "Sanctuary authority boot requested; prerequisite verification pending" });
     const expectedUid = options.expectedUid ?? 0;
@@ -245,7 +275,7 @@ async function startSanctuaryTelegramAuthority(options) {
         const publicKey = (0, node_crypto_1.createPublicKey)(privateKey);
         if (!options.retireOnly) {
             api = (options.createApi ?? ((value) => (0, telegram_client_1.createTelegramBotApi)({ token: value })))(token);
-            const identity = await api.request("getMe", {});
+            const identity = await getMeWithRetry(api, options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms))));
             if (!isObject(identity) || String(identity.id) !== config.botId) {
                 throw new Error("Sanctuary Telegram authority bot identity changed");
             }

package/dist/heart/daemon/sanctuary-telegram-authority-service.js

@@ -520,6 +520,17 @@ function createSanctuaryTelegramAuthorityServer(options) {
         connection.setEncoding("utf8");
         connection.setTimeout(connectionTimeoutMs, () => connection.destroy());
         connection.once("close", () => connections.delete(connection));
+        // A client that vanishes mid-response (reset, timeout, crash) surfaces as EPIPE/ECONNRESET on this
+        // socket; unhandled, that killed the whole gateway. Log it and let the connection close.
+        connection.on("error", (error) => {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.sanctuary_authority_connection_error",
+                message: "Sanctuary authority client connection failed; dropping it",
+                meta: { code: error.code ?? "unknown" },
+            });
+        });
         let buffer = "";
         connection.on("data", (chunk) => {
             buffer += chunk;
@@ -573,20 +584,22 @@ function createSanctuaryTelegramAuthorityServer(options) {
                 const response = dispatchTail.then(async () => {
                     try {
                         const result = await options.dispatch(frame.method, frame.params);
-                        connection.write(`${JSON.stringify({
-                            protocolVersion: PROTOCOL_VERSION,
-                            id: frame.id,
-                            ok: true,
-                            result,
-                        })}\n`);
+                        if (!connection.destroyed)
+                            connection.write(`${JSON.stringify({
+                                protocolVersion: PROTOCOL_VERSION,
+                                id: frame.id,
+                                ok: true,
+                                result,
+                            })}\n`);
                     }
                     catch {
-                        connection.write(`${JSON.stringify({
-                            protocolVersion: PROTOCOL_VERSION,
-                            id: frame.id,
-                            ok: false,
-                            error: { message: "Sanctuary authority request failed" },
-                        })}\n`);
+                        if (!connection.destroyed)
+                            connection.write(`${JSON.stringify({
+                                protocolVersion: PROTOCOL_VERSION,
+                                id: frame.id,
+                                ok: false,
+                                error: { message: "Sanctuary authority request failed" },
+                            })}\n`);
                     }
                 });
                 dispatchTail = response;

package/dist/senses/a2a-entry.js

@@ -47,6 +47,7 @@ function argValue(name) {
 const runtime_logging_1 = require("../heart/daemon/runtime-logging");
 const runtime_1 = require("../nerves/runtime");
 const delegated_command_1 = require("../a2a/delegated-command");
+const identity_1 = require("../heart/identity");
 (0, runtime_logging_1.configureDaemonRuntimeLogger)("a2a");
 (0, runtime_1.emitNervesEvent)({
     component: "senses",
@@ -101,6 +102,7 @@ Promise.all([
         ...(agentName === "sanctuary" ? {
             delegation: {
                 principalProfileId: delegated_command_1.A2A_PRINCIPAL_PROFILE_ID,
+                agentRoot: (0, identity_1.getAgentRoot)(agentName),
                 notifyPrincipal: async (notice) => {
                     const { sendTelegramOwnerNotice } = await Promise.resolve().then(() => __importStar(require("./telegram")));
                     await sendTelegramOwnerNotice(agentName, { ...notice, signal: AbortSignal.timeout(30_000) });

package/dist/senses/private-runtime.js

@@ -166,7 +166,7 @@ async function resolveA2APrincipal(agentRoot, store, peer, requestId) {
     if (owners.length !== 1 || owners[0].id === peer.id)
         throw new StaleRelationshipAwaitError("delegating owner cannot be resolved");
     const owner = owners[0];
-    if (!(0, delegated_command_1.delegatedCommandWasNoticed)(agentRoot, requestId, owner.id))
+    if (!(0, delegated_command_1.delegatedCommandWasNoticed)(agentRoot, requestId, owner.id, peer.id))
         throw new StaleRelationshipAwaitError("request was not a delegated command the owner was notified of");
     return owner;
 }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.864",
+  "version": "0.1.0-alpha.866",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@ouro.bot/cli",
-      "version": "0.1.0-alpha.864",
+      "version": "0.1.0-alpha.866",
       "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.864",
+  "version": "0.1.0-alpha.866",
   "engines": {
     "node": ">=22"
   },