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

package/changelog.json

@@ -1,6 +1,24 @@
 {
   "_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": [
+        "Fix: CLI chat terminal logging now filters to warn/error only — info-level nerves logs go to ndjson file only, keeping the interactive TUI clean.",
+        "Fix: Streamed model output now wraps at word boundaries instead of mid-word. A new StreamingWordWrapper buffers partial lines and breaks at spaces when approaching terminal width.",
+        "New: `ouro up` now prints 'ouro updated to <version> (was <previous>)' when npx downloads a newer CLI binary, separate from the agent bundle update message.",
+        "Fix: Spinner/log interleave verified — terminal sink reads pause/resume hooks at call time, not creation time, so the filterSink wrapper in CLI logging does not break spinner coordination."
+      ]
+    },
     {
       "version": "0.1.0-alpha.75",
       "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/daemon/daemon-cli.js

@@ -37,6 +37,7 @@ exports.ensureDaemonRunning = ensureDaemonRunning;
 exports.listGithubCopilotModels = listGithubCopilotModels;
 exports.pingGithubCopilotModel = pingGithubCopilotModel;
 exports.parseOuroCommand = parseOuroCommand;
+exports.readFirstBundleMetaVersion = readFirstBundleMetaVersion;
 exports.discoverExistingCredentials = discoverExistingCredentials;
 exports.createDefaultOuroCliDeps = createDefaultOuroCliDeps;
 exports.runOuroCli = runOuroCli;
@@ -971,6 +972,33 @@ function defaultWriteStdout(text) {
     // eslint-disable-next-line no-console -- terminal UX: CLI command output
     console.log(text);
 }
+/**
+ * Read the runtimeVersion from the first .ouro bundle's bundle-meta.json.
+ * Returns undefined if none found or unreadable.
+ */
+function readFirstBundleMetaVersion(bundlesRoot) {
+    try {
+        if (!fs.existsSync(bundlesRoot))
+            return undefined;
+        const entries = fs.readdirSync(bundlesRoot, { withFileTypes: true });
+        for (const entry of entries) {
+            /* v8 ignore next -- skip non-.ouro dirs: tested via version-detect tests @preserve */
+            if (!entry.isDirectory() || !entry.name.endsWith(".ouro"))
+                continue;
+            const metaPath = path.join(bundlesRoot, entry.name, "bundle-meta.json");
+            if (!fs.existsSync(metaPath))
+                continue;
+            const raw = fs.readFileSync(metaPath, "utf-8");
+            const meta = JSON.parse(raw);
+            if (meta.runtimeVersion)
+                return meta.runtimeVersion;
+        }
+    }
+    catch {
+        // Best effort — return undefined on any error
+    }
+    return undefined;
+}
 function defaultCleanupStaleSocket(socketPath) {
     if (fs.existsSync(socketPath)) {
         fs.unlinkSync(socketPath);
@@ -1743,7 +1771,16 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
         (0, update_hooks_1.registerUpdateHook)(bundle_meta_1.bundleMetaHook);
         const bundlesRoot = (0, identity_1.getAgentBundlesRoot)();
         const currentVersion = (0, bundle_manifest_1.getPackageVersion)();
+        // Snapshot the previous CLI version from the first bundle-meta before
+        // hooks overwrite it. This detects when npx downloaded a newer CLI.
+        const previousCliVersion = readFirstBundleMetaVersion(bundlesRoot);
         const updateSummary = await (0, update_hooks_1.applyPendingUpdates)(bundlesRoot, currentVersion);
+        // Notify about CLI binary update (npx downloaded a new version)
+        /* v8 ignore start -- CLI update detection: tested via daemon-cli-version-detect.test.ts @preserve */
+        if (previousCliVersion && previousCliVersion !== currentVersion) {
+            deps.writeStdout(`ouro updated to ${currentVersion} (was ${previousCliVersion})`);
+        }
+        /* v8 ignore stop */
         if (updateSummary.updated.length > 0) {
             const agents = updateSummary.updated.map((e) => e.agent);
             const from = updateSummary.updated[0].from;

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/cli-layout.js

@@ -1,8 +1,108 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamingWordWrapper = void 0;
 exports.wrapCliText = wrapCliText;
 exports.formatEchoedInputSummary = formatEchoedInputSummary;
 const runtime_1 = require("../nerves/runtime");
+// Strip ANSI escape sequences to measure visible text width.
+const ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]/g;
+function visibleLength(text) {
+    return text.replace(ANSI_RE, "").length;
+}
+/**
+ * Streaming word wrapper for terminal output.
+ *
+ * Text arrives in small chunks (sometimes single characters). This class
+ * buffers a partial line and emits complete wrapped lines at word boundaries
+ * when the visible width approaches the terminal column limit.
+ *
+ * ANSI escape sequences are treated as zero-width so colours and styles
+ * pass through without affecting line-break decisions.
+ */
+class StreamingWordWrapper {
+    col = 0; // visible columns consumed on the current line
+    buf = ""; // buffered text for the current line (not yet emitted)
+    width; // terminal column count
+    constructor(cols) {
+        this.width = Math.max(cols ?? (process.stdout.columns || 80), 1);
+    }
+    /** Accept a chunk of already-rendered text and return text ready for stdout. */
+    push(text) {
+        let out = "";
+        for (let i = 0; i < text.length; i++) {
+            const ch = text[i];
+            // Pass through ANSI escape sequences without counting width
+            /* v8 ignore start -- ANSI handling: tested via StreamingWordWrapper ANSI test @preserve */
+            if (ch === "\x1b") {
+                const rest = text.slice(i);
+                const m = rest.match(/^\x1b\[[0-9;]*[A-Za-z]/);
+                if (m) {
+                    this.buf += m[0];
+                    i += m[0].length - 1;
+                    continue;
+                }
+            }
+            /* v8 ignore stop */
+            // Explicit newline: flush current line and reset
+            if (ch === "\n") {
+                out += this.buf + "\n";
+                this.buf = "";
+                this.col = 0;
+                continue;
+            }
+            // Space: if the current line is already at or past width, wrap now.
+            // Otherwise just append.
+            if (ch === " ") {
+                /* v8 ignore start -- wrap-at-space: tested via StreamingWordWrapper unit tests @preserve */
+                if (this.col >= this.width) {
+                    out += this.buf + "\n";
+                    this.buf = "";
+                    this.col = 0;
+                    // Drop the space at the wrap point
+                    continue;
+                    /* v8 ignore stop */
+                }
+                this.buf += ch;
+                this.col++;
+                continue;
+            }
+            // Non-space character
+            this.col++;
+            if (this.col > this.width) {
+                // We've exceeded the width. Try to break at the last space.
+                const lastSpace = this.buf.lastIndexOf(" ");
+                if (lastSpace !== -1) {
+                    out += this.buf.slice(0, lastSpace) + "\n";
+                    // Keep the remainder (after space) plus current char
+                    this.buf = this.buf.slice(lastSpace + 1) + ch;
+                    this.col = visibleLength(this.buf);
+                }
+                else {
+                    // No space to break at — hard wrap
+                    out += this.buf + "\n";
+                    this.buf = ch;
+                    this.col = 1;
+                }
+                continue;
+            }
+            this.buf += ch;
+        }
+        return out;
+    }
+    /** Flush any remaining buffered text (call at end of response). */
+    flush() {
+        const remainder = this.buf;
+        this.buf = "";
+        this.col = 0;
+        return remainder;
+    }
+    /** Reset wrapper state (call at start of new model turn). */
+    reset() {
+        this.buf = "";
+        this.col = 0;
+    }
+}
+exports.StreamingWordWrapper = StreamingWordWrapper;
 function splitLongWord(word, width) {
     const chunks = [];
     for (let index = 0; index < word.length; index += width) {

package/dist/senses/cli.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MarkdownStreamer = exports.InputController = exports.Spinner = exports.wrapCliText = exports.formatEchoedInputSummary = void 0;
+exports.MarkdownStreamer = exports.InputController = exports.Spinner = exports.StreamingWordWrapper = exports.wrapCliText = exports.formatEchoedInputSummary = void 0;
 exports.formatPendingPrefix = formatPendingPrefix;
 exports.getCliContinuityIngressTexts = getCliContinuityIngressTexts;
 exports.pauseActiveSpinner = pauseActiveSpinner;
@@ -76,6 +76,7 @@ const cli_layout_1 = require("./cli-layout");
 var cli_layout_2 = require("./cli-layout");
 Object.defineProperty(exports, "formatEchoedInputSummary", { enumerable: true, get: function () { return cli_layout_2.formatEchoedInputSummary; } });
 Object.defineProperty(exports, "wrapCliText", { enumerable: true, get: function () { return cli_layout_2.wrapCliText; } });
+Object.defineProperty(exports, "StreamingWordWrapper", { enumerable: true, get: function () { return cli_layout_2.StreamingWordWrapper; } });
 /**
  * Format pending messages as content-prefix strings for injection into
  * the next user message. Self-messages (from === agentName) become
@@ -349,6 +350,7 @@ function createCliCallbacks() {
     let hadToolRun = false;
     let textDirty = false; // true when text/reasoning was written without a trailing newline
     const streamer = new MarkdownStreamer();
+    const wrapper = new cli_layout_1.StreamingWordWrapper();
     return {
         onModelStart: () => {
             currentSpinner?.stop();
@@ -356,6 +358,7 @@ function createCliCallbacks() {
             hadReasoning = false;
             textDirty = false;
             streamer.reset();
+            wrapper.reset();
             const phrases = (0, phrases_1.getPhrases)();
             const pool = hadToolRun ? phrases.followup : phrases.thinking;
             const first = (0, phrases_1.pickPhrase)(pool);
@@ -369,6 +372,7 @@ function createCliCallbacks() {
         },
         onClearText: () => {
             streamer.reset();
+            wrapper.reset();
         },
         onTextChunk: (text) => {
             // Stop spinner if still running — final_answer streaming and Anthropic
@@ -385,8 +389,13 @@ function createCliCallbacks() {
                 hadReasoning = false;
             }
             const rendered = streamer.push(text);
-            if (rendered)
-                process.stdout.write(rendered);
+            /* v8 ignore start -- wrapper integration: tested via cli.test.ts onTextChunk tests @preserve */
+            if (rendered) {
+                const wrapped = wrapper.push(rendered);
+                if (wrapped)
+                    process.stdout.write(wrapped);
+            }
+            /* v8 ignore stop */
             textDirty = text.length > 0 && !text.endsWith("\n");
         },
         onReasoningChunk: (text) => {
@@ -445,9 +454,17 @@ function createCliCallbacks() {
         flushMarkdown: () => {
             currentSpinner?.stop();
             setSpinner(null);
+            /* v8 ignore start -- wrapper flush: tested via cli.test.ts flushMarkdown tests @preserve */
             const remaining = streamer.flush();
-            if (remaining)
-                process.stdout.write(remaining);
+            if (remaining) {
+                const wrapped = wrapper.push(remaining);
+                if (wrapped)
+                    process.stdout.write(wrapped);
+            }
+            const tail = wrapper.flush();
+            if (tail)
+                process.stdout.write(tail);
+            /* v8 ignore stop */
         },
     };
 }

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.75",
+  "version": "0.1.0-alpha.77",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",