@ouro.bot/cli 0.1.0-alpha.605 → 0.1.0-alpha.606

package/changelog.json

@@ -1,6 +1,12 @@
 {
   "_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.606",
+      "changes": [
+        "Root-cause fix for the 2026-05-11 inner-dialog wake storm that cost ~$50 in minimax inference. PR #725 removed `inner.wake` from the Claude Code post-tool-use hook with the stated intent that the notification message stay in the queue and be picked up on the agent's next natural turn — but the daemon's `message.send` HANDLER (daemon.ts case `message.send`) was unconditionally calling `processManager.sendToAgent(to, { type: \"message\" })` after queueing, which woke the inner-dialog worker on every message.send anyway. ~30 message.send/min × the 3-turn instinct-loop cap = ~90 turns/min sustained for hours. PR #725 fixed the hook side; the daemon side defeated it.\n\nFix: the `message.send` handler is now pure queue-only delivery. No `startAgent`, no `sendToAgent` — just `router.send`. Callers that want immediate processing must send `inner.wake` explicitly after `message.send`. The Claude Code hook (cli-exec.ts) was already correctly discriminating (only firing inner.wake on session-start/stop, never per-tool-use), so it works as originally intended now. The CLI `ouro msg` was updated to chain `inner.wake` after `message.send` (operator-driven delivery wants immediate response, preserving historical CLI UX). Other callers (API, programmatic) default to queue-only.\n\nTest pinned: `daemon-command-plane-branches.test.ts` now asserts `processManager.startAgent` and `processManager.sendToAgent` are NOT called from `message.send`. The regression cannot be silently reintroduced."
+      ]
+    },
     {
       "version": "0.1.0-alpha.605",
       "changes": [

package/dist/heart/daemon/cli-exec.js

@@ -7538,6 +7538,14 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
     let response;
     try {
         response = await deps.sendCommand(deps.socketPath, daemonCommand);
+        // `ouro msg` is operator-driven and expects the recipient to process the
+        // message now (vs. on next natural turn). message.send is queue-only as
+        // of the 2026-05-11 fix; we explicitly fire inner.wake to preserve the
+        // historical CLI UX. Background callers (hooks, API) deliberately omit
+        // this and let the agent pick up notifications on its next turn.
+        if (command.kind === "message.send" && command.from === "ouro-cli") {
+            await deps.sendCommand(deps.socketPath, { kind: "inner.wake", agent: command.to }).catch(() => { });
+        }
     }
     catch (error) {
         if (command.kind === "message.send") {

package/dist/heart/daemon/daemon.js

@@ -1164,6 +1164,20 @@ class OuroDaemon {
                 return { ok: result.ok, message: result.message };
             }
             case "message.send": {
+                // Pure queue-only delivery. We DO NOT wake the recipient — that was
+                // the 2026-05-11 $50 bleed. The Claude Code post-tool-use hook
+                // (cli-exec.ts) intentionally sends only message.send for tool-use
+                // events to avoid waking the agent on every tool call. The hook's
+                // intent was completely defeated by this handler calling
+                // `sendToAgent({type: "message"})`, which woke the inner-dialog
+                // worker on EVERY message.send anyway. ~30 message.send/min × the
+                // 3-turn instinct-loop cap = ~90 turns/min sustained for hours.
+                //
+                // Callers that want immediate processing must send `inner.wake`
+                // explicitly after message.send. The CLI `ouro msg` does so
+                // (lifecycle-boundary delivery should wake); the hook does so
+                // only on session-start / stop, not per tool-use; the API does
+                // not (notifications go to the queue).
                 const receipt = await this.router.send({
                     from: command.from,
                     to: command.to,
@@ -1172,8 +1186,6 @@ class OuroDaemon {
                     sessionId: command.sessionId,
                     taskRef: command.taskRef,
                 });
-                await this.processManager.startAgent(command.to);
-                this.processManager.sendToAgent?.(command.to, { type: "message" });
                 return { ok: true, message: `queued message ${receipt.id}`, data: receipt };
             }
             case "message.poll": {

package/package.json

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