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

package/changelog.json

@@ -1,6 +1,14 @@
 {
   "_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.133",
+      "changes": [
+        "Inner return obligations: delegated inner dialog work now tracks a ReturnObligation through queued → running → returned/deferred lifecycle.",
+        "Exact-origin routing: inner dialog completions route back to the session that delegated the work, not just the freshest active session.",
+        "Active work frame surfaces pending inner return obligations so the agent knows what's outstanding."
+      ]
+    },
     {
       "version": "0.1.0-alpha.132",
       "changes": [

package/dist/heart/active-work.js

@@ -439,6 +439,7 @@ function buildActiveWorkFrame(input) {
         otherCodingSessions,
         pendingObligations,
         targetCandidates: input.targetCandidates ?? [],
+        innerReturnObligations: input.innerReturnObligations ?? [],
         bridgeSuggestion: suggestBridgeForActiveWork({
             currentSession: input.currentSession,
             currentObligation: input.currentObligation,
@@ -588,6 +589,16 @@ function formatActiveWorkFrame(frame) {
             lines.push(obligationLine);
         }
     }
+    if (frame.innerReturnObligations && frame.innerReturnObligations.length > 0) {
+        lines.push("");
+        lines.push("## inner return obligations");
+        for (const ob of frame.innerReturnObligations) {
+            const preview = ob.delegatedContent.length > 60
+                ? `${ob.delegatedContent.slice(0, 57)}...`
+                : ob.delegatedContent;
+            lines.push(`- [${ob.status}] ${ob.origin.friendId}/${ob.origin.channel}/${ob.origin.key}: ${preview}`);
+        }
+    }
     // Bridge suggestion
     if (frame.bridgeSuggestion) {
         lines.push("");

package/dist/heart/daemon/ouro-path-installer.js

@@ -46,6 +46,11 @@ if [ ! -e "$ENTRY" ]; then
 fi
 exec node "$ENTRY" "$@"
 `;
+function writeWrapperScript(scriptPath, mkdirSync, writeFileSync, chmodSync) {
+    mkdirSync(path.dirname(scriptPath), { recursive: true });
+    writeFileSync(scriptPath, WRAPPER_SCRIPT, { mode: 0o755 });
+    chmodSync(scriptPath, 0o755);
+}
 function detectShellProfile(homeDir, shell) {
     if (!shell)
         return null;
@@ -151,9 +156,9 @@ function installOuroCommand(deps = {}) {
         meta: { scriptPath, binDir },
     });
     try {
-        mkdirSync(binDir, { recursive: true });
-        writeFileSync(scriptPath, WRAPPER_SCRIPT, { mode: 0o755 });
-        chmodSync(scriptPath, 0o755);
+        if (!modernCurrent) {
+            writeWrapperScript(scriptPath, mkdirSync, writeFileSync, chmodSync);
+        }
     }
     catch (error) {
         (0, runtime_1.emitNervesEvent)({
@@ -166,8 +171,8 @@ function installOuroCommand(deps = {}) {
         return { installed: false, scriptPath: null, pathReady: false, shellProfileUpdated: null, skippedReason: error instanceof Error ? error.message : /* v8 ignore next -- defensive @preserve */ String(error), repairedOldLauncher };
     }
     // Check if ~/.ouro-cli/bin is already in PATH
-    let shellProfileUpdated = null;
     const pathReady = isBinDirInPath(binDir, envPath);
+    let shellProfileUpdated = null;
     if (!pathReady) {
         const profilePath = detectShellProfile(homeDir, shell);
         if (profilePath) {
@@ -199,7 +204,7 @@ function installOuroCommand(deps = {}) {
         component: "daemon",
         event: "daemon.ouro_path_install_end",
         message: "ouro command installed",
-        meta: { scriptPath, pathReady, shellProfileUpdated },
+        meta: { scriptPath, pathReady, shellProfileUpdated, oldScriptPath: oldExists ? oldScriptPath : null },
     });
     return { installed: true, scriptPath, pathReady, shellProfileUpdated, repairedOldLauncher };
 }

package/dist/mind/obligations.js

@@ -0,0 +1,134 @@
+"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.getObligationsDir = getObligationsDir;
+exports.generateObligationId = generateObligationId;
+exports.createObligation = createObligation;
+exports.readObligation = readObligation;
+exports.advanceObligation = advanceObligation;
+exports.listActiveObligations = listActiveObligations;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+// ── Paths ────────────────────────────────────────────────────────
+function getObligationsDir(agentName) {
+    return path.join((0, identity_1.getAgentRoot)(agentName), "state", "obligations", "inner");
+}
+// ── ID generation ────────────────────────────────────────────────
+function generateObligationId(timestamp) {
+    return `${timestamp}-${Math.random().toString(36).slice(2, 10)}`;
+}
+// ── Store operations ─────────────────────────────────────────────
+function createObligation(agentName, obligation) {
+    const dir = getObligationsDir(agentName);
+    fs.mkdirSync(dir, { recursive: true });
+    const filePath = path.join(dir, `${obligation.id}.json`);
+    fs.writeFileSync(filePath, JSON.stringify(obligation, null, 2), "utf8");
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.obligation_created",
+        component: "mind",
+        message: "return obligation created",
+        meta: {
+            obligationId: obligation.id,
+            origin: `${obligation.origin.friendId}/${obligation.origin.channel}/${obligation.origin.key}`,
+            status: obligation.status,
+        },
+    });
+    return filePath;
+}
+function readObligation(agentName, obligationId) {
+    const dir = getObligationsDir(agentName);
+    try {
+        const raw = fs.readFileSync(path.join(dir, `${obligationId}.json`), "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function advanceObligation(agentName, obligationId, update) {
+    const existing = readObligation(agentName, obligationId);
+    if (!existing)
+        return null;
+    const updated = {
+        ...existing,
+        status: update.status,
+        ...(update.startedAt !== undefined ? { startedAt: update.startedAt } : {}),
+        ...(update.returnedAt !== undefined ? { returnedAt: update.returnedAt } : {}),
+        ...(update.returnTarget !== undefined ? { returnTarget: update.returnTarget } : {}),
+    };
+    const dir = getObligationsDir(agentName);
+    fs.writeFileSync(path.join(dir, `${obligationId}.json`), JSON.stringify(updated, null, 2), "utf8");
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.obligation_advanced",
+        component: "mind",
+        message: `obligation advanced to ${update.status}`,
+        meta: {
+            obligationId,
+            status: update.status,
+            ...(update.returnTarget ? { returnTarget: update.returnTarget } : {}),
+        },
+    });
+    return updated;
+}
+function listActiveObligations(agentName) {
+    const dir = getObligationsDir(agentName);
+    if (!fs.existsSync(dir))
+        return [];
+    let entries;
+    try {
+        entries = fs.readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const obligations = [];
+    for (const file of entries) {
+        if (!file.endsWith(".json"))
+            continue;
+        try {
+            const raw = fs.readFileSync(path.join(dir, file), "utf-8");
+            const parsed = JSON.parse(raw);
+            if (parsed.status === "queued" || parsed.status === "running") {
+                obligations.push(parsed);
+            }
+        }
+        catch {
+            // skip unparseable
+        }
+    }
+    return obligations.sort((a, b) => a.createdAt - b.createdAt);
+}

package/dist/repertoire/tools-base.js

@@ -55,9 +55,10 @@ const coding_1 = require("./coding");
 const memory_1 = require("../mind/memory");
 const tasks_1 = require("./tasks");
 const pending_1 = require("../mind/pending");
+const obligations_1 = require("../mind/obligations");
 const progress_story_1 = require("../heart/progress-story");
 const cross_chat_delivery_1 = require("../heart/cross-chat-delivery");
-const obligations_1 = require("../heart/obligations");
+const obligations_2 = 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();
@@ -207,7 +208,7 @@ function readActiveWorkInnerState() {
         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);
-        const storeObligationPending = (0, obligations_1.readPendingObligations)(agentRoot).length > 0;
+        const storeObligationPending = (0, obligations_2.readPendingObligations)(agentRoot).length > 0;
         return {
             status: dialogStatus.processing === "started" ? "running" : "idle",
             hasPending: dialogStatus.queue !== "clear",
@@ -256,7 +257,7 @@ async function buildToolActiveWorkFrame(ctx) {
     }
     const pendingObligations = (() => {
         try {
-            return (0, obligations_1.readPendingObligations)(agentRoot);
+            return (0, obligations_2.readPendingObligations)(agentRoot);
         }
         catch {
             return [];
@@ -1122,6 +1123,7 @@ exports.baseToolDefinitions = [
                     ...(delegatingBridgeId ? { bridgeId: delegatingBridgeId } : {}),
                 }
                 : undefined;
+            const obligationId = delegatedFrom ? (0, obligations_1.generateObligationId)(now) : undefined;
             const envelope = {
                 from: agentName,
                 friendId,
@@ -1130,12 +1132,13 @@ exports.baseToolDefinitions = [
                 content,
                 timestamp: now,
                 ...(delegatedFrom ? { delegatedFrom, obligationStatus: "pending" } : {}),
+                ...(obligationId ? { obligationId } : {}),
             };
             if (isSelf) {
                 writePendingEnvelope(pendingDir, envelope);
                 if (delegatedFrom) {
                     try {
-                        (0, obligations_1.createObligation)((0, identity_1.getAgentRoot)(), {
+                        (0, obligations_2.createObligation)((0, identity_1.getAgentRoot)(), {
                             origin: {
                                 friendId: delegatedFrom.friendId,
                                 channel: delegatedFrom.channel,
@@ -1148,6 +1151,16 @@ exports.baseToolDefinitions = [
                     catch {
                         /* v8 ignore next -- defensive: obligation store write failure should not break send_message @preserve */
                     }
+                    /* v8 ignore next -- obligationId always set when delegatedFrom is set (see generateObligationId above) @preserve */
+                    if (obligationId) {
+                        (0, obligations_1.createObligation)(agentName, {
+                            id: obligationId,
+                            origin: delegatedFrom,
+                            status: "queued",
+                            delegatedContent: content.length > 120 ? `${content.slice(0, 117)}...` : content,
+                            createdAt: now,
+                        });
+                    }
                     (0, runtime_1.emitNervesEvent)({
                         event: "repertoire.obligation_created",
                         component: "repertoire",

package/dist/senses/inner-dialog.js

@@ -53,6 +53,7 @@ const prompt_1 = require("../mind/prompt");
 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 channel_1 = require("../mind/friends/channel");
 const trust_gate_1 = require("./trust-gate");
 const tokens_1 = require("../mind/friends/tokens");
@@ -62,7 +63,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 obligations_2 = require("../heart/obligations");
 const DEFAULT_INNER_DIALOG_INSTINCTS = [
     {
         id: "heartbeat_checkin",
@@ -269,6 +270,12 @@ 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;
+}
 function resolveBridgePreferredSession(delegatedFrom, sessionActivity) {
     if (!delegatedFrom.bridgeId)
         return null;
@@ -307,23 +314,46 @@ function enrichDelegatedFromWithBridge(delegatedFrom) {
     }
     return delegatedFrom;
 }
+function advanceObligationQuietly(agentName, obligationId, update) {
+    if (!obligationId)
+        return;
+    try {
+        (0, obligations_1.advanceObligation)(agentName, obligationId, update);
+        /* v8 ignore start -- best-effort: obligation fs errors must never block return routing @preserve */
+    }
+    catch {
+        // swallowed
+    }
+    /* v8 ignore stop */
+}
 async function routeDelegatedCompletion(agentRoot, agentName, completion, drainedPending, timestamp) {
     const delegated = (drainedPending ?? []).find((message) => message.delegatedFrom);
     if (!delegated?.delegatedFrom || !completion?.answer?.trim()) {
         return;
     }
     const delegatedFrom = enrichDelegatedFromWithBridge(delegated.delegatedFrom);
+    const obligationId = delegated.obligationId;
+    // Advance any inner return obligations from queued -> running (they were drained this turn).
+    // drainedPending is guaranteed non-null here (we found delegated above).
+    for (const msg of drainedPending) {
+        if (msg.obligationId) {
+            advanceObligationQuietly(agentName, msg.obligationId, {
+                status: "running",
+                startedAt: timestamp,
+            });
+        }
+    }
     if (delegated.obligationStatus === "pending") {
         // Fulfill the persistent obligation in the store
         try {
-            const pending = (0, obligations_1.findPendingObligationForOrigin)(agentRoot, {
+            const pending = (0, obligations_2.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);
+                (0, obligations_2.fulfillObligation)(agentRoot, pending.id);
             }
         }
         catch {
@@ -348,20 +378,36 @@ async function routeDelegatedCompletion(agentRoot, agentName, completion, draine
         content: completion.answer.trim(),
         timestamp,
         delegatedFrom,
+        ...(obligationId ? { obligationId } : {}),
     };
     const sessionActivity = (0, session_activity_1.listSessionActivity)({
         sessionsDir: path.join(agentRoot, "state", "sessions"),
         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).
     const bridgeTarget = resolveBridgePreferredSession(delegatedFrom, sessionActivity);
     if (bridgeTarget) {
         if (await tryDeliverDelegatedCompletion(bridgeTarget, outboundEnvelope)) {
+            advanceObligationQuietly(agentName, obligationId, { status: "returned", returnedAt: timestamp, returnTarget: "bridge-session" });
             return;
         }
         writePendingEnvelope((0, pending_1.getPendingDir)(agentName, bridgeTarget.friendId, bridgeTarget.channel, bridgeTarget.key), outboundEnvelope);
+        advanceObligationQuietly(agentName, obligationId, { status: "returned", returnedAt: timestamp, returnTarget: "bridge-session" });
         return;
     }
+    // Priority 3: Freshest active friend session.
     const freshest = (0, session_activity_1.findFreshestFriendSession)({
         sessionsDir: path.join(agentRoot, "state", "sessions"),
         friendsDir: path.join(agentRoot, "friends"),
@@ -371,12 +417,16 @@ async function routeDelegatedCompletion(agentRoot, agentName, completion, draine
     });
     if (freshest && freshest.channel !== "inner") {
         if (await tryDeliverDelegatedCompletion(freshest, outboundEnvelope)) {
+            advanceObligationQuietly(agentName, obligationId, { status: "returned", returnedAt: timestamp, returnTarget: "freshest-session" });
             return;
         }
         writePendingEnvelope((0, pending_1.getPendingDir)(agentName, freshest.friendId, freshest.channel, freshest.key), outboundEnvelope);
+        advanceObligationQuietly(agentName, obligationId, { status: "returned", returnedAt: timestamp, returnTarget: "freshest-session" });
         return;
     }
+    // Priority 4: Deferred return queue.
     writePendingEnvelope((0, pending_1.getDeferredReturnDir)(agentName, delegatedFrom.friendId), outboundEnvelope);
+    advanceObligationQuietly(agentName, obligationId, { status: "deferred", returnedAt: timestamp, returnTarget: "deferred" });
 }
 // Self-referencing friend record for inner dialog (agent talking to itself).
 // No real friend to resolve -- this satisfies the pipeline's friend resolver contract.

package/dist/senses/pipeline.js

@@ -19,6 +19,7 @@ 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");
+const obligations_2 = require("../mind/obligations");
 const provider_failover_1 = require("../heart/provider-failover");
 const provider_ping_1 = require("../heart/provider-ping");
 const auth_flow_1 = require("../heart/daemon/auth-flow");
@@ -310,6 +311,14 @@ async function handleInboundTurn(input) {
         })(),
         friendActivity: sessionActivity,
         targetCandidates,
+        innerReturnObligations: (() => {
+            try {
+                return (0, obligations_2.listActiveObligations)((0, identity_1.getAgentName)());
+            }
+            catch {
+                return [];
+            }
+        })(),
     });
     const delegationDecision = (0, delegation_1.decideDelegation)({
         channel: input.channel,

package/package.json

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