@ouro.bot/cli 0.1.0-alpha.49 → 0.1.0-alpha.50

package/dist/senses/inner-dialog.js

@@ -57,6 +57,9 @@ const tokens_1 = require("../mind/friends/tokens");
 const pipeline_1 = require("./pipeline");
 const nerves_1 = require("../nerves");
 const runtime_1 = require("../nerves/runtime");
+const manager_1 = require("../heart/bridges/manager");
+const session_activity_1 = require("../heart/session-activity");
+const bluebubbles_1 = require("./bluebubbles");
 const DEFAULT_INNER_DIALOG_INSTINCTS = [
     {
         id: "heartbeat_checkin",
@@ -244,6 +247,83 @@ function writeInnerDialogRuntimeState(sessionFilePath, state) {
         });
     }
 }
+function writePendingEnvelope(pendingDir, message) {
+    fs.mkdirSync(pendingDir, { recursive: true });
+    const fileName = `${message.timestamp}-${Math.random().toString(36).slice(2, 10)}.json`;
+    const filePath = path.join(pendingDir, fileName);
+    fs.writeFileSync(filePath, JSON.stringify(message, null, 2), "utf8");
+}
+function sessionMatchesActivity(activity, session) {
+    return activity.friendId === session.friendId
+        && activity.channel === session.channel
+        && activity.key === session.key;
+}
+function resolveBridgePreferredSession(delegatedFrom, sessionActivity) {
+    if (!delegatedFrom.bridgeId)
+        return null;
+    const bridge = (0, manager_1.createBridgeManager)().getBridge(delegatedFrom.bridgeId);
+    if (!bridge || bridge.lifecycle === "completed" || bridge.lifecycle === "cancelled") {
+        return null;
+    }
+    return sessionActivity.find((activity) => activity.friendId === delegatedFrom.friendId
+        && activity.channel !== "inner"
+        && bridge.attachedSessions.some((session) => sessionMatchesActivity(activity, session))) ?? null;
+}
+async function tryDeliverDelegatedCompletion(target, outboundEnvelope) {
+    if (target.channel !== "bluebubbles") {
+        return false;
+    }
+    const result = await (0, bluebubbles_1.sendProactiveBlueBubblesMessageToSession)({
+        friendId: target.friendId,
+        sessionKey: target.key,
+        text: outboundEnvelope.content,
+    });
+    return result.delivered;
+}
+async function routeDelegatedCompletion(agentRoot, agentName, completion, drainedPending, timestamp) {
+    const delegated = (drainedPending ?? []).find((message) => message.delegatedFrom);
+    if (!delegated?.delegatedFrom || !completion?.answer?.trim()) {
+        return;
+    }
+    const delegatedFrom = delegated.delegatedFrom;
+    const outboundEnvelope = {
+        from: agentName,
+        friendId: delegatedFrom.friendId,
+        channel: delegatedFrom.channel,
+        key: delegatedFrom.key,
+        content: completion.answer.trim(),
+        timestamp,
+        delegatedFrom,
+    };
+    const sessionActivity = (0, session_activity_1.listSessionActivity)({
+        sessionsDir: path.join(agentRoot, "state", "sessions"),
+        friendsDir: path.join(agentRoot, "friends"),
+        agentName,
+    });
+    const bridgeTarget = resolveBridgePreferredSession(delegatedFrom, sessionActivity);
+    if (bridgeTarget) {
+        if (await tryDeliverDelegatedCompletion(bridgeTarget, outboundEnvelope)) {
+            return;
+        }
+        writePendingEnvelope((0, pending_1.getPendingDir)(agentName, bridgeTarget.friendId, bridgeTarget.channel, bridgeTarget.key), outboundEnvelope);
+        return;
+    }
+    const freshest = (0, session_activity_1.findFreshestFriendSession)({
+        sessionsDir: path.join(agentRoot, "state", "sessions"),
+        friendsDir: path.join(agentRoot, "friends"),
+        agentName,
+        friendId: delegatedFrom.friendId,
+        activeOnly: true,
+    });
+    if (freshest && freshest.channel !== "inner") {
+        if (await tryDeliverDelegatedCompletion(freshest, outboundEnvelope)) {
+            return;
+        }
+        writePendingEnvelope((0, pending_1.getPendingDir)(agentName, freshest.friendId, freshest.channel, freshest.key), outboundEnvelope);
+        return;
+    }
+    writePendingEnvelope((0, pending_1.getDeferredReturnDir)(agentName, delegatedFrom.friendId), outboundEnvelope);
+}
 // 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) {
@@ -274,6 +354,8 @@ async function runInnerDialogTurn(options) {
     const now = options?.now ?? (() => new Date());
     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,
@@ -316,8 +398,8 @@ async function runInnerDialogTurn(options) {
         const userMessage = { role: "user", content: userContent };
         // ── Session loader: wraps existing session logic ──────────────────
         const innerCapabilities = (0, channel_1.getChannelCapabilities)("inner");
-        const pendingDir = (0, pending_1.getInnerDialogPendingDir)((0, identity_1.getAgentName)());
-        const selfFriend = createSelfFriend((0, identity_1.getAgentName)());
+        const pendingDir = (0, pending_1.getInnerDialogPendingDir)(agentName);
+        const selfFriend = createSelfFriend(agentName);
         const selfContext = { friend: selfFriend, channel: innerCapabilities };
         const sessionLoader = {
             loadOrCreate: async () => {
@@ -358,6 +440,7 @@ async function runInnerDialogTurn(options) {
                 skipConfirmation: true,
             },
         });
+        await routeDelegatedCompletion(agentRoot, agentName, result.completion, result.drainedPending, now().getTime());
         const resultMessages = result.messages ?? [];
         const assistantPreview = extractAssistantPreview(resultMessages);
         const toolCalls = extractToolCallNames(resultMessages);
@@ -382,6 +465,7 @@ async function runInnerDialogTurn(options) {
             messages: resultMessages,
             usage: result.usage,
             sessionPath: result.sessionPath ?? sessionFilePath,
+            completion: result.completion,
         };
     }
     finally {

package/dist/senses/pipeline.js

@@ -9,6 +9,50 @@ exports.handleInboundTurn = handleInboundTurn;
 const runtime_1 = require("../nerves/runtime");
 const continuity_1 = require("./continuity");
 const manager_1 = require("../heart/bridges/manager");
+const identity_1 = require("../heart/identity");
+const tasks_1 = require("../repertoire/tasks");
+const session_activity_1 = require("../heart/session-activity");
+const active_work_1 = require("../heart/active-work");
+const delegation_1 = require("../heart/delegation");
+const thoughts_1 = require("../heart/daemon/thoughts");
+const pending_1 = require("../mind/pending");
+function emptyTaskBoard() {
+    return {
+        compact: "",
+        full: "",
+        byStatus: {
+            drafting: [],
+            processing: [],
+            validating: [],
+            collaborating: [],
+            paused: [],
+            blocked: [],
+            done: [],
+        },
+        actionRequired: [],
+        unresolvedDependencies: [],
+        activeSessions: [],
+        activeBridges: [],
+    };
+}
+function readInnerWorkState() {
+    try {
+        const agentRoot = (0, identity_1.getAgentRoot)();
+        const pendingDir = (0, pending_1.getInnerDialogPendingDir)((0, identity_1.getAgentName)());
+        const sessionPath = (0, thoughts_1.getInnerDialogSessionPath)(agentRoot);
+        const status = (0, thoughts_1.readInnerDialogStatus)(sessionPath, pendingDir);
+        return {
+            status: status.processing === "started" ? "running" : "idle",
+            hasPending: status.queue !== "clear",
+        };
+    }
+    catch {
+        return {
+            status: "idle",
+            hasPending: false,
+        };
+    }
+}
 // ── Pipeline ──────────────────────────────────────────────────────
 async function handleInboundTurn(input) {
     // Step 1: Resolve friend
@@ -57,6 +101,9 @@ async function handleInboundTurn(input) {
     const session = await input.sessionLoader.loadOrCreate();
     const sessionMessages = session.messages;
     let mustResolveBeforeHandoff = (0, continuity_1.resolveMustResolveBeforeHandoff)(session.state?.mustResolveBeforeHandoff === true, input.continuityIngressTexts);
+    const lastFriendActivityAt = input.channel === "inner"
+        ? session.state?.lastFriendActivityAt
+        : new Date().toISOString();
     const currentObligation = input.continuityIngressTexts
         ?.map((text) => text.trim())
         .filter((text) => text.length > 0)
@@ -73,8 +120,51 @@ async function handleInboundTurn(input) {
         key: currentSession.key,
     });
     const bridgeContext = (0, manager_1.formatBridgeContext)(activeBridges) || undefined;
-    // Step 4: Drain pending messages
-    const pending = input.drainPending(input.pendingDir);
+    let sessionActivity = [];
+    try {
+        const agentRoot = (0, identity_1.getAgentRoot)();
+        sessionActivity = (0, session_activity_1.listSessionActivity)({
+            sessionsDir: `${agentRoot}/state/sessions`,
+            friendsDir: `${agentRoot}/friends`,
+            agentName: (0, identity_1.getAgentName)(),
+            currentSession: {
+                friendId: currentSession.friendId,
+                channel: currentSession.channel,
+                key: currentSession.key,
+            },
+        });
+    }
+    catch {
+        sessionActivity = [];
+    }
+    const activeWorkFrame = (0, active_work_1.buildActiveWorkFrame)({
+        currentSession,
+        currentObligation,
+        mustResolveBeforeHandoff,
+        inner: readInnerWorkState(),
+        bridges: activeBridges,
+        taskBoard: (() => {
+            try {
+                return (0, tasks_1.getTaskModule)().getBoard();
+            }
+            catch {
+                return emptyTaskBoard();
+            }
+        })(),
+        friendActivity: sessionActivity,
+    });
+    const delegationDecision = (0, delegation_1.decideDelegation)({
+        channel: input.channel,
+        ingressTexts: input.continuityIngressTexts ?? [],
+        activeWork: activeWorkFrame,
+        mustResolveBeforeHandoff,
+    });
+    // Step 4: Drain deferred friend returns, then ordinary per-session pending.
+    const deferredReturns = input.channel === "inner"
+        ? []
+        : (input.drainDeferredReturns?.(resolvedContext.friend.id) ?? []);
+    const sessionPending = input.drainPending(input.pendingDir);
+    const pending = [...deferredReturns, ...sessionPending];
     // Assemble messages: session messages + pending (formatted) + inbound user messages
     if (pending.length > 0) {
         // Format pending messages and prepend to the user content
@@ -112,6 +202,8 @@ async function handleInboundTurn(input) {
     const runAgentOptions = {
         ...input.runAgentOptions,
         bridgeContext,
+        activeWorkFrame,
+        delegationDecision,
         currentSessionKey: currentSession.key,
         currentObligation,
         mustResolveBeforeHandoff,
@@ -130,11 +222,15 @@ async function handleInboundTurn(input) {
     };
     const result = await input.runAgent(sessionMessages, input.callbacks, input.channel, input.signal, runAgentOptions);
     // Step 6: postTurn
+    const continuingState = {
+        ...(mustResolveBeforeHandoff ? { mustResolveBeforeHandoff: true } : {}),
+        ...(typeof lastFriendActivityAt === "string" ? { lastFriendActivityAt } : {}),
+    };
     const nextState = result.outcome === "complete" || result.outcome === "blocked" || result.outcome === "superseded"
-        ? undefined
-        : mustResolveBeforeHandoff
-            ? { mustResolveBeforeHandoff: true }
-            : undefined;
+        ? (typeof lastFriendActivityAt === "string"
+            ? { lastFriendActivityAt }
+            : undefined)
+        : (Object.keys(continuingState).length > 0 ? continuingState : undefined);
     input.postTurn(sessionMessages, session.sessionPath, result.usage, undefined, nextState);
     // Step 7: Token accumulation
     await input.accumulateFriendTokens(input.friendStore, resolvedContext.friend.id, result.usage);
@@ -152,7 +248,9 @@ async function handleInboundTurn(input) {
         gateResult,
         usage: result.usage,
         turnOutcome: result.outcome,
+        completion: result.completion,
         sessionPath: session.sessionPath,
         messages: sessionMessages,
+        drainedPending: pending,
     };
 }

package/dist/senses/teams.js

@@ -63,6 +63,7 @@ const resolver_1 = require("../mind/friends/resolver");
 const tokens_1 = require("../mind/friends/tokens");
 const turn_coordinator_1 = require("../heart/turn-coordinator");
 const identity_1 = require("../heart/identity");
+const progress_story_1 = require("../heart/progress-story");
 const http = __importStar(require("http"));
 const path = __importStar(require("path"));
 const trust_gate_1 = require("./trust-gate");
@@ -334,13 +335,21 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
             if (!streamHasContent)
                 safeEmit("⏳");
             const argSummary = (0, tools_1.summarizeArgs)(name, args) || Object.keys(args).join(", ");
-            safeUpdate(`running ${name} (${argSummary})...`);
+            safeUpdate((0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
+                scope: "shared-work",
+                phase: "processing",
+                objective: `running ${name} (${argSummary})...`,
+            })));
             hadToolRun = true;
         },
         onToolEnd: (name, summary, success) => {
             stopPhraseRotation();
             const msg = (0, format_1.formatToolResult)(name, summary, success);
-            safeUpdate(msg);
+            safeUpdate((0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
+                scope: "shared-work",
+                phase: "processing",
+                objective: msg,
+            })));
         },
         onKick: () => {
             stopPhraseRotation();
@@ -351,7 +360,11 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
             stopPhraseRotation();
             if (stopped)
                 return;
-            const msg = (0, format_1.formatError)(error);
+            const msg = (0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
+                scope: "shared-work",
+                phase: "errored",
+                outcomeText: (0, format_1.formatError)(error),
+            }));
             if (severity === "transient") {
                 safeUpdate(msg);
             }
@@ -560,6 +573,7 @@ async function handleTeamsMessage(text, stream, conversationId, teamsContext, se
             hasExistingGroupWithFamily: false,
             enforceTrustGate: trust_gate_1.enforceTrustGate,
             drainPending: pending_1.drainPending,
+            drainDeferredReturns: (deferredFriendId) => (0, pending_1.drainDeferredReturns)((0, identity_1.getAgentName)(), deferredFriendId),
             runAgent: (msgs, cb, channel, sig, opts) => (0, core_1.runAgent)(msgs, cb, channel, sig, {
                 ...opts,
                 toolContext: {

package/package.json

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