@ouro.bot/cli 0.1.0-alpha.76 → 0.1.0-alpha.77

package/changelog.json

@@ -1,6 +1,15 @@
 {
   "_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.77",
+      "changes": [
+        "New: Persistent obligation store (state/obligations/*.json). Obligations survive pending message consumption so the agent always knows what it owes and to whom.",
+        "Obligations are created when send_message delegates to self or go_inward fires with a return address, and fulfilled when routeDelegatedCompletion delivers the answer.",
+        "The commitments frame now reads pending obligations from the store, giving the agent an accurate view of outstanding commitments across all sessions.",
+        "readInnerWorkState derives obligationPending from both pending messages and the obligation store, ensuring obligations are visible even after the inner dialog queue drains."
+      ]
+    },
     {
       "version": "0.1.0-alpha.76",
       "changes": [

package/dist/heart/active-work.js

@@ -108,6 +108,7 @@ function buildActiveWorkFrame(input) {
             freshestForCurrentFriend: friendSessions[0] ?? null,
             otherLiveSessionsForCurrentFriend: friendSessions,
         },
+        pendingObligations: input.pendingObligations ?? [],
         targetCandidates: input.targetCandidates ?? [],
         bridgeSuggestion: suggestBridgeForActiveWork({
             currentSession: input.currentSession,

package/dist/heart/commitments.js

@@ -3,11 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.deriveCommitments = deriveCommitments;
 exports.formatCommitments = formatCommitments;
 const runtime_1 = require("../nerves/runtime");
-function deriveCommitments(activeWorkFrame, innerJob) {
+function deriveCommitments(activeWorkFrame, innerJob, pendingObligations) {
     const committedTo = [];
     const completionCriteria = [];
     const safeToIgnore = [];
-    // Obligation
+    // Persistent obligations from the obligation store
+    if (pendingObligations && pendingObligations.length > 0) {
+        for (const ob of pendingObligations) {
+            committedTo.push(`i owe ${ob.origin.friendId}: ${ob.content}`);
+        }
+        completionCriteria.push("fulfill my outstanding obligations");
+    }
+    // Obligation (from current turn -- kept for backward compat)
     if (typeof activeWorkFrame.currentObligation === "string" && activeWorkFrame.currentObligation.trim().length > 0) {
         committedTo.push(`i told them i'd ${activeWorkFrame.currentObligation.trim()}`);
     }

package/dist/heart/core.js

@@ -29,6 +29,7 @@ const github_copilot_1 = require("./providers/github-copilot");
 const pending_1 = require("../mind/pending");
 const identity_2 = require("./identity");
 const socket_client_1 = require("./daemon/socket-client");
+const obligations_1 = require("./obligations");
 let _providerRuntime = null;
 function getProviderRuntimeFingerprint() {
     const provider = (0, identity_1.loadAgentConfig)().provider;
@@ -702,6 +703,21 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         } : {}),
                     };
                     (0, pending_1.queuePendingMessage)(pendingDir, envelope);
+                    if (currentSession && !isInnerChannel) {
+                        try {
+                            (0, obligations_1.createObligation)((0, identity_2.getAgentRoot)(), {
+                                origin: {
+                                    friendId: currentSession.friendId,
+                                    channel: currentSession.channel,
+                                    key: currentSession.key,
+                                },
+                                content,
+                            });
+                        }
+                        catch {
+                            /* v8 ignore next -- defensive: obligation store write failure should not break go_inward @preserve */
+                        }
+                    }
                     try {
                         await (0, socket_client_1.requestInnerWake)((0, identity_2.getAgentName)());
                     }

package/dist/heart/obligations.js

@@ -0,0 +1,141 @@
+"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.createObligation = createObligation;
+exports.readObligations = readObligations;
+exports.readPendingObligations = readPendingObligations;
+exports.fulfillObligation = fulfillObligation;
+exports.findPendingObligationForOrigin = findPendingObligationForOrigin;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+function obligationsDir(agentRoot) {
+    return path.join(agentRoot, "state", "obligations");
+}
+function obligationFilePath(agentRoot, id) {
+    return path.join(obligationsDir(agentRoot), `${id}.json`);
+}
+function generateId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).slice(2, 10);
+    return `${timestamp}-${random}`;
+}
+function createObligation(agentRoot, input) {
+    const id = generateId();
+    const obligation = {
+        id,
+        origin: input.origin,
+        ...(input.bridgeId ? { bridgeId: input.bridgeId } : {}),
+        content: input.content,
+        status: "pending",
+        createdAt: new Date().toISOString(),
+    };
+    const dir = obligationsDir(agentRoot);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(obligationFilePath(agentRoot, id), JSON.stringify(obligation, null, 2), "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.obligation_created",
+        message: "obligation created",
+        meta: {
+            obligationId: id,
+            friendId: input.origin.friendId,
+            channel: input.origin.channel,
+            key: input.origin.key,
+        },
+    });
+    return obligation;
+}
+function readObligations(agentRoot) {
+    const dir = obligationsDir(agentRoot);
+    if (!fs.existsSync(dir))
+        return [];
+    let entries;
+    try {
+        entries = fs.readdirSync(dir);
+    }
+    catch {
+        /* v8 ignore next -- defensive: readdirSync race after existsSync @preserve */
+        return [];
+    }
+    const jsonFiles = entries.filter((entry) => entry.endsWith(".json")).sort();
+    const obligations = [];
+    for (const file of jsonFiles) {
+        try {
+            const raw = fs.readFileSync(path.join(dir, file), "utf-8");
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.id === "string" && typeof parsed.content === "string") {
+                obligations.push(parsed);
+            }
+        }
+        catch {
+            // skip malformed files
+        }
+    }
+    return obligations;
+}
+function readPendingObligations(agentRoot) {
+    return readObligations(agentRoot).filter((ob) => ob.status === "pending");
+}
+function fulfillObligation(agentRoot, obligationId) {
+    const filePath = obligationFilePath(agentRoot, obligationId);
+    let obligation;
+    try {
+        const raw = fs.readFileSync(filePath, "utf-8");
+        obligation = JSON.parse(raw);
+    }
+    catch {
+        return;
+    }
+    obligation.status = "fulfilled";
+    obligation.fulfilledAt = new Date().toISOString();
+    fs.writeFileSync(filePath, JSON.stringify(obligation, null, 2), "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.obligation_fulfilled",
+        message: "obligation fulfilled",
+        meta: {
+            obligationId,
+            friendId: obligation.origin.friendId,
+            channel: obligation.origin.channel,
+            key: obligation.origin.key,
+        },
+    });
+}
+function findPendingObligationForOrigin(agentRoot, origin) {
+    return readPendingObligations(agentRoot).find((ob) => ob.origin.friendId === origin.friendId
+        && ob.origin.channel === origin.channel
+        && ob.origin.key === origin.key);
+}

package/dist/mind/prompt.js

@@ -503,7 +503,7 @@ function commitmentsSection(options) {
     const job = options.activeWorkFrame.inner?.job;
     if (!job)
         return "";
-    const commitments = (0, commitments_1.deriveCommitments)(options.activeWorkFrame, job);
+    const commitments = (0, commitments_1.deriveCommitments)(options.activeWorkFrame, job, options.activeWorkFrame.pendingObligations);
     if (commitments.committedTo.length === 0)
         return "";
     return `## my commitments\n${commitments.committedTo.map((c) => `- ${c}`).join("\n")}`;

package/dist/repertoire/tools-base.js

@@ -53,6 +53,7 @@ const memory_1 = require("../mind/memory");
 const pending_1 = require("../mind/pending");
 const progress_story_1 = require("../heart/progress-story");
 const cross_chat_delivery_1 = require("../heart/cross-chat-delivery");
+const obligations_1 = require("../heart/obligations");
 // Tracks which file paths have been read via read_file in this session.
 // edit_file requires a file to be read first (must-read-first guard).
 exports.editFileReadTracker = new Set();
@@ -893,6 +894,20 @@ exports.baseToolDefinitions = [
             if (isSelf) {
                 writePendingEnvelope(pendingDir, envelope);
                 if (delegatedFrom) {
+                    try {
+                        (0, obligations_1.createObligation)((0, identity_1.getAgentRoot)(), {
+                            origin: {
+                                friendId: delegatedFrom.friendId,
+                                channel: delegatedFrom.channel,
+                                key: delegatedFrom.key,
+                            },
+                            ...(delegatedFrom.bridgeId ? { bridgeId: delegatedFrom.bridgeId } : {}),
+                            content,
+                        });
+                    }
+                    catch {
+                        /* v8 ignore next -- defensive: obligation store write failure should not break send_message @preserve */
+                    }
                     (0, runtime_1.emitNervesEvent)({
                         event: "repertoire.obligation_created",
                         component: "repertoire",

package/dist/senses/inner-dialog.js

@@ -62,6 +62,7 @@ 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 obligations_1 = require("../heart/obligations");
 const DEFAULT_INNER_DIALOG_INSTINCTS = [
     {
         id: "heartbeat_checkin",
@@ -305,6 +306,21 @@ async function routeDelegatedCompletion(agentRoot, agentName, completion, draine
     }
     const delegatedFrom = enrichDelegatedFromWithBridge(delegated.delegatedFrom);
     if (delegated.obligationStatus === "pending") {
+        // Fulfill the persistent obligation in the store
+        try {
+            const pending = (0, obligations_1.findPendingObligationForOrigin)(agentRoot, {
+                friendId: delegatedFrom.friendId,
+                channel: delegatedFrom.channel,
+                key: delegatedFrom.key,
+            });
+            /* v8 ignore next 2 -- obligation fulfillment tested via obligations.test.ts; integration requires real disk state @preserve */
+            if (pending) {
+                (0, obligations_1.fulfillObligation)(agentRoot, pending.id);
+            }
+        }
+        catch {
+            /* v8 ignore next -- defensive: obligation store read failure should not break delivery @preserve */
+        }
         (0, runtime_1.emitNervesEvent)({
             event: "senses.obligation_fulfilled",
             component: "senses",

package/dist/senses/pipeline.js

@@ -17,6 +17,7 @@ const delegation_1 = require("../heart/delegation");
 const target_resolution_1 = require("../heart/target-resolution");
 const thoughts_1 = require("../heart/daemon/thoughts");
 const pending_1 = require("../mind/pending");
+const obligations_1 = require("../heart/obligations");
 function emptyTaskBoard() {
     return {
         compact: "",
@@ -55,12 +56,14 @@ function readInnerWorkState() {
         const { pendingMessages, turns, runtimeState } = (0, thoughts_1.readInnerDialogRawData)(sessionPath, pendingDir);
         const dialogStatus = (0, thoughts_1.deriveInnerDialogStatus)(pendingMessages, turns, runtimeState);
         const job = (0, thoughts_1.deriveInnerJob)(pendingMessages, turns, runtimeState);
+        // Derive obligationPending from both the pending message field and the obligation store
+        const storeObligationPending = (0, obligations_1.readPendingObligations)(agentRoot).length > 0;
         return {
             status: dialogStatus.processing === "started" ? "running" : "idle",
             hasPending: dialogStatus.queue !== "clear",
             origin: dialogStatus.origin,
             contentSnippet: dialogStatus.contentSnippet,
-            obligationPending: dialogStatus.obligationPending,
+            obligationPending: dialogStatus.obligationPending || storeObligationPending,
             job,
         };
     }
@@ -176,12 +179,20 @@ async function handleInboundTurn(input) {
     catch {
         targetCandidates = [];
     }
+    let pendingObligations = [];
+    try {
+        pendingObligations = (0, obligations_1.readPendingObligations)((0, identity_1.getAgentRoot)());
+    }
+    catch {
+        pendingObligations = [];
+    }
     const activeWorkFrame = (0, active_work_1.buildActiveWorkFrame)({
         currentSession,
         currentObligation,
         mustResolveBeforeHandoff,
         inner: readInnerWorkState(),
         bridges: activeBridges,
+        pendingObligations,
         taskBoard: (() => {
             try {
                 return (0, tasks_1.getTaskModule)().getBoard();

package/package.json

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