@ouro.bot/cli 0.1.0-alpha.596 → 0.1.0-alpha.598

package/changelog.json

@@ -1,6 +1,18 @@
 {
   "_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.598",
+      "changes": [
+        "New `restart_runtime({ reason })` tool. Agent self-maintenance: asking Ari to restart the daemon over BlueBubbles is now a thing of the past. Sends `daemon.restart` over the existing socket — daemon logs the reason as `daemon.restart_requested`, runs its normal stop pathway, and exits. launchctl's KeepAlive policy auto-respawns the daemon, so the agent comes back fresh on the other side. The agent will not see this tool's return value — its process exits with the daemon and a clean boot replaces it. In dev mode (no launchctl) the daemon just exits; same observable behavior as `daemon.stop`, with the restart-requested audit event distinguishing intent."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.597",
+      "changes": [
+        "New `let_go({ id, reason? })` tool. Closes a gap surfaced live by Slugger after #720 (await_condition): when a held work item is resolved externally (e.g. an obligation whose underlying issue was merged in a separate PR), the agent had no way to dismiss it. The existing path to terminal state — fulfilling via `surface` — requires delivering a response, which doesn't fit externally-resolved work. The agent kept seeing the same stale items in its prompt every turn for a month with nothing to act on. `let_go` is dismissal WITHOUT delivery: tries `arc/obligations/inner/<id>.json` (ReturnObligation → `returned` with returnTarget=`surface`), falls through to `arc/obligations/<id>.json` (Obligation → `fulfilled` with `latestNote=reason`). Idempotent — calling on an already-terminal item returns the existing status, not an error. Emits `repertoire.obligation_let_go` nerves event recording the reason for future-me. id is the bracketed value in the prompt's 'held work items' section."
+      ]
+    },
     {
       "version": "0.1.0-alpha.596",
       "changes": [

package/dist/heart/daemon/daemon.js

@@ -1073,6 +1073,27 @@ class OuroDaemon {
                 await this.stop();
                 this.onStopCommandComplete?.();
                 return { ok: true, message: "daemon stopped" };
+            case "daemon.restart": {
+                // Restart is "stop + let launchctl respawn." Under launchctl's KeepAlive
+                // policy the process is auto-restarted on exit, so daemon.restart and
+                // daemon.stop differ only in intent + audit trail. In dev (no launchctl),
+                // the process simply exits — same observable behavior as daemon.stop.
+                (0, runtime_1.emitNervesEvent)({
+                    component: "daemon",
+                    event: "daemon.restart_requested",
+                    message: "daemon restart requested",
+                    meta: {
+                        reason: command.reason ?? null,
+                        requestedBy: command.requestedBy ?? null,
+                    },
+                });
+                await this.stop();
+                this.onStopCommandComplete?.();
+                return {
+                    ok: true,
+                    message: "daemon restarting — launchctl will respawn",
+                };
+            }
             case "daemon.status": {
                 const data = this.buildStatusPayload();
                 return {

package/dist/repertoire/tools-base.js

@@ -19,6 +19,8 @@ const tools_attachments_1 = require("./tools-attachments");
 const tools_mail_1 = require("./tools-mail");
 const tools_trip_1 = require("./tools-trip");
 const tools_awaiting_1 = require("./tools-awaiting");
+const tools_obligations_1 = require("./tools-obligations");
+const tools_runtime_1 = require("./tools-runtime");
 // Re-export flow tools for consumers that import them from tools-base
 var tools_flow_1 = require("./tools-flow");
 Object.defineProperty(exports, "ponderTool", { enumerable: true, get: function () { return tools_flow_1.ponderTool; } });
@@ -53,6 +55,8 @@ exports.baseToolDefinitions = [
     ...tools_mail_1.mailToolDefinitions,
     ...tools_trip_1.tripToolDefinitions,
     ...tools_awaiting_1.awaitingToolDefinitions,
+    ...tools_obligations_1.obligationToolDefinitions,
+    ...tools_runtime_1.runtimeToolDefinitions,
 ];
 // Convenience array of just the tool schemas (no handler/integration metadata).
 // Used by consumers that need the OpenAI function-tool format.

package/dist/repertoire/tools-obligations.js

@@ -0,0 +1,142 @@
+"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.obligationToolDefinitions = void 0;
+const path = __importStar(require("path"));
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+const json_store_1 = require("../arc/json-store");
+const obligations_1 = require("../arc/obligations");
+/**
+ * `let_go` lets the agent release a held work item from its attention loop.
+ *
+ * Two stores need release semantics:
+ *   1. ReturnObligations at `arc/obligations/inner/<id>.json` (status: queued|running|returned|deferred)
+ *      — these are what surface in the "held work items" section of the prompt.
+ *   2. Outer Obligations at `arc/obligations/<id>.json` (status: pending|...|fulfilled)
+ *      — these surface as "i owe <friend>: ..." in the commitments section.
+ *
+ * The pre-existing path to terminal state for both is the `surface` tool, which fulfills
+ * an obligation as a side-effect of delivering a response. When work is resolved EXTERNALLY
+ * (e.g. a PR merged fixed the underlying issue), there is no response to surface — the
+ * agent has no way to clear the item, so it cycles in the prompt every turn.
+ *
+ * `let_go` is the missing primitive: dismissal WITHOUT delivery.
+ */
+function outerObligationsDir(agentRoot) {
+    return path.join(agentRoot, "arc", "obligations");
+}
+function readOuterObligation(agentRoot, id) {
+    return (0, json_store_1.readJsonFile)(outerObligationsDir(agentRoot), id) ?? null;
+}
+function letGo(args, agentRoot, agentName) {
+    if (typeof args.id !== "string" || args.id.trim().length === 0) {
+        return JSON.stringify({ error: "id is required" });
+    }
+    const id = args.id.trim();
+    const reason = typeof args.reason === "string" && args.reason.trim().length > 0
+        ? args.reason.trim()
+        : null;
+    // 1. ReturnObligation (inner) first — these are what slugger sees in "held work items".
+    const ret = (0, obligations_1.readReturnObligation)(agentName, id);
+    if (ret) {
+        if (ret.status === "returned" || ret.status === "deferred") {
+            return JSON.stringify({ kind: "return_obligation", id, already: ret.status });
+        }
+        (0, obligations_1.advanceReturnObligation)(agentName, id, {
+            status: "returned",
+            returnedAt: Date.now(),
+            returnTarget: "surface",
+        });
+        (0, runtime_1.emitNervesEvent)({
+            component: "repertoire",
+            event: "repertoire.obligation_let_go",
+            message: "agent let go of return obligation",
+            meta: { kind: "return_obligation", id, reason: reason ?? null },
+        });
+        return JSON.stringify({ kind: "return_obligation", let_go: id, reason });
+    }
+    // 2. Outer Obligation — these surface as "i owe ..." in commitments.
+    const outer = readOuterObligation(agentRoot, id);
+    if (outer) {
+        if (outer.status === "fulfilled") {
+            return JSON.stringify({ kind: "obligation", id, already: "fulfilled" });
+        }
+        (0, obligations_1.fulfillObligation)(agentRoot, id);
+        if (reason !== null) {
+            // Persist the dismissal reason as the obligation's latestNote so future-me
+            // can read why this was released (the nerves event also captures it).
+            (0, obligations_1.advanceObligation)(agentRoot, id, { latestNote: reason });
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "repertoire",
+            event: "repertoire.obligation_let_go",
+            message: "agent let go of outer obligation",
+            meta: { kind: "obligation", id, reason: reason ?? null },
+        });
+        return JSON.stringify({ kind: "obligation", let_go: id, reason });
+    }
+    return JSON.stringify({ error: `no obligation found with id "${id}"` });
+}
+exports.obligationToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "let_go",
+                description: "release a held work item from my attention. for items that have been resolved externally, no longer apply, or are stale and just cycling in my prompt with nothing to act on. takes the id i see in the 'held work items' section (or any obligation id from arc/obligations/). optional reason is recorded for future me. idempotent — calling on an already-released item returns the existing status, not an error.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        id: {
+                            type: "string",
+                            description: "the obligation id — the bracketed id in 'held work items' (e.g. '1775976317954-s5pno43r'), or any obligation file's id from arc/obligations/.",
+                        },
+                        reason: {
+                            type: "string",
+                            description: "optional one-line reason i'm letting go (e.g. 'resolved externally by PR #701').",
+                        },
+                    },
+                    required: ["id"],
+                },
+            },
+        },
+        handler: (args) => {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const agentName = (0, identity_1.getAgentName)();
+            return letGo({ id: args.id, reason: args.reason }, agentRoot, agentName);
+        },
+    },
+];

package/dist/repertoire/tools-runtime.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runtimeToolDefinitions = void 0;
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+const socket_client_1 = require("../heart/daemon/socket-client");
+async function restartRuntime(args, agentName) {
+    if (typeof args.reason !== "string" || args.reason.trim().length === 0) {
+        return JSON.stringify({ error: "reason is required (one-line audit string)" });
+    }
+    const reason = args.reason.trim();
+    (0, runtime_1.emitNervesEvent)({
+        component: "repertoire",
+        event: "repertoire.runtime_restart_requested",
+        message: "agent requested runtime restart",
+        meta: { agent: agentName, reason },
+    });
+    try {
+        const response = await (0, socket_client_1.sendDaemonCommand)(socket_client_1.DEFAULT_DAEMON_SOCKET_PATH, {
+            kind: "daemon.restart",
+            reason,
+            requestedBy: agentName,
+        });
+        return JSON.stringify({
+            requested: true,
+            reason,
+            detail: response.message ?? "daemon restart requested",
+        });
+    }
+    catch (error) {
+        return JSON.stringify({
+            error: "failed to reach daemon socket",
+            detail: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+exports.runtimeToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "restart_runtime",
+                description: "ask my runtime (the daemon hosting me) to restart itself. for when something is wedged — stale state, recovery queue jammed, version mismatch, or i just need a fresh boot. under launchctl the daemon auto-respawns, so i come back on the other side with a clean slate. takes a one-line reason that lands in the audit log. i will NOT see this tool's response — my process exits with the daemon and i wake up fresh.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        reason: {
+                            type: "string",
+                            description: "one-line audit reason (e.g. 'bluebubbles recovery queue wedged for 4h', 'picking up daemon version update').",
+                        },
+                    },
+                    required: ["reason"],
+                },
+            },
+        },
+        handler: async (args) => {
+            const agentName = (0, identity_1.getAgentName)();
+            return restartRuntime({ reason: args.reason }, agentName);
+        },
+    },
+];

package/package.json

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