@ouro.bot/cli 0.1.0-alpha.877 → 0.1.0-alpha.879

package/dist/heart/file-lock.js

@@ -0,0 +1,109 @@
+"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.withFileLock = withFileLock;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../nerves/runtime");
+const DEFAULT_STALE_MS = 120_000;
+const DEFAULT_WAIT_MS = 45_000;
+const DEFAULT_POLL_MS = 25;
+/**
+ * Breaks a stale lock by renaming it to a name only this caller knows, then removing that. Two waiters both seeing the
+ * same stale lock cannot both break it: only one rename succeeds, and the loser never touches a lock a third process
+ * has since taken under the original name.
+ */
+function breakStaleLock(lock) {
+    const broken = `${lock}.broken-${process.pid}-${Math.random().toString(36).slice(2)}`;
+    try {
+        fs.renameSync(lock, broken);
+    }
+    catch {
+        /* v8 ignore next -- the loser of a break race finds the lock already renamed away, and simply retries @preserve */
+        return false;
+    }
+    removeLock(broken);
+    return true;
+}
+/** The lock directory is always empty, so removing it never recurses; another process may already have broken it as stale. */
+function removeLock(lock) {
+    try {
+        fs.rmdirSync(lock);
+    }
+    catch {
+        /* v8 ignore next -- a lock broken as stale by another process is already gone @preserve */
+        return;
+    }
+}
+/**
+ * Runs `fn` while holding a named lock in `dir`. The lock is a directory, because creating one is atomic across
+ * processes, which matters here: the Butler's senses (Telegram, A2A, the private runtime) are separate processes that
+ * share one bundle on disk.
+ */
+async function withFileLock(dir, name, fn, options = {}) {
+    const staleMs = options.staleMs ?? DEFAULT_STALE_MS;
+    const waitMs = options.waitMs ?? DEFAULT_WAIT_MS;
+    const pollMs = options.pollMs ?? DEFAULT_POLL_MS;
+    fs.mkdirSync(dir, { recursive: true });
+    const lock = path.join(dir, `${name}.lock`);
+    const deadline = Date.now() + waitMs;
+    for (;;) {
+        try {
+            fs.mkdirSync(lock);
+            break;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            /* v8 ignore next -- a holder releasing between the failed mkdir and this stat reads as an old lock, which is then simply retried @preserve */
+            const heldSince = fs.statSync(lock, { throwIfNoEntry: false })?.mtimeMs ?? 0;
+            if (Date.now() - heldSince > staleMs) {
+                /* v8 ignore next -- only the waiter whose rename won reports the break @preserve */
+                if (breakStaleLock(lock))
+                    (0, runtime_1.emitNervesEvent)({ level: "warn", component: "heart", event: "heart.file_lock_broken", message: "broke a lock whose holder never released it", meta: { name, heldMs: Date.now() - heldSince } });
+                continue;
+            }
+            if (Date.now() >= deadline)
+                throw new Error(`timed out waiting for the ${name} lock`);
+            await new Promise((resolve) => setTimeout(resolve, pollMs));
+        }
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        removeLock(lock);
+    }
+}

package/dist/repertoire/guardrails.js

@@ -63,6 +63,10 @@ const PROTECTED_PATH_SEGMENTS = [
     ".ouro-cli/vault-unlock/",
     ".ouro-cli/vault-unlock-dpapi/",
     "state/policy/",
+    // What the Butler tells its escalation peers, and who may hear it: only the harness writes these, never the model.
+    "state/a2a/escalation-grants.json",
+    "state/outbox/",
+    "state/reports/",
 ];
 const PROTECTED_FILENAMES = ["agent.json", "tool-profiles.json"];
 /** The agent's psyche folder ships only from the repository (a pull request and the replay gate), so no tool writes into it. */

package/dist/repertoire/tools-awaiting.js

@@ -43,6 +43,7 @@ exports.cancelStaleAwait = cancelStaleAwait;
 exports.isBrokenBindingReason = isBrokenBindingReason;
 exports.failBrokenAwait = failBrokenAwait;
 exports.inspectRelationshipFollowUp = inspectRelationshipFollowUp;
+exports.inspectPeerAwait = inspectPeerAwait;
 exports.hasActiveRelationshipFollowUp = hasActiveRelationshipFollowUp;
 exports.hasActiveExternalEventAwait = hasActiveExternalEventAwait;
 exports.inspectExternalEventAwait = inspectExternalEventAwait;
@@ -180,6 +181,8 @@ function failedAskOwner(agentName, name, error) {
 /** At most this many ask_owner closures per requester in a rolling day, so one requester cannot make the Butler pester the owner. */
 const ASK_OWNER_DAILY_LIMIT = 3;
 const ASK_OWNER_WINDOW_MS = 24 * 60 * 60 * 1000;
+/** Across every requester who is not the owner, so many requesters together cannot flood the owner either. */
+const ASK_OWNER_NON_OWNER_DAILY_LIMIT = 6;
 function askLedgerPath(agentRoot) {
     return path.join(awaitingDir(agentRoot), ".asks.jsonl");
 }
@@ -230,7 +233,8 @@ function recentAskCount(agentRoot, filer, now) {
     return raw.split("\n").filter((line) => {
         try {
             const entry = JSON.parse(line);
-            return (entry.filer ?? null) === filer && typeof entry.at === "string" && now - Date.parse(entry.at) < ASK_OWNER_WINDOW_MS;
+            const who = filer === undefined ? entry.owner === false : (entry.filer ?? null) === filer;
+            return who && typeof entry.at === "string" && now - Date.parse(entry.at) < ASK_OWNER_WINDOW_MS;
         }
         catch {
             return false;
@@ -274,6 +278,9 @@ async function askOwnerTool(name, observation, question, choices, existing, agen
         if (!filer.isOwner && recentAskCount(agentRoot, filerId, Date.now()) >= ASK_OWNER_DAILY_LIMIT) {
             return JSON.stringify({ error: `ask_owner limit reached: this requester has already had my owner asked ${ASK_OWNER_DAILY_LIMIT} times in the last day; do not retry ask_owner, resolve with verdict 'no' with an observation and keep polling` });
         }
+        if (!filer.isOwner && recentAskCount(agentRoot, undefined, Date.now()) >= ASK_OWNER_NON_OWNER_DAILY_LIMIT) {
+            return JSON.stringify({ error: `ask_owner limit reached: my owner has already been asked ${ASK_OWNER_NON_OWNER_DAILY_LIMIT} times today on behalf of other requesters; do not retry ask_owner, resolve with verdict 'no' with an observation and keep polling` });
+        }
         const isA2A = existing.filed_from === "a2a";
         const noticeId = `await:${name}:asked_owner:${String(existing.created_at)}`;
         const question = formatOwnerQuestion(parsed.question, parsed.choices);
@@ -318,7 +325,7 @@ async function askOwnerTool(name, observation, question, choices, existing, agen
         /* v8 ignore next -- defensive: archiveAwait only fails on the file-disappears-mid-call race already covered by v8 ignore inside archiveAwait @preserve */
         if (!archive.ok)
             return JSON.stringify({ error: archive.error });
-        recordAsk(agentRoot, { filer: filerId, name, at: askedAt, question: parsed.question });
+        recordAsk(agentRoot, { filer: filerId, owner: filer.isOwner, name, at: askedAt, question: parsed.question });
         if (!tellsFriend || delivered(friendNotice))
             fulfillAwaitObligation(agentRoot, archive.file);
         (0, runtime_1.emitNervesEvent)({
@@ -643,6 +650,25 @@ function inspectRelationshipFollowUp(agentRoot, input) {
     }
     return { active: true };
 }
+/**
+ * The binding of an await filed in a plain A2A conversation: it has no request id and no obligation, only the peer's friend
+ * id and conversation key as provenance. It is live while it is still pending, was filed by that peer in that conversation,
+ * and has not outlived its max age.
+ */
+function inspectPeerAwait(agentRoot, input) {
+    const awaiting = readAwaitDefinition(agentRoot, input.awaitName);
+    if (!awaiting)
+        throw new Error(`Await ${input.awaitName} could not be verified`);
+    const matches = awaiting.status === "pending" && !awaiting.request_id && !awaiting.obligation_id
+        && awaiting.filed_for_friend_id === input.friendId && awaiting.filed_from === "a2a" && awaiting.filed_from_key === input.key;
+    if (!matches)
+        return { active: false, reason: "request obligation binding no longer matches" };
+    const maxAge = (0, cadence_1.parseCadenceToMs)(awaiting.max_age);
+    if (input.allowElapsed !== true && maxAge !== null && awaiting.created_at && (input.now ?? Date.now()) >= Date.parse(awaiting.created_at) + maxAge) {
+        return { active: false, reason: "request obligation await expired" };
+    }
+    return { active: true };
+}
 function hasActiveRelationshipFollowUp(agentRoot, input) {
     if (input.awaitName)
         return inspectRelationshipFollowUp(agentRoot, { ...input, awaitName: input.awaitName }).active;
@@ -770,6 +796,11 @@ exports.awaitingToolDefinitions = [
                 if (session?.channel === "external-event" && existing?.wake_at) {
                     binding = inspectExternalEventAwait(agentName, { recordPath: session.key, awaitName, wakeAt: existing.wake_at });
                 }
+                else if (session?.channel === "a2a" && ctx.awaitTick && !requestId && existing && !existing.request_id
+                    && existing.filed_for_friend_id === session.friendId && existing.filed_from === "a2a" && existing.filed_from_key === session.key) {
+                    // A plain peer await is resolved only by its own tick, never from a chat turn.
+                    binding = inspectPeerAwait(agentRoot, { friendId: session.friendId, key: session.key, awaitName });
+                }
                 else if (session && requestId) {
                     if (existing?.filed_for_friend_id !== session.friendId || existing.filed_from !== session.channel
                         || existing.filed_from_key !== session.key || existing.request_id !== requestId) {

package/dist/repertoire/tools-base.js

@@ -24,6 +24,7 @@ const tools_trip_1 = require("./tools-trip");
 const tools_a2a_1 = require("./tools-a2a");
 const tools_commerce_1 = require("./tools-commerce");
 const tools_awaiting_1 = require("./tools-awaiting");
+const tools_escalation_1 = require("./tools-escalation");
 const tools_obligations_1 = require("./tools-obligations");
 const tools_evolution_1 = require("./tools-evolution");
 const tools_runtime_1 = require("./tools-runtime");
@@ -75,6 +76,7 @@ exports.baseToolDefinitions = [
     ...tools_a2a_1.a2aToolDefinitions,
     ...tools_commerce_1.commerceToolDefinitions,
     ...tools_awaiting_1.awaitingToolDefinitions,
+    tools_escalation_1.reportFailureToolDefinition,
     ...tools_obligations_1.obligationToolDefinitions,
     ...tools_evolution_1.evolutionToolDefinitions,
     ...tools_orientation_1.orientationToolDefinitions,

package/dist/repertoire/tools-escalation.js

@@ -0,0 +1,84 @@
+"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.reportFailureToolDefinition = void 0;
+const path = __importStar(require("path"));
+const friends_1 = require("@ouro.bot/friends");
+const failure_reports_1 = require("../heart/failure-reports");
+const runtime_1 = require("../nerves/runtime");
+function text(value) {
+    return typeof value === "string" ? value : "";
+}
+/**
+ * Lets the agent hand a failure it cannot work around to the peers who fix it. The session comes from the runtime
+ * context, never from the model, so a report cannot be addressed to or attributed to anyone else.
+ */
+exports.reportFailureToolDefinition = {
+    tool: {
+        type: "function",
+        function: {
+            name: "report_failure",
+            description: "File a failure report for the engineers who fix you. Use it when a tool you need is missing, a tool errors in a way you cannot work around, or you are about to give up on what the owner asked. Then tell the owner you have filed it, with the short report id, in your own words. Do not ask the owner to do anything about it.",
+            parameters: {
+                type: "object",
+                properties: {
+                    ari_words: { type: "string", description: "What the owner asked for, verbatim from the conversation." },
+                    tried: { type: "string", description: "What you tried: tool names and arguments, summarized." },
+                    error: { type: "string", description: "The tool error, or the reason you gave up." },
+                    failed_tool: { type: "string", description: "The tool that failed or that you wished existed, if there is one." },
+                    severity: { type: "string", enum: ["low", "medium", "high"], description: "How much this blocks the owner." },
+                },
+                required: ["ari_words", "tried", "error"],
+                additionalProperties: false,
+            },
+        },
+    },
+    handler: async (args, ctx) => {
+        if (!ctx?.agentRoot)
+            return "report_failure is unavailable: no agent runtime.";
+        const severity = ["low", "medium", "high"].includes(args.severity) ? args.severity : "medium";
+        const store = new friends_1.FileFriendStore(path.join(ctx.agentRoot, "friends"));
+        const result = await (0, failure_reports_1.fileFailureReport)(ctx.agentRoot, store, {
+            ariWords: text(args.ari_words), tried: text(args.tried), error: text(args.error),
+            ...(text(args.failed_tool) ? { failedTool: text(args.failed_tool) } : {}),
+            severity,
+            origin: { friendId: ctx.currentSession?.friendId ?? null, channel: ctx.currentSession?.channel ?? null, key: ctx.currentSession?.key ?? null },
+        });
+        (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.report_failure", message: "failure report requested", meta: { ok: result.ok, ...(result.ok ? { duplicate: result.duplicate } : { reason: result.reason }) } });
+        if (!result.ok)
+            return `Not filed (${result.reason}): ${result.detail}`;
+        return JSON.stringify({ filed: true, reportId: result.id, shortId: result.shortId, duplicate: result.duplicate, recipients: result.recipients });
+    },
+};

package/dist/repertoire/tools.js

@@ -56,6 +56,7 @@ const SANCTUARY_RELATIONSHIP_BASE_TOOLS = new Set([
     "query_cares",
     "care_manage",
     "await_condition",
+    "report_failure",
     "resolve_await",
     "cancel_await",
     "list_recent_attachments",

package/dist/senses/a2a-entry.js

@@ -61,8 +61,9 @@ Promise.all([
     Promise.resolve().then(() => __importStar(require("../heart/runtime-credentials"))),
     Promise.resolve().then(() => __importStar(require("../heart/machine-identity"))),
     Promise.resolve().then(() => __importStar(require("@ouro.bot/friends/a2a-client"))),
+    Promise.resolve().then(() => __importStar(require("../a2a/escalation-wiring"))),
 ])
-    .then(async ([{ startA2AServer }, { loadOrMintA2AIdentity, readStoredA2ASeed }, { waitForRuntimeCredentialBootstrap, readMachineRuntimeCredentialConfig, refreshMachineRuntimeCredentialConfig, mergeMachineRuntimeCredentialConfig }, { loadOrCreateMachineIdentity }, { ready },]) => {
+    .then(async ([{ startA2AServer }, { loadOrMintA2AIdentity, readStoredA2ASeed }, { waitForRuntimeCredentialBootstrap, readMachineRuntimeCredentialConfig, refreshMachineRuntimeCredentialConfig, mergeMachineRuntimeCredentialConfig }, { loadOrCreateMachineIdentity }, { ready }, { escalationOptionsFor, sendOwnerNoticeViaTelegram },]) => {
     const os = await Promise.resolve().then(() => __importStar(require("node:os")));
     // Wait for the daemon to deliver the machine-local runtime config (carrying the
     // a2a identity seed) into the in-memory cache before we read or mint identity.
@@ -109,6 +110,7 @@ Promise.all([
                 },
             },
         } : {}),
+        ...escalationOptionsFor(agentName, (notice) => sendOwnerNoticeViaTelegram(agentName, notice)),
         ...(argValue("--host") ? { host: argValue("--host") } : {}),
         ...(Number.isInteger(port) ? { port } : {}),
         ...(argValue("--base-url") ? { baseUrl: argValue("--base-url") } : {}),

package/dist/senses/private-runtime.js

@@ -133,6 +133,12 @@ function relationshipAwaitCoordinates(awaitFile) {
                 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 };
         }
+        if (awaitFile.filed_from === "a2a" && awaitFile.filed_for_friend_id && awaitFile.filed_from_key) {
+            // Filed in a plain (non-delegated) A2A conversation: the peer and conversation are its whole provenance.
+            if (Buffer.byteLength(awaitFile.filed_for_friend_id) > 256 || Buffer.byteLength(awaitFile.filed_from_key) > 1_024)
+                throw new InvalidRelationshipAwaitProvenanceError("Relationship await provenance is invalid");
+            return { friendId: awaitFile.filed_for_friend_id, channel: "a2a", key: awaitFile.filed_from_key, requestId: null };
+        }
         const isSystemAwait = awaitFile.filed_for_friend_id === null
             && awaitFile.filed_from_key === null
             && (awaitFile.filed_from === null || awaitFile.filed_from === "unknown" || awaitFile.filed_from === "cli");
@@ -186,14 +192,23 @@ 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;
+    // A plain peer await carries the peer's own authority and nobody else's: no principal, no delegation grant.
+    const plainPeerAwait = coordinates.channel === "a2a" && coordinates.requestId === null;
+    // A peer the operator switched to no contact at all is not ticked; every other policy is held to following up on this one internal request.
+    if (plainPeerAwait && friend.initiativePolicy === "none")
+        throw new StaleRelationshipAwaitError("initiative policy denies contact");
+    const subjectFriend = coordinates.channel === "a2a" && !plainPeerAwait ? 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" })
-        : 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" });
+        : plainPeerAwait
+            // The peer's own profile and trust, nothing wider. Following up is reading its own outbox, not contacting it, so the
+            // follow-up phase is opened with an internal request id that exists only for this await and is never shown to the peer.
+            ? (0, relationship_authorization_2.createRelationshipAuthorizationEvaluator)({ friend: { ...friend, initiativePolicy: "request_follow_up_only" }, registry, profileId: friend.capabilityProfileId, requestId: `peer-await:${coordinates.key}`, requestPhase: "follow_up" })
+            : 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)
@@ -1233,14 +1248,16 @@ async function runPrivateRuntimeTurn(options) {
                             ? parsedAwait.wake_at && (0, tools_awaiting_1.hasActiveExternalEventAwait)(agentName, { recordPath: relationshipAwaitCoordinatesValue.key, awaitName: parsedAwait.name, wakeAt: parsedAwait.wake_at })
                                 ? { active: true }
                                 : { active: false, reason: "external event disposition is no longer active" }
-                            : (0, tools_awaiting_1.inspectRelationshipFollowUp)(agentRoot, {
-                                friendId: relationshipAwaitCoordinatesValue.friendId,
-                                channel: relationshipAwaitCoordinatesValue.channel,
-                                key: relationshipAwaitCoordinatesValue.key,
-                                requestId: relationshipAwaitCoordinatesValue.requestId,
-                                awaitName: parsedAwait.name,
-                                now: now().getTime(),
-                            });
+                            : relationshipAwaitCoordinatesValue.channel === "a2a" && relationshipAwaitCoordinatesValue.requestId === null
+                                ? (0, tools_awaiting_1.inspectPeerAwait)(agentRoot, { friendId: relationshipAwaitCoordinatesValue.friendId, key: relationshipAwaitCoordinatesValue.key, awaitName: parsedAwait.name, now: now().getTime() })
+                                : (0, tools_awaiting_1.inspectRelationshipFollowUp)(agentRoot, {
+                                    friendId: relationshipAwaitCoordinatesValue.friendId,
+                                    channel: relationshipAwaitCoordinatesValue.channel,
+                                    key: relationshipAwaitCoordinatesValue.key,
+                                    requestId: relationshipAwaitCoordinatesValue.requestId,
+                                    awaitName: parsedAwait.name,
+                                    now: now().getTime(),
+                                });
                         if (!binding.active) {
                             if ((0, tools_awaiting_1.isBrokenBindingReason)(binding.reason))
                                 (0, tools_awaiting_1.failBrokenAwait)(agentRoot, agentName, parsedAwait.name, binding.reason);

package/npm-shrinkwrap.json

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