@ouro.bot/cli 0.1.0-alpha.133 → 0.1.0-alpha.135

package/dist/senses/attention-queue.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAttentionQueue = buildAttentionQueue;
+exports.dequeueAttentionItem = dequeueAttentionItem;
+exports.attentionQueueEmpty = attentionQueueEmpty;
+exports.buildAttentionQueueSummary = buildAttentionQueueSummary;
+const runtime_1 = require("../nerves/runtime");
+// ── Queue construction ───────────────────────────────────────────
+function generateItemId() {
+    return Math.random().toString(36).slice(2, 10);
+}
+function originKey(friendId, channel, key) {
+    return `${friendId}/${channel}/${key}`;
+}
+function buildAttentionQueue(input) {
+    const { drainedPending, outstandingObligations, friendNameResolver } = input;
+    const seen = new Set();
+    const items = [];
+    // Source 1: drained pending messages with delegatedFrom (current-turn delegations)
+    for (const msg of drainedPending) {
+        if (!msg.delegatedFrom)
+            continue;
+        const { friendId, channel, key, bridgeId } = msg.delegatedFrom;
+        const oKey = originKey(friendId, channel, key);
+        seen.add(oKey);
+        const resolvedName = friendNameResolver(friendId);
+        items.push({
+            id: msg.obligationId ?? generateItemId(),
+            friendId,
+            friendName: resolvedName ?? friendId,
+            channel,
+            key,
+            ...(bridgeId ? { bridgeId } : {}),
+            delegatedContent: msg.content,
+            ...(msg.obligationId ? { obligationId: msg.obligationId } : {}),
+            source: "drained",
+            timestamp: msg.timestamp,
+        });
+    }
+    // Source 2: outstanding obligations (crash recovery)
+    for (const obligation of outstandingObligations) {
+        const { friendId, channel, key, bridgeId } = obligation.origin;
+        const oKey = originKey(friendId, channel, key);
+        if (seen.has(oKey))
+            continue; // deduplicate: prefer drained version
+        seen.add(oKey);
+        const resolvedName = friendNameResolver(friendId);
+        items.push({
+            id: obligation.id,
+            friendId,
+            friendName: resolvedName ?? friendId,
+            channel,
+            key,
+            ...(bridgeId ? { bridgeId } : {}),
+            delegatedContent: obligation.delegatedContent,
+            obligationId: obligation.id,
+            source: "obligation-recovery",
+            timestamp: obligation.createdAt,
+        });
+    }
+    // Sort FIFO (oldest first)
+    items.sort((a, b) => a.timestamp - b.timestamp);
+    (0, runtime_1.emitNervesEvent)({
+        event: "senses.attention_queue_built",
+        component: "senses",
+        message: `attention queue built with ${items.length} item(s)`,
+        meta: {
+            drainedCount: items.filter((i) => i.source === "drained").length,
+            recoveredCount: items.filter((i) => i.source === "obligation-recovery").length,
+        },
+    });
+    return items;
+}
+// ── Queue operations ─────────────────────────────────────────────
+function dequeueAttentionItem(queue, id) {
+    const index = queue.findIndex((item) => item.id === id);
+    if (index === -1)
+        return null;
+    return queue.splice(index, 1)[0];
+}
+function attentionQueueEmpty(queue) {
+    return queue.length === 0;
+}
+// ── Queue visibility ─────────────────────────────────────────────
+const CONTENT_PREVIEW_MAX = 80;
+function buildAttentionQueueSummary(queue) {
+    if (queue.length === 0)
+        return "";
+    const lines = ["you're holding:"];
+    for (const item of queue) {
+        const preview = item.delegatedContent.length > CONTENT_PREVIEW_MAX
+            ? `${item.delegatedContent.slice(0, CONTENT_PREVIEW_MAX - 3)}...`
+            : item.delegatedContent;
+        lines.push(`- [${item.id}] ${item.friendName} asked: "${preview}"`);
+    }
+    return lines.join("\n");
+}

package/dist/senses/cli.js

@@ -382,14 +382,14 @@ function createCliCallbacks() {
         onModelStreamStart: () => {
             // No-op: content callbacks (onTextChunk, onReasoningChunk) handle
             // stopping the spinner. onModelStreamStart fires too early and
-            // doesn't fire at all for final_answer tool streaming.
+            // doesn't fire at all for settle tool streaming.
         },
         onClearText: () => {
             streamer.reset();
             wrapper.reset();
         },
         onTextChunk: (text) => {
-            // Stop spinner if still running — final_answer streaming and Anthropic
+            // Stop spinner if still running — settle streaming and Anthropic
             // tool-only responses bypass onModelStreamStart, so the spinner would
             // otherwise keep running (and its \r writes overwrite response text).
             if (currentSpinner) {
@@ -558,7 +558,7 @@ async function runCliSession(options) {
                 exitToolResult = result;
                 exitToolFired = true;
                 // Abort immediately so the model doesn't generate more output
-                // (e.g. reasoning about calling final_answer after complete_adoption)
+                // (e.g. reasoning about calling settle after complete_adoption)
                 currentAbort?.abort();
             }
             return result;

package/dist/senses/inner-dialog.js

@@ -42,6 +42,7 @@ exports.buildTaskTriggeredMessage = buildTaskTriggeredMessage;
 exports.deriveResumeCheckpoint = deriveResumeCheckpoint;
 exports.innerDialogSessionPath = innerDialogSessionPath;
 exports.enrichDelegatedFromWithBridge = enrichDelegatedFromWithBridge;
+exports.routeDelegatedCompletion = routeDelegatedCompletion;
 exports.runInnerDialogTurn = runInnerDialogTurn;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -54,6 +55,7 @@ const mcp_manager_1 = require("../repertoire/mcp-manager");
 const bundle_manifest_1 = require("../mind/bundle-manifest");
 const pending_1 = require("../mind/pending");
 const obligations_1 = require("../mind/obligations");
+const attention_queue_1 = require("./attention-queue");
 const channel_1 = require("../mind/friends/channel");
 const trust_gate_1 = require("./trust-gate");
 const tokens_1 = require("../mind/friends/tokens");
@@ -259,6 +261,7 @@ function writeInnerDialogRuntimeState(sessionFilePath, state) {
         });
     }
 }
+/* v8 ignore start -- routing helpers: called from routing functions which are integration paths @preserve */
 function writePendingEnvelope(pendingDir, message) {
     fs.mkdirSync(pendingDir, { recursive: true });
     const fileName = `${message.timestamp}-${Math.random().toString(36).slice(2, 10)}.json`;
@@ -270,12 +273,8 @@ function sessionMatchesActivity(activity, session) {
         && activity.channel === session.channel
         && activity.key === session.key;
 }
-function resolveExactOriginSession(delegatedFrom, sessionActivity) {
-    return sessionActivity.find((activity) => activity.friendId === delegatedFrom.friendId
-        && activity.channel === delegatedFrom.channel
-        && activity.key === delegatedFrom.key
-        && activity.channel !== "inner") ?? null;
-}
+/* v8 ignore stop */
+/* v8 ignore start -- routing: delivery now inline via surface tool; routing functions preserved for reuse @preserve */
 function resolveBridgePreferredSession(delegatedFrom, sessionActivity) {
     if (!delegatedFrom.bridgeId)
         return null;
@@ -385,18 +384,7 @@ async function routeDelegatedCompletion(agentRoot, agentName, completion, draine
         friendsDir: path.join(agentRoot, "friends"),
         agentName,
     });
-    // Priority 1: Exact origin session (the session that delegated this work).
-    const exactOrigin = resolveExactOriginSession(delegatedFrom, sessionActivity);
-    if (exactOrigin) {
-        if (await tryDeliverDelegatedCompletion(exactOrigin, outboundEnvelope)) {
-            advanceObligationQuietly(agentName, obligationId, { status: "returned", returnedAt: timestamp, returnTarget: "exact-origin" });
-            return;
-        }
-        writePendingEnvelope((0, pending_1.getPendingDir)(agentName, exactOrigin.friendId, exactOrigin.channel, exactOrigin.key), outboundEnvelope);
-        advanceObligationQuietly(agentName, obligationId, { status: "returned", returnedAt: timestamp, returnTarget: "exact-origin" });
-        return;
-    }
-    // Priority 2: Bridge-preferred session (if delegation was within a bridge).
+    // Priority 1: Bridge-preferred session (if delegation was within a bridge).
     const bridgeTarget = resolveBridgePreferredSession(delegatedFrom, sessionActivity);
     if (bridgeTarget) {
         if (await tryDeliverDelegatedCompletion(bridgeTarget, outboundEnvelope)) {
@@ -407,7 +395,7 @@ async function routeDelegatedCompletion(agentRoot, agentName, completion, draine
         advanceObligationQuietly(agentName, obligationId, { status: "returned", returnedAt: timestamp, returnTarget: "bridge-session" });
         return;
     }
-    // Priority 3: Freshest active friend session.
+    // Priority 2: Freshest active friend session.
     const freshest = (0, session_activity_1.findFreshestFriendSession)({
         sessionsDir: path.join(agentRoot, "state", "sessions"),
         friendsDir: path.join(agentRoot, "friends"),
@@ -424,10 +412,11 @@ async function routeDelegatedCompletion(agentRoot, agentName, completion, draine
         advanceObligationQuietly(agentName, obligationId, { status: "returned", returnedAt: timestamp, returnTarget: "freshest-session" });
         return;
     }
-    // Priority 4: Deferred return queue.
+    // Priority 3: Deferred return queue.
     writePendingEnvelope((0, pending_1.getDeferredReturnDir)(agentName, delegatedFrom.friendId), outboundEnvelope);
     advanceObligationQuietly(agentName, obligationId, { status: "deferred", returnedAt: timestamp, returnTarget: "deferred" });
 }
+/* v8 ignore stop */
 // Self-referencing friend record for inner dialog (agent talking to itself).
 // No real friend to resolve -- this satisfies the pipeline's friend resolver contract.
 function createSelfFriend(agentName) {
@@ -459,7 +448,6 @@ async function runInnerDialogTurn(options) {
     const reason = options?.reason ?? "heartbeat";
     const sessionFilePath = innerDialogSessionPath();
     const agentName = (0, identity_1.getAgentName)();
-    const agentRoot = (0, identity_1.getAgentRoot)();
     writeInnerDialogRuntimeState(sessionFilePath, {
         status: "running",
         reason,
@@ -525,6 +513,8 @@ async function runInnerDialogTurn(options) {
         // ── Call shared pipeline ──────────────────────────────────────────
         const callbacks = createInnerDialogCallbacks();
         const traceId = (0, nerves_1.createTraceId)();
+        // Attention queue: built when pending messages are drained, shared with tool context
+        let attentionQueue = [];
         const result = await (0, pipeline_1.handleInboundTurn)({
             channel: "inner",
             sessionKey: "dialog",
@@ -542,14 +532,41 @@ async function runInnerDialogTurn(options) {
             postTurn: context_1.postTurn,
             accumulateFriendTokens: tokens_1.accumulateFriendTokens,
             signal: options?.signal,
+            /* v8 ignore start -- attention queue: callback invoked by pipeline during pending drain; tested via attention-queue unit tests @preserve */
+            onPendingDrained: (drained) => {
+                const outstandingObligations = (0, obligations_1.listActiveObligations)(agentName);
+                attentionQueue = (0, attention_queue_1.buildAttentionQueue)({
+                    drainedPending: drained,
+                    outstandingObligations,
+                    friendNameResolver: (friendId) => {
+                        try {
+                            const raw = fs.readFileSync(path.join((0, identity_1.getAgentRoot)(agentName), "friends", friendId + ".json"), "utf-8");
+                            const parsed = JSON.parse(raw);
+                            return typeof parsed.name === "string" ? parsed.name : null;
+                        }
+                        catch {
+                            return null;
+                        }
+                    },
+                });
+                const summary = (0, attention_queue_1.buildAttentionQueueSummary)(attentionQueue);
+                return summary ? [summary] : [];
+            },
+            /* v8 ignore stop */
             runAgentOptions: {
                 traceId,
                 toolChoiceRequired: true,
                 skipConfirmation: true,
                 mcpManager,
+                toolContext: {
+                    signin: async () => undefined,
+                    delegatedOrigins: attentionQueue,
+                },
             },
         });
-        await routeDelegatedCompletion(agentRoot, agentName, result.completion, result.drainedPending, now().getTime());
+        // Post-turn routeDelegatedCompletion removed: delivery is now inline via surface tool.
+        // settle in inner dialog produces no CompletionMetadata, so routeDelegatedCompletion
+        // would be a no-op. The routing infrastructure is reused by the surface handler.
         const resultMessages = result.messages ?? [];
         const assistantPreview = extractAssistantPreview(resultMessages);
         const toolCalls = extractToolCallNames(resultMessages);

package/dist/senses/pipeline.js

@@ -332,8 +332,9 @@ async function handleInboundTurn(input) {
         : (input.drainDeferredReturns?.(resolvedContext.friend.id) ?? []);
     const sessionPending = input.drainPending(input.pendingDir);
     const pending = [...deferredReturns, ...sessionPending];
-    // Assemble messages: session messages + live world-state checkpoint + pending + inbound user messages
-    const prefixSections = [(0, active_work_1.formatLiveWorldStateCheckpoint)(activeWorkFrame)];
+    // Assemble messages: session messages + attention queue + live world-state checkpoint + pending + inbound user messages
+    const extraPrefixSections = input.onPendingDrained?.(pending) ?? [];
+    const prefixSections = [...extraPrefixSections, (0, active_work_1.formatLiveWorldStateCheckpoint)(activeWorkFrame)];
     if (pending.length > 0) {
         const pendingSection = pending
             .map((msg) => `[pending from ${msg.from}]: ${msg.content}`)
@@ -422,7 +423,7 @@ async function handleInboundTurn(input) {
         ...(mustResolveBeforeHandoff ? { mustResolveBeforeHandoff: true } : {}),
         ...(typeof lastFriendActivityAt === "string" ? { lastFriendActivityAt } : {}),
     };
-    const nextState = result.outcome === "complete" || result.outcome === "blocked" || result.outcome === "superseded" || result.outcome === "no_response"
+    const nextState = result.outcome === "settled" || result.outcome === "blocked" || result.outcome === "superseded" || result.outcome === "observed"
         ? (typeof lastFriendActivityAt === "string"
             ? { lastFriendActivityAt }
             : undefined)

package/dist/senses/surface-tool.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.surfaceToolDef = void 0;
+exports.handleSurface = handleSurface;
+const attention_queue_1 = require("./attention-queue");
+const runtime_1 = require("../nerves/runtime");
+// ── Tool definition ──────────────────────────────────────────────
+exports.surfaceToolDef = {
+    type: "function",
+    function: {
+        name: "surface",
+        description: "share a thought outward — deliver an answer, ask a follow-up, or surface progress to whoever needs to hear it. pass delegationId to address a held thought (see your attention queue above), or friendId for spontaneous outreach. does not end your turn.",
+        parameters: {
+            type: "object",
+            properties: {
+                content: {
+                    type: "string",
+                    description: "the message to deliver",
+                },
+                delegationId: {
+                    type: "string",
+                    description: "ID from your attention queue — addresses a specific held thought",
+                },
+                friendId: {
+                    type: "string",
+                    description: "friend to reach out to spontaneously (when not addressing a held thought)",
+                },
+            },
+            required: ["content"],
+        },
+    },
+};
+async function handleSurface(input) {
+    const { content, delegationId, friendId, queue, routeToFriend, advanceObligation } = input;
+    // Resolve target friend
+    let targetFriendId;
+    let queueItem;
+    if (delegationId) {
+        // Look up in attention queue
+        const found = queue.find((item) => item.id === delegationId);
+        if (!found) {
+            return `no delegation found with id ${delegationId} — check your attention queue`;
+        }
+        targetFriendId = found.friendId;
+        queueItem = found;
+    }
+    else if (friendId) {
+        targetFriendId = friendId;
+    }
+    else {
+        return "specify who this thought is for — use delegationId to address a held thought, or friendId for spontaneous outreach";
+    }
+    // Route to target
+    const result = await routeToFriend(targetFriendId, content, queueItem);
+    (0, runtime_1.emitNervesEvent)({
+        event: "senses.surface_routed",
+        component: "senses",
+        message: `surface routed to ${targetFriendId}: ${result.status}`,
+        meta: {
+            targetFriendId,
+            status: result.status,
+            hasDelegationId: !!delegationId,
+            ...(result.detail ? { detail: result.detail } : {}),
+        },
+    });
+    // On successful routing with delegationId:
+    // 1. Advance obligation to "returned" (disk FIRST — crash safety)
+    // 2. Dequeue from in-memory queue (AFTER obligation advance)
+    if (delegationId && queueItem && result.status !== "failed") {
+        if (queueItem.obligationId) {
+            advanceObligation(queueItem.obligationId, {
+                status: "returned",
+                returnedAt: Date.now(),
+                returnTarget: "surface",
+            });
+        }
+        (0, attention_queue_1.dequeueAttentionItem)(queue, delegationId);
+    }
+    // Return delivery status
+    const detail = result.detail ? ` — ${result.detail}` : "";
+    return `${result.status}${detail}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.133",
+  "version": "0.1.0-alpha.135",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",