@ouro.bot/cli 0.1.0-alpha.859 → 0.1.0-alpha.860

package/changelog.json

@@ -1,6 +1,12 @@
 {
   "_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.860",
+      "changes": [
+        "Awaits filed from an A2A delegated command now run: the follow-up carries the delegating owner's authority narrowed to the peer's profile, its outcome reaches the owner on Telegram as the agent, and an await that can never run is canceled with a reason and reported instead of failing silently on every wake."
+      ]
+    },
     {
       "version": "0.1.0-alpha.859",
       "changes": [

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

@@ -1,5 +1,5 @@
 {
-  "runtimeVersion": "0.1.0-alpha.859",
+  "runtimeVersion": "0.1.0-alpha.860",
   "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.859</Repository>
+  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.860</Repository>
   <Registry>https://github.com/ourostack/ouroboros/pkgs/container/ouroboros-butler</Registry>
   <Network>host</Network>
   <Shell>sh</Shell>

package/dist/a2a/delegated-command.js

@@ -1,11 +1,71 @@
 "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.DELEGATED_BANNER = void 0;
+exports.DELEGATED_BANNER = exports.A2A_PRINCIPAL_PROFILE_ID = void 0;
+exports.delegatedCommandWasNoticed = delegatedCommandWasNoticed;
 exports.delegatedCommandNotice = delegatedCommandNotice;
 exports.admitDelegatedCommand = admitDelegatedCommand;
+const crypto_1 = require("crypto");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 const runtime_1 = require("../nerves/runtime");
 const relationship_authorization_1 = require("../repertoire/relationship-authorization");
 const NOTICE_EXCERPT_CHARS = 200;
+/** The relationship profile that names the principal a delegated peer acts for. */
+exports.A2A_PRINCIPAL_PROFILE_ID = "sanctuary-owner";
+/**
+ * True when the owner was told about delegated command `commandId` in their own chat: admission only runs a command
+ * after that notice is delivered, and the Telegram effect journal keeps the notice under a key derived from the
+ * command id. A request id with no such record never came through a signed, owner-notified delegated command.
+ * A missing record is `false`; an unreadable or malformed one throws, so the caller retries instead of deciding.
+ */
+function delegatedCommandWasNoticed(agentRoot, commandId, principalFriendId) {
+    const idempotencyKey = `owner-notice:delegated:${commandId}`;
+    const file = path.join(agentRoot, "state", "telegram", "effects", `${(0, crypto_1.createHash)("sha256").update(idempotencyKey).digest("hex")}.json`);
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+    const artifact = JSON.parse(raw);
+    return artifact.idempotencyKey === idempotencyKey && artifact.authorClass === "butler" && artifact.target?.friendId === principalFriendId;
+}
 /** Matches the banner only the server may put in front of an admitted command. */
 exports.DELEGATED_BANNER = /^\s*\[\s*delegated command/iu;
 function delegatedCommandNotice(input) {

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

@@ -0,0 +1,76 @@
+"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.createA2AAwaitOwnerDeliverer = createA2AAwaitOwnerDeliverer;
+const path = __importStar(require("path"));
+const friends_1 = require("@ouro.bot/friends");
+const identity_1 = require("../identity");
+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
+ * an A2A conversation resolves or expires, the outcome goes to the agent's owner in the owner's own Telegram chat,
+ * written by the agent as itself (an owner notice, the same path that announces delegated commands). Nothing is
+ * sent as the owner or to the peer, and the notice id is the await's delivery id, so a retry cannot double-send.
+ */
+const NOTICE_ID_MAX_BYTES = 512;
+function createA2AAwaitOwnerDeliverer(agentName, notifyOwner = defaultNotifyOwner(agentName)) {
+    return async (request) => {
+        if (!request.deliveryId || Buffer.byteLength(request.deliveryId) > NOTICE_ID_MAX_BYTES) {
+            return { status: "blocked", detail: "A2A await follow-up is missing a valid delivery id" };
+        }
+        try {
+            const peer = await new friends_1.FileFriendStore(path.join((0, identity_1.getAgentRoot)(agentName), "friends")).get(request.friendId);
+            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" };
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "daemon",
+                event: "daemon.await_a2a_owner_notice_error",
+                message: "A2A await follow-up could not be delivered to the owner",
+                meta: { agentName, friendId: request.friendId, error: error instanceof Error ? error.message : String(error) },
+            });
+            return { status: "failed", detail: error instanceof Error ? error.message : String(error) };
+        }
+    };
+}
+function defaultNotifyOwner(agentName) {
+    return async (input) => {
+        const { sendTelegramOwnerNotice } = await Promise.resolve().then(() => __importStar(require("../../senses/telegram")));
+        await sendTelegramOwnerNotice(agentName, { ...input, signal: AbortSignal.timeout(30_000) });
+    };
+}

package/dist/heart/daemon/daemon-entry.js

@@ -55,6 +55,7 @@ const habit_scheduler_1 = require("../habits/habit-scheduler");
 const habit_migration_1 = require("../habits/habit-migration");
 const await_scheduler_1 = require("../awaiting/await-scheduler");
 const await_expiry_1 = require("../awaiting/await-expiry");
+const a2a_await_delivery_1 = require("../awaiting/a2a-await-delivery");
 const await_runtime_state_1 = require("../awaiting/await-runtime-state");
 const os_cron_deps_1 = require("./os-cron-deps");
 const os_cron_1 = require("./os-cron");
@@ -828,6 +829,7 @@ void (0, daemon_bootstrap_startup_1.startDaemonAfterContainerCredentialBootstrap
                         deliveryDeps: {
                             agentName: agent,
                             deliverers: {
+                                a2a: (0, a2a_await_delivery_1.createA2AAwaitOwnerDeliverer)(agent),
                                 telegram: async (request) => {
                                     const { sendTelegramAwaitFollowUp } = await Promise.resolve().then(() => __importStar(require("../../senses/telegram")));
                                     return sendTelegramAwaitFollowUp(agent, request);

package/dist/repertoire/tools-awaiting.js

@@ -39,6 +39,8 @@ exports.setAwaitToolDeps = setAwaitToolDeps;
 exports.resetAwaitToolDeps = resetAwaitToolDeps;
 exports.cancelAwaitTool = cancelAwaitTool;
 exports.cancelStaleAwait = cancelStaleAwait;
+exports.isBrokenBindingReason = isBrokenBindingReason;
+exports.failBrokenAwait = failBrokenAwait;
 exports.inspectRelationshipFollowUp = inspectRelationshipFollowUp;
 exports.hasActiveRelationshipFollowUp = hasActiveRelationshipFollowUp;
 exports.hasActiveExternalEventAwait = hasActiveExternalEventAwait;
@@ -51,6 +53,7 @@ const session_events_1 = require("../heart/session-events");
 const runtime_1 = require("../nerves/runtime");
 const await_parser_1 = require("../heart/awaiting/await-parser");
 const await_alert_1 = require("../heart/awaiting/await-alert");
+const a2a_await_delivery_1 = require("../heart/awaiting/a2a-await-delivery");
 const pending_1 = require("../mind/pending");
 const router_1 = require("../heart/external-events/router");
 const obligations_1 = require("../arc/obligations");
@@ -115,9 +118,8 @@ function resetAwaitToolDeps() {
     injected = {};
 }
 function resolveDeliveryDeps(agentName) {
-    if (injected.buildDeliveryDeps)
-        return injected.buildDeliveryDeps(agentName);
-    return defaultDeliveryDeps(agentName);
+    const deps = injected.buildDeliveryDeps ? injected.buildDeliveryDeps(agentName) : defaultDeliveryDeps(agentName);
+    return { ...deps, deliverers: { a2a: (0, a2a_await_delivery_1.createA2AAwaitOwnerDeliverer)(agentName), ...deps.deliverers } };
 }
 function fileAwait(args, agentRoot, agentName, sessionFriendId, sessionChannel, sessionKey, requestId) {
     const nameError = validateName(args.name);
@@ -360,6 +362,34 @@ function cancelStaleAwait(agentRoot, agentName, name, reason) {
     if (result.canceled !== name)
         throw new Error(`Stale await could not be archived for repair: ${result.error ?? name}`);
 }
+/** Binding losses that mean the await is broken, as opposed to finished (fulfilled, expired). */
+function isBrokenBindingReason(reason) {
+    return reason === "request obligation is missing" || reason === "request obligation binding no longer matches";
+}
+/**
+ * An await that can never run is ended, not retried: archived as canceled with the reason, logged as an error, and
+ * the private runtime is told once that the follow-up it promised will not happen. Without this the await stayed
+ * pending and every scheduled wake failed again, silently, for days.
+ */
+function failBrokenAwait(agentRoot, agentName, awaitName, reason) {
+    cancelStaleAwait(agentRoot, agentName, awaitName, reason);
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "senses",
+        event: "senses.relationship_await_failed",
+        message: "relationship await could not run and was canceled",
+        meta: { agentName, awaitName, reason },
+    });
+    (0, pending_1.queuePendingMessageOnce)((0, pending_1.getPrivateRuntimePendingDir)(agentName), {
+        from: agentName,
+        friendId: "self",
+        channel: "inner",
+        key: "dialog",
+        content: `my await "${awaitName}" was canceled because it could not run (${reason}). the follow-up it promised did not happen; i should tell my owner and decide whether to file it again.`,
+        timestamp: Date.now(),
+        packetId: `await-failed:${awaitName}`,
+    });
+}
 function inspectRelationshipFollowUp(agentRoot, input) {
     const awaiting = readAwaitDefinition(agentRoot, input.awaitName);
     if (!awaiting)
@@ -523,7 +553,10 @@ exports.awaitingToolDefinitions = [
                     binding = inspectRelationshipFollowUp(agentRoot, { friendId: session.friendId, channel: session.channel, key: session.key, requestId, awaitName });
                 }
                 if (binding && !binding.active) {
-                    cancelStaleAwait(agentRoot, agentName, awaitName, binding.reason);
+                    if (isBrokenBindingReason(binding.reason))
+                        failBrokenAwait(agentRoot, agentName, awaitName, binding.reason);
+                    else
+                        cancelStaleAwait(agentRoot, agentName, awaitName, binding.reason);
                     return JSON.stringify({ error: binding.reason });
                 }
                 if (!binding?.active)

package/dist/senses/a2a-entry.js

@@ -46,6 +46,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");
 (0, runtime_logging_1.configureDaemonRuntimeLogger)("a2a");
 (0, runtime_1.emitNervesEvent)({
     component: "senses",
@@ -99,7 +100,7 @@ Promise.all([
         // one is announced in the owner's Telegram chat before it runs.
         ...(agentName === "sanctuary" ? {
             delegation: {
-                principalProfileId: "sanctuary-owner",
+                principalProfileId: delegated_command_1.A2A_PRINCIPAL_PROFILE_ID,
                 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

@@ -57,6 +57,7 @@ const prompt_1 = require("../mind/prompt");
 const mcp_manager_1 = require("../repertoire/mcp-manager");
 const tools_1 = require("../repertoire/tools");
 const tools_awaiting_1 = require("../repertoire/tools-awaiting");
+const delegated_command_1 = require("../a2a/delegated-command");
 const relationship_authorization_1 = require("../repertoire/relationship-authorization");
 const run_ledger_1 = require("../heart/run-ledger");
 const bundle_manifest_1 = require("../mind/bundle-manifest");
@@ -99,6 +100,10 @@ const DEFAULT_PRIVATE_RUNTIME_INSTINCTS = [
         enabled: true,
     },
 ];
+/** The await file's provenance can never be satisfied; waking it again cannot help. */
+class InvalidRelationshipAwaitProvenanceError extends Error {
+}
+const RELATIONSHIP_AWAIT_CHANNELS = new Set(["telegram", "a2a"]);
 class StaleRelationshipAwaitError extends Error {
     reason;
     constructor(reason) {
@@ -124,7 +129,7 @@ function relationshipAwaitCoordinates(awaitFile) {
     if (!awaitFile.request_id) {
         if (awaitFile.filed_from === "external-event" && awaitFile.filed_for_friend_id && awaitFile.filed_from_key) {
             if (Buffer.byteLength(awaitFile.filed_for_friend_id) > 256 || Buffer.byteLength(awaitFile.filed_from_key) > 1_024)
-                throw new Error("Relationship await provenance is invalid");
+                throw new InvalidRelationshipAwaitProvenanceError("Relationship await provenance is invalid");
             return { friendId: awaitFile.filed_for_friend_id, channel: awaitFile.filed_from, key: awaitFile.filed_from_key, requestId: null };
         }
         const isSystemAwait = awaitFile.filed_for_friend_id === null
@@ -132,16 +137,38 @@ function relationshipAwaitCoordinates(awaitFile) {
             && (awaitFile.filed_from === null || awaitFile.filed_from === "unknown" || awaitFile.filed_from === "cli");
         if (isSystemAwait)
             return null;
-        throw new Error("Relationship await provenance is incomplete or legacy");
+        throw new InvalidRelationshipAwaitProvenanceError("Relationship await provenance is incomplete or legacy");
     }
     if (values.some((value) => value === null))
-        throw new Error("Relationship await provenance is incomplete or legacy");
+        throw new InvalidRelationshipAwaitProvenanceError("Relationship await provenance is incomplete or legacy");
     const [friendId, channel, key] = values;
-    if (channel !== "telegram" || Buffer.byteLength(friendId) > 256 || Buffer.byteLength(channel) > 64 || Buffer.byteLength(key) > 1_024 || Buffer.byteLength(awaitFile.request_id) > 256) {
-        throw new Error("Relationship await provenance is invalid");
+    if (!RELATIONSHIP_AWAIT_CHANNELS.has(channel) || Buffer.byteLength(friendId) > 256 || Buffer.byteLength(channel) > 64 || Buffer.byteLength(key) > 1_024 || Buffer.byteLength(awaitFile.request_id) > 256) {
+        throw new InvalidRelationshipAwaitProvenanceError("Relationship await provenance is invalid");
     }
     return { friendId, channel, key, requestId: awaitFile.request_id };
 }
+/**
+ * An A2A peer is reactive-only: it cannot be pushed to, and on its own it has no authority to be followed up with.
+ * Only a peer still holding the operator-set principal-command grant keeps follow-up authority, and that authority
+ * is the delegating owner's, resolved exactly as the delegated command resolved it. Revoking the grant ends it.
+ */
+async function resolveA2APrincipal(agentRoot, store, peer, requestId) {
+    if (peer.delegationGrant?.scope !== "principal_commands" || peer.trustLevel !== "family")
+        throw new StaleRelationshipAwaitError("A2A peer no longer holds a delegation grant");
+    // listAll() swallows an unreadable directory or record as "no friend": only a verified complete read may end an await.
+    const entries = fs.readdirSync(path.join(agentRoot, "friends")).filter((entry) => entry.endsWith(".json"));
+    const friends = await store.listAll();
+    if (friends.length !== entries.length)
+        throw new Error("Relationship await authority friends could not be read completely");
+    const owners = friends.filter((candidate) => candidate.capabilityProfileId === delegated_command_1.A2A_PRINCIPAL_PROFILE_ID
+        && candidate.trustLevel === "family" && candidate.admissionState === "active");
+    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))
+        throw new StaleRelationshipAwaitError("request was not a delegated command the owner was notified of");
+    return owner;
+}
 async function resolveRelationshipAwaitAuthority(agentRoot, store, registry, coordinates) {
     const friend = await store.get(coordinates.friendId);
     if (!friend) {
@@ -158,10 +185,15 @@ async function resolveRelationshipAwaitAuthority(agentRoot, store, registry, coo
     if (coordinates.channel === "external-event" && (friend.capabilityProfileId !== "sanctuary-owner" || !registry.profiles["sanctuary-event"])) {
         throw new StaleRelationshipAwaitError("admission or profile is not active");
     }
+    const subjectFriend = coordinates.channel === "a2a" ? await resolveA2APrincipal(agentRoot, store, friend, coordinates.requestId) : friend;
     const authorization = coordinates.channel === "external-event"
         ? (0, relationship_authorization_2.createRelationshipAuthorizationEvaluator)({ friend, registry, profileId: "sanctuary-event", requestPhase: "follow_up" })
-        : (0, relationship_authorization_2.createRelationshipAuthorizationEvaluator)({ friend, registry, requestId: coordinates.requestId, requestPhase: "follow_up" });
-    if (authorization.subject.friendId !== coordinates.friendId)
+        : coordinates.channel === "a2a"
+            // The follow-up carries the delegating owner's authority (as the delegated command did), but the turn profile
+            // is the peer's own, which can only narrow it: never wider than a peer chat turn or the original command.
+            ? (0, relationship_authorization_2.createRelationshipAuthorizationEvaluator)({ friend: subjectFriend, registry, profileId: friend.capabilityProfileId, requestId: coordinates.requestId, requestPhase: "follow_up" })
+            : (0, relationship_authorization_2.createRelationshipAuthorizationEvaluator)({ friend, registry, requestId: coordinates.requestId, requestPhase: "follow_up" });
+    if (authorization.subject.friendId !== subjectFriend.id)
         throw new Error("Relationship await authority friend is ambiguous");
     if (!authorization.authorizeTool("resolve_await").allowed)
         throw new StaleRelationshipAwaitError("admission or profile is not active");
@@ -1157,7 +1189,16 @@ async function runPrivateRuntimeTurn(options) {
             const selfContext = { friend: selfFriend, channel: innerCapabilities };
             const mcpOwner = { agentName, agentRoot: (0, identity_1.getAgentRoot)(agentName) };
             const mcpManager = await (0, mcp_manager_1.getSharedMcpManager)(mcpOwner) ?? undefined;
-            const relationshipAwaitCoordinatesValue = parsedAwait ? relationshipAwaitCoordinates(parsedAwait) : null;
+            const relationshipAwaitCoordinatesValue = parsedAwait ? (() => {
+                try {
+                    return relationshipAwaitCoordinates(parsedAwait);
+                }
+                catch (error) {
+                    // relationshipAwaitCoordinates only ever throws provenance errors: none of them can be fixed by waking again.
+                    (0, tools_awaiting_1.failBrokenAwait)((0, identity_1.getAgentRoot)(agentName), agentName, parsedAwait.name, error.message);
+                    throw error;
+                }
+            })() : null;
             const relationshipAwait = relationshipAwaitCoordinatesValue
                 ? await (async () => {
                     const agentRoot = (0, identity_1.getAgentRoot)(agentName);
@@ -1175,7 +1216,10 @@ async function runPrivateRuntimeTurn(options) {
                                 now: now().getTime(),
                             });
                         if (!binding.active) {
-                            (0, tools_awaiting_1.cancelStaleAwait)(agentRoot, agentName, parsedAwait.name, binding.reason);
+                            if ((0, tools_awaiting_1.isBrokenBindingReason)(binding.reason))
+                                (0, tools_awaiting_1.failBrokenAwait)(agentRoot, agentName, parsedAwait.name, binding.reason);
+                            else
+                                (0, tools_awaiting_1.cancelStaleAwait)(agentRoot, agentName, parsedAwait.name, binding.reason);
                             throw new Error(`Relationship await authority binding is missing, stale, or ambiguous: ${binding.reason}`);
                         }
                     };
@@ -1188,7 +1232,7 @@ async function runPrivateRuntimeTurn(options) {
                         }
                         catch (error) {
                             if (error instanceof StaleRelationshipAwaitError)
-                                (0, tools_awaiting_1.cancelStaleAwait)(agentRoot, agentName, parsedAwait.name, error.reason);
+                                (0, tools_awaiting_1.failBrokenAwait)(agentRoot, agentName, parsedAwait.name, error.reason);
                             throw error;
                         }
                     };

package/npm-shrinkwrap.json

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