@ouro.bot/cli 0.1.0-alpha.955 → 0.1.0-alpha.957

package/dist/senses/private-runtime-worker.js

@@ -40,6 +40,7 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const private_runtime_1 = require("./private-runtime");
 const router_1 = require("../heart/external-events/router");
+const telegram_handoff_1 = require("./telegram-handoff");
 const runtime_1 = require("../nerves/runtime");
 const identity_1 = require("../heart/identity");
 const pending_1 = require("../mind/pending");
@@ -167,6 +168,50 @@ function reserveHabitAutonomyBudget(habitRun, nowIso) {
         now: nowIso,
     }, (0, autonomy_budget_1.resolveAutonomyBudgetPolicy)(habitRun.agentRoot, agentName));
 }
+/**
+ * External-event turns are paid model work, so they draw on their own daily allowance (the agent's
+ * habitPaidTurnsPerDay, counted under the "external-events" name so a busy event day cannot starve a
+ * habit) and share one storm breaker: three failed event turns within ten minutes pause event turns
+ * for thirty minutes.
+ */
+const EXTERNAL_EVENT_BUDGET_NAME = "external-events";
+function externalEventStorm(agentName) {
+    return {
+        agent: agentName,
+        triggerType: "habit",
+        sourceKind: "private-runtime",
+        senseOrHabit: EXTERNAL_EVENT_BUDGET_NAME,
+        provider: "model",
+        target: { kind: EXTERNAL_EVENT_BUDGET_NAME },
+        normalizedErrorName: "external_event_turn_failed",
+        normalizedErrorCode: "turn_failed",
+        codeLocation: "private-runtime-worker",
+        idempotencyBucket: EXTERNAL_EVENT_BUDGET_NAME,
+    };
+}
+/** A blocked event turn waits this long (the breaker's block length) and keeps its retry attempts. */
+const EXTERNAL_EVENT_BLOCKED_DEFER_MS = 30 * 60_000;
+function reserveExternalEventAutonomyBudget(event, nowIso) {
+    // Disk, parity and array failures always get a turn: the owner must hear about them even on a busy day.
+    if ([event, ...(event.relatedEvents ?? [])].some((member) => (0, telegram_handoff_1.isCriticalNoticeKey)(member.eventId)))
+        return null;
+    const agentRoot = (0, identity_1.getAgentRoot)();
+    const agentName = (0, identity_1.getAgentName)();
+    return (0, autonomy_budget_1.reserveAutonomyBudget)(agentRoot, {
+        agent: agentName,
+        triggerType: "habit",
+        sourceKind: "private-runtime",
+        senseOrHabit: EXTERNAL_EVENT_BUDGET_NAME,
+        target: { kind: EXTERNAL_EVENT_BUDGET_NAME },
+        idempotencyKey: `event:${event.recordPath}:${event.generation}:${event.claimOwner}`,
+        now: nowIso,
+        storm: externalEventStorm(agentName),
+    }, (0, autonomy_budget_1.resolveAutonomyBudgetPolicy)(agentRoot, agentName));
+}
+function recordExternalEventTurnFailure(nowIso) {
+    const agentRoot = (0, identity_1.getAgentRoot)();
+    (0, autonomy_budget_1.recordAutonomyFailure)(agentRoot, { ...externalEventStorm((0, identity_1.getAgentName)()), occurredAt: nowIso }, (0, autonomy_budget_1.resolveAutonomyBudgetPolicy)(agentRoot, (0, identity_1.getAgentName)()));
+}
 /**
  * Habit recursion detector thresholds. This protects against the *external*
  * IPC self-loop where heartbeat-shaped messages get re-issued faster
@@ -537,7 +582,9 @@ function createPrivateRuntimeWorker(runTurn = (options) => (0, private_runtime_1
                         const turnStartedAt = new Date(nowSource()).toISOString();
                         const autonomyDecision = currentHabitRun && !currentHabitRun.blockedReason
                             ? reserveHabitAutonomyBudget(currentHabitRun, turnStartedAt)
-                            : null;
+                            : currentExternalEvent
+                                ? reserveExternalEventAutonomyBudget(currentExternalEvent, turnStartedAt)
+                                : null;
                         if (currentHabitRun)
                             recordHabitStartIfNeeded(currentHabitRun);
                         if (currentHabitRun?.blockedReason) {
@@ -620,15 +667,20 @@ function createPrivateRuntimeWorker(runTurn = (options) => (0, private_runtime_1
                             : blockedAutonomyTurn || turnOutcome === "blocked" || turnOutcome === "suspended"
                                 ? "external-event turn was blocked"
                                 : "external-event turn completed without a terminal disposition";
+                        const settledAt = nowSource();
+                        const deferUntil = blockedAutonomyTurn ? new Date(settledAt + EXTERNAL_EVENT_BLOCKED_DEFER_MS).toISOString() : undefined;
                         let settledIncomplete = false;
                         for (const member of [currentExternalEvent, ...(currentExternalEvent.relatedEvents ?? [])]) {
                             const result = (0, router_1.settleExternalEventFailureIfOwned)(member.recordPath, {
                                 owner: member.claimOwner,
                                 expectedGeneration: member.generation,
                                 error: failureReason,
+                                ...(deferUntil ? { deferUntil } : {}),
                             });
                             settledIncomplete = result.settled || settledIncomplete;
                         }
+                        if (!blockedAutonomyTurn && (turnErrors.length > 0 || turnOutcome === "errored" || settledIncomplete))
+                            recordExternalEventTurnFailure(new Date(settledAt).toISOString());
                         if (settledIncomplete && turnErrors.length === 0)
                             turnErrors.push(failureReason);
                     }

package/dist/senses/sanctuary-health-acceptance-probe.js

@@ -547,7 +547,7 @@ async function runSanctuaryHealthAcceptanceProbe(input, dependencies = createSan
                 }
                 const runPhase = async (name, trigger, fixtureStatus, fetchImpl, now) => {
                     const sweep = (0, sanctuary_health_1.createSanctuaryHealthSweep)({
-                        toolContext: dependencies.toolContext, statePath, fetch: fetchImpl, now: () => now, lease,
+                        toolContext: dependencies.toolContext, statePath, fetch: fetchImpl, now: () => now, lease, endpointDebounce: false,
                         acceptanceEventMeta: () => ({ scenarioHandleDigest: input.scenarioHandleDigest }),
                     });
                     await (0, sanctuary_health_runner_1.runSanctuaryHealthHabit)("sanctuary", {

package/dist/senses/sanctuary-health.js

@@ -226,6 +226,7 @@ function load(filePath) {
             lastDigestDay: value.lastDigestDay,
             updatedAt: value.updatedAt,
             ...(value.pendingRecovered?.length ? { pendingRecovered: value.pendingRecovered } : {}),
+            ...(endpointFailuresOf(value.endpointFailures) ? { endpointFailures: endpointFailuresOf(value.endpointFailures) } : {}),
             outbox: value.outbox ? { ...value.outbox, kind: value.outbox.kind ?? "legacy_unknown" } : null,
             indeterminateDeliveries: (value.indeterminateDeliveries ?? []).map((delivery) => ({ ...delivery, kind: delivery.kind ?? "legacy_unknown" })),
             deliveredReceipts: (value.deliveredReceipts ?? []).map((receipt) => ({ ...receipt, kind: receipt.kind ?? "legacy_unknown" })),
@@ -242,6 +243,13 @@ function load(filePath) {
 function readSanctuaryHealthState(filePath) {
     return load(filePath);
 }
+// A malformed failure counter only delays an endpoint incident by one sweep, so it is dropped rather than treated as corrupt state.
+function endpointFailuresOf(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const entries = Object.entries(value).filter(([, count]) => Number.isSafeInteger(count) && count > 0);
+    return entries.length > 0 ? Object.fromEntries(entries) : null;
+}
 function save(filePath, state) {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
     const temporary = `${filePath}.tmp-${process.pid}-${(0, node_crypto_1.randomUUID)()}`;
@@ -295,6 +303,16 @@ async function probeSanctuaryEndpoint(url, fetchImpl = fetch) {
 }
 function createSanctuaryHealthSweep(options) {
     const fetchImpl = options.fetch ?? fetch;
+    const endpointRetryDelayMs = options.endpointRetryDelayMs ?? 3_000;
+    const endpointDebounce = options.endpointDebounce ?? true;
+    const endpointFailuresToOpen = endpointDebounce ? 2 : 1;
+    const probeWithRetry = async (url) => {
+        const first = await probeSanctuaryEndpoint(url, fetchImpl);
+        if (first.ok || !endpointDebounce)
+            return first;
+        await new Promise((resolve) => setTimeout(resolve, endpointRetryDelayMs));
+        return probeSanctuaryEndpoint(url, fetchImpl);
+    };
     const now = options.now ?? (() => new Date());
     const acceptanceEventMeta = options.acceptanceEventMeta ?? (() => (0, sanctuary_acceptance_marker_1.sanctuaryAcceptanceEventMeta)("sanctuary"));
     const runSweep = async () => {
@@ -313,7 +331,7 @@ function createSanctuaryHealthSweep(options) {
             throw new Error("Sanctuary health runtime is unavailable");
         const [containersResult, storageResult, disksResult, notificationsResult, endpoints] = await Promise.all([
             runtime.listContainers(), runtime.getStorage(), runtime.getDisks(), runtime.getNotifications(),
-            Promise.all(exports.SANCTUARY_PUBLIC_ENDPOINTS.map((url) => probeSanctuaryEndpoint(url, fetchImpl))),
+            Promise.all(exports.SANCTUARY_PUBLIC_ENDPOINTS.map((url) => probeWithRetry(url))),
         ]);
         const incidents = new Map();
         const add = (id, rawSummary) => {
@@ -364,13 +382,20 @@ function createSanctuaryHealthSweep(options) {
         const notifications = record(notificationsResult)?.ok ? record(record(notificationsResult)?.data)?.unacknowledged : null;
         if (!Array.isArray(notifications))
             add("notifications:unavailable", "notification status is unavailable");
+        // Informational (Unraid "normal") notifications are not incidents; warnings and alerts are.
         else
             for (const item of notifications)
-                add(`notification:${item.id}`, `unacknowledged notification: ${item.title || item.id}`);
-        for (const endpoint of endpoints)
-            if (!endpoint.ok)
-                add(`endpoint:${endpoint.url}`, `${endpoint.url} returned ${endpoint.status || "no response"}`);
+                if (item.severity !== "info")
+                    add(`notification:${item.id}`, `unacknowledged notification: ${item.title || item.id}`);
         const previous = load(options.statePath);
+        const endpointFailures = {};
+        for (const endpoint of endpoints) {
+            if (endpoint.ok)
+                continue;
+            endpointFailures[endpoint.url] = (previous.endpointFailures?.[endpoint.url] ?? 0) + 1;
+            if (endpointFailures[endpoint.url] >= endpointFailuresToOpen)
+                add(`endpoint:${endpoint.url}`, `${endpoint.url} returned ${endpoint.status || "no response"}`);
+        }
         const current = Object.fromEntries([...incidents.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([id, incident]) => {
             const prior = previous.incidents[id];
             const transition = !prior ? "opened" : prior.observationRevision === incident.observationRevision ? "unchanged" : "changed";
@@ -401,6 +426,7 @@ function createSanctuaryHealthSweep(options) {
             lastDigestDay: null,
             updatedAt: now().toISOString(),
             ...(unacknowledgedRecovered.length > 0 ? { pendingRecovered: unacknowledgedRecovered } : {}),
+            ...(Object.keys(endpointFailures).length > 0 ? { endpointFailures } : {}),
             outbox: null,
             indeterminateDeliveries: [],
             deliveredReceipts: previous.deliveredReceipts,

package/dist/senses/telegram-handoff.js

@@ -33,10 +33,17 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OWNER_CHAT_HANDOFF_MS = void 0;
+exports.QUIET_HOURS = exports.PROACTIVE_DAILY_CAP = exports.OWNER_CHAT_HANDOFF_MS = void 0;
 exports.ownerChatHandedOff = ownerChatHandedOff;
 exports.readHeldNotices = readHeldNotices;
 exports.writeHeldNotices = writeHeldNotices;
+exports.isQuietHour = isQuietHour;
+exports.isCriticalNoticeKey = isCriticalNoticeKey;
+exports.proactiveHoldReason = proactiveHoldReason;
+exports.recordProactiveSend = recordProactiveSend;
+exports.foldHeldNotices = foldHeldNotices;
+exports.readReleasedHeldKeys = readReleasedHeldKeys;
+exports.recordReleasedHeldKeys = recordReleasedHeldKeys;
 /**
  * Ari sometimes hands his Telegram chat to someone else ("I'm going to hand you to my wife, Rachel"). For a while after that,
  * the chat is that person's conversation, so house notices (an outage, a recovery) wait instead of landing in it
@@ -45,6 +52,7 @@ exports.writeHeldNotices = writeHeldNotices;
  */
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
 const session_events_1 = require("../heart/session-events");
 const runtime_1 = require("../nerves/runtime");
 exports.OWNER_CHAT_HANDOFF_MS = 2 * 60 * 60 * 1000;
@@ -78,3 +86,69 @@ function writeHeldNotices(filePath, notices) {
     fs.renameSync(temporary, filePath);
     (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.telegram_held_notices_saved", message: "saved the house notices held during a handoff", meta: { held: notices.length } });
 }
+/**
+ * Proactive pacing: at most PROACTIVE_DAILY_CAP unprompted owner messages per local day, and none in quiet hours
+ * (23:00-08:00 local), except critical ones (array or disk failure, parity errors). A held message waits in the same
+ * held-notice file and goes out, folded into one message, at the next allowed moment.
+ */
+exports.PROACTIVE_DAILY_CAP = 3;
+exports.QUIET_HOURS = { start: 23, end: 8 };
+const CRITICAL_NOTICE = /\b(?:disk:[^"\s]*:smart|parity:|disk:array:state)/u;
+function localParts(now, timeZone) {
+    const parts = Object.fromEntries(new Intl.DateTimeFormat("en-CA", { timeZone, year: "numeric", month: "2-digit", day: "2-digit", hour: "2-digit", hourCycle: "h23" })
+        .formatToParts(now).map((part) => [part.type, part.value]));
+    return { day: `${parts.year}-${parts.month}-${parts.day}`, hour: Number(parts.hour) };
+}
+function isQuietHour(now, pacing) {
+    const { hour } = localParts(now, pacing.timeZone);
+    return hour >= exports.QUIET_HOURS.start || hour < exports.QUIET_HOURS.end;
+}
+function isCriticalNoticeKey(key) {
+    return CRITICAL_NOTICE.test(key);
+}
+function readProactiveLedger(filePath) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+        return typeof parsed.day === "string" && Number.isSafeInteger(parsed.count) ? { day: parsed.day, count: parsed.count } : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Why a non-critical proactive message must wait now, or null when it may go. */
+function proactiveHoldReason(ledgerPath, now, pacing) {
+    if (isQuietHour(now, pacing))
+        return "quiet_hours";
+    const ledger = readProactiveLedger(ledgerPath);
+    return ledger?.day === localParts(now, pacing.timeZone).day && ledger.count >= exports.PROACTIVE_DAILY_CAP ? "daily_cap" : null;
+}
+function recordProactiveSend(ledgerPath, now, pacing) {
+    const day = localParts(now, pacing.timeZone).day;
+    const ledger = readProactiveLedger(ledgerPath);
+    fs.mkdirSync(path.dirname(ledgerPath), { recursive: true });
+    fs.writeFileSync(ledgerPath, JSON.stringify({ day, count: ledger?.day === day ? ledger.count + 1 : 1 }), { mode: 0o600 });
+}
+/** Several held notices go out as one message so a quiet night never becomes a morning burst. */
+function foldHeldNotices(held) {
+    if (held.length === 1)
+        return held[0];
+    return { key: `held-batch:${(0, node_crypto_1.createHash)("sha256").update(held.map((notice) => notice.key).join("\0")).digest("hex").slice(0, 32)}`, text: ["While you were away:", ...held.map((notice) => `- ${notice.text}`)].join("\n") };
+}
+const RELEASED_KEYS_LIMIT = 500;
+/** Keys of held notices that went out inside a folded batch, so a retried decision sees its message already exists. */
+function readReleasedHeldKeys(filePath) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+        return Array.isArray(parsed) ? parsed.filter((entry) => typeof entry === "string") : [];
+    }
+    catch {
+        return [];
+    }
+}
+function recordReleasedHeldKeys(filePath, keys) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const next = [...readReleasedHeldKeys(filePath).filter((key) => !keys.includes(key)), ...keys].slice(-RELEASED_KEYS_LIMIT);
+    const temporary = `${filePath}.${process.pid}.tmp`;
+    fs.writeFileSync(temporary, JSON.stringify(next), { mode: 0o600 });
+    fs.renameSync(temporary, filePath);
+}

package/dist/senses/telegram.js

@@ -1137,13 +1137,22 @@ function createTelegramSenseApp(options) {
         const sessionPath = (0, shared_turn_1.getSenseSessionPath)(options.agentName, configuredOwnerFriendId, "telegram", configuredOwnerSessionKey, agentRoot);
         return (0, telegram_handoff_1.ownerChatHandedOff)((0, session_events_1.loadSessionEnvelopeFile)(sessionPath)?.events ?? [], Date.now());
     };
-    const holdNoticeDuringHandoff = (text, key) => {
-        if (!ownerChatIsHandedOff())
+    const proactiveLedgerPath = path.join(agentRoot, "state", "telegram", "proactive-sends.json");
+    const countProactiveSend = () => { if (options.proactivePacing)
+        (0, telegram_handoff_1.recordProactiveSend)(proactiveLedgerPath, new Date(), options.proactivePacing); };
+    const releasedHeldKeysPath = path.join(agentRoot, "state", "telegram", "released-held-keys.json");
+    const holdNoticeDuringHandoff = (text, key, critical = (0, telegram_handoff_1.isCriticalNoticeKey)(key)) => {
+        const handedOff = ownerChatIsHandedOff();
+        const pacingReason = !handedOff && options.proactivePacing && !critical ? (0, telegram_handoff_1.proactiveHoldReason)(proactiveLedgerPath, new Date(), options.proactivePacing) : null;
+        if (!handedOff && !pacingReason)
             return false;
         const held = (0, telegram_handoff_1.readHeldNotices)(heldNoticesPath);
         if (!held.some((notice) => notice.key === key))
             (0, telegram_handoff_1.writeHeldNotices)(heldNoticesPath, [...held, { key, text }]);
-        (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.telegram_notice_held_for_handoff", message: "held a house notice while the owner's chat is handed to someone else", meta: { agentName: options.agentName } });
+        if (handedOff)
+            (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.telegram_notice_held_for_handoff", message: "held a house notice while the owner's chat is handed to someone else", meta: { agentName: options.agentName } });
+        else
+            (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.telegram_notice_held_for_pacing", message: "held a house notice for quiet hours or the daily message cap", meta: { agentName: options.agentName, reason: pacingReason } });
         return true;
     };
     let heldNoticeRelease = Promise.resolve();
@@ -1156,6 +1165,21 @@ function createTelegramSenseApp(options) {
             if (ownerChatIsHandedOff())
                 return;
             const sessionPath = (0, shared_turn_1.getSenseSessionPath)(options.agentName, configuredOwnerFriendId, "telegram", configuredOwnerSessionKey, agentRoot);
+            if (options.proactivePacing) {
+                // Held notices go out as one message, and only when an unprompted message is allowed now (quiet hours and the daily cap).
+                if ((0, telegram_handoff_1.proactiveHoldReason)(proactiveLedgerPath, new Date(), options.proactivePacing))
+                    return;
+                /* v8 ignore next -- the caller already saw held notices; only a concurrent release can empty the file before this re-read @preserve */
+                if (held.length === 0)
+                    return;
+                const folded = (0, telegram_handoff_1.foldHeldNotices)(held);
+                if (held.length > 1)
+                    (0, telegram_handoff_1.recordReleasedHeldKeys)(releasedHeldKeysPath, held.map((notice) => notice.key));
+                (0, telegram_handoff_1.writeHeldNotices)(heldNoticesPath, (0, telegram_handoff_1.readHeldNotices)(heldNoticesPath).filter((entry) => !held.some((notice) => notice.key === entry.key)));
+                await recordAcceptedEffects(sessionPath, [await deliverButlerEffect(folded.text, folded.key, signal)]);
+                countProactiveSend();
+                return;
+            }
             for (const notice of held) {
                 (0, telegram_handoff_1.writeHeldNotices)(heldNoticesPath, (0, telegram_handoff_1.readHeldNotices)(heldNoticesPath).filter((entry) => entry.key !== notice.key));
                 await recordAcceptedEffects(sessionPath, [await deliverButlerEffect(notice.text, notice.key, signal)]);
@@ -1949,6 +1973,7 @@ function createTelegramSenseApp(options) {
                     return;
                 await releaseHeldNotices(signal);
                 const effect = await deliverButlerEffect(proactiveText, key, signal);
+                countProactiveSend();
                 const sessionPath = (0, shared_turn_1.getSenseSessionPath)(options.agentName, configuredOwnerFriendId, "telegram", configuredOwnerSessionKey, agentRoot);
                 await recordAcceptedEffects(sessionPath, [effect]);
             });
@@ -1967,7 +1992,9 @@ function createTelegramSenseApp(options) {
                 const text = requiredText(input.text, "external event decision");
                 const sessionPath = (0, shared_turn_1.getSenseSessionPath)(options.agentName, configuredOwnerFriendId, "telegram", configuredOwnerSessionKey, agentRoot);
                 const held = (0, telegram_handoff_1.readHeldNotices)(heldNoticesPath);
+                const releasedKeys = (0, telegram_handoff_1.readReleasedHeldKeys)(releasedHeldKeysPath);
                 const ownerMessageExists = (candidate) => held.some((notice) => notice.key === candidate)
+                    || releasedKeys.includes(candidate)
                     || getEffectJournal().readByIdempotencyKey(candidate) !== null;
                 if (ownerMessageExists(key)) {
                     // A retry after the message went out (or was held): finish the original send, never send a reworded second one.
@@ -1991,10 +2018,11 @@ function createTelegramSenseApp(options) {
                     });
                     return { status: "covered", effectKey: coveredBy };
                 }
-                if (holdNoticeDuringHandoff(text, key))
+                if (holdNoticeDuringHandoff(text, key, [key, ...relatedKeys].some(telegram_handoff_1.isCriticalNoticeKey)))
                     return { status: "sent", effectKey: key };
                 await releaseHeldNotices(input.signal);
                 const effect = await deliverButlerEffect(text, key, input.signal);
+                countProactiveSend();
                 await recordAcceptedEffects(sessionPath, [effect]);
                 return { status: "sent", effectKey: key };
             });
@@ -2012,6 +2040,7 @@ function createTelegramSenseApp(options) {
                     return;
                 await releaseHeldNotices(input.signal);
                 const effect = await deliverButlerEffect(text, `owner-notice:${noticeId}`, input.signal);
+                countProactiveSend();
                 const sessionPath = (0, shared_turn_1.getSenseSessionPath)(options.agentName, configuredOwnerFriendId, "telegram", configuredOwnerSessionKey, agentRoot);
                 await recordAcceptedEffects(sessionPath, [effect]);
             });
@@ -2323,6 +2352,8 @@ async function startTelegramSenseApp(agentName, waitForAuthority = false) {
             agentName,
             credentials,
             authorityTransport,
+            // The owner is in Los Angeles; a container without TZ would otherwise run quiet hours on UTC.
+            proactivePacing: { timeZone: process.env.TZ || "America/Los_Angeles" },
             ...(await createProductionTelegramRelationshipComposition(agentName, credentials, undefined, authorityTransport)),
             ...(agentName === "sanctuary" ? { privilegedFailsafe: {
                     eventRoot: (0, router_1.getExternalEventRoot)(),

package/npm-shrinkwrap.json

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