@ouro.bot/cli 0.1.0-alpha.270 → 0.1.0-alpha.272

package/changelog.json

@@ -1,6 +1,20 @@
 {
   "_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.272",
+      "changes": [
+        "fix(daemon): the daemon's periodic update checker can now actually auto-update itself. The `onUpdate` callback in `daemon.ts` invoked `performStagedRestart` which (a) ran `npm install -g @ouro.bot/cli@{version}` to install to the global node prefix, and (b) tried to find the new code via `node -e \"console.log(require.resolve('@ouro.bot/cli/package.json'))\"` which depends on the daemon process's NODE_PATH. Neither path was actually reachable from the daemon process running out of `~/.ouro-cli/versions/{version}/...`, so every auto-update attempt bailed at `daemon.staged_restart_path_failed` (\"could not resolve new code path\") and the daemon never updated itself. The user had to manually run `ouro up` to pick up new versions. Fix: switch the staged restart to use the version-managed installer (same one the CLI's `up` flow uses) — `installVersion(version)` puts files at `~/.ouro-cli/versions/{version}/node_modules/@ouro.bot/cli` (deterministic, computable), then `activateVersion(version)` flips the CurrentVersion symlink so the next user-driven `ouro up` sees the same version the daemon is running. `performStagedRestart` gained an optional `installNewVersion` dep that production callers inject; the legacy `npm install -g` fallback path is preserved for tests. Two new regression tests in `staged-restart.test.ts`.",
+        "fix(cli): `ouro up` no longer prints the 'ouro updated to ...' message twice during npx invocations. Three independent paths can detect a CLI version change: (1) `checkForCliUpdate` finds a newer version on npm and re-execs (cross-process print), (2) `ensureCurrentVersionInstalled` flips the CurrentVersion symlink during `performSystemSetup` because the running package version is newer than what the symlink pointed at (path 2, in-process), (3) `bundle-meta.json`'s stored runtime version differs from the running version (path 3, in-process fallback). Path 3's existing guard `linkedVersionBeforeUp !== currentVersion` correctly skipped path 3 when path 1 had already printed in a different process, but did NOT catch the case where path 2 fired in the same process. Verified live on 2026-04-08: `npx --yes @ouro.bot/cli@alpha up` printed the message twice. Fix: track an in-process `printedUpdateMessage` flag set by path 2; path 3 checks it before printing. Path 3 still acts as a fallback when path 2 didn't fire. New regression test in `daemon-cli-update-flow.test.ts` simulates the npx scenario and asserts exactly one print.",
+        "fix(hooks): Claude Code lifecycle hooks (`ouro hook session-start|stop|post-tool-use`) now short-circuit when the daemon socket file doesn't exist, instead of attempting `sendDaemonCommand` and logging two ENOENT errors per hook fire (one for `message.send`, one for `inner.wake`). Every Claude Code event during a daemon-down window was producing noisy `connect ENOENT /tmp/ouroboros-daemon.sock` entries in `ouro.ndjson`, which made it hard to read logs around outages. The hook is best-effort by design — dropping notifications when the daemon is down is correct behavior; we just don't want to log spam about it. New nerves event `daemon.hook_skipped_no_socket` (info level) when the short-circuit fires."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.271",
+      "changes": [
+        "fix(daemon): unblock daemon.stop deadlock that hung `ouro up` after a CLI auto-update. When the running daemon's version drifted from the local CLI version, `ensureDaemonRunning` would send `daemon.stop` over the socket, the daemon's command handler would `await this.stop()`, and `stop()` would `await server.close()`. server.close() resolves only after every open connection has closed — but the calling client's connection was the ONE thing keeping the server open: its `flushResponse()` was awaiting THIS function call. Both processes sat in kevent forever. Verified live on 2026-04-08: alpha.268 daemon hung at `daemon.server_end` log line for 5+ minutes after a fresh alpha.270 ouro process sent daemon.stop, and the alpha.270 ouro process hung waiting for the response. The deadlock had existed since the original `await server.close()` line was added (2026-03-05) but was masked for weeks by the half-close behavior in socket-client: the client called `client.end()` after writing its command, which (with `allowHalfOpen: false`) caused node to auto-tear-down the server's writable side, incidentally unblocking server.close() before the response was sent. The fix in #303/#334/#339 (which removed `client.end()` and switched to `allowHalfOpen: true` to stop dropping long-running responses like agent.senseTurn) accidentally exposed the underlying deadlock. Fix: don't `await` server.close() in stop() — just fire it. Once stop() returns, the daemon.stop case returns its response, flushResponse calls connection.end(response), the connection closes, and server.close()'s pending callback fires asynchronously. Includes a new daemon-stop-deadlock.test.ts that uses real net sockets to drive daemon.stop and asserts the response comes back within 2s — the test fails (24s timeout) without the fix and passes (110ms) with it."
+      ]
+    },
     {
       "version": "0.1.0-alpha.270",
       "changes": [

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

@@ -791,6 +791,27 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
             }
         }
         await performSystemSetup(deps);
+        // Track whether we've already printed the "ouro updated to" message
+        // this turn so the bundle-meta-fallback path below doesn't double-print.
+        // There are three independent paths that can detect "the binary just
+        // got newer":
+        //   1. checkForCliUpdate found a newer version on npm (above) — this
+        //      path always re-execs, so the duplicate-detect runs in a
+        //      different process and the in-process tracker doesn't apply.
+        //   2. ensureCurrentVersionInstalled (called from performSystemSetup)
+        //      flipped the CurrentVersion symlink because the running package
+        //      version is newer than what the symlink pointed at. This is the
+        //      common npx path.
+        //   3. bundle-meta.json's stored runtime version differs from the
+        //      running version (fallback for when path 2 couldn't activate
+        //      but the binary is still newer).
+        //
+        // Verified live on 2026-04-08: npx download triggered both path 2 and
+        // path 3 in the same process and the user saw the message printed twice.
+        // Path 3's existing `linkedVersionBeforeUp !== currentVersion` guard
+        // catches the cross-process re-exec case (path 1) but not the
+        // in-process double-fire case (path 2 + path 3 in the same process).
+        let printedUpdateMessage = false;
         const linkedVersionAfterSetup = deps.getCurrentCliVersion?.() ?? null;
         const runtimeVersion = (0, bundle_manifest_1.getPackageVersion)();
         if (linkedVersionBeforeUp && linkedVersionBeforeUp !== runtimeVersion && linkedVersionAfterSetup === runtimeVersion) {
@@ -799,6 +820,7 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
             if (changelogCommand) {
                 deps.writeStdout(`review changes with: ${changelogCommand}`);
             }
+            printedUpdateMessage = true;
         }
         // Run update hooks before starting daemon so user sees the output
         (0, update_hooks_1.registerUpdateHook)(bundle_meta_1.bundleMetaHook);
@@ -812,9 +834,14 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
         // Notify about CLI binary update (npx downloaded a new version).
         // Skip when the symlink already points to the running version — that
         // means path 1 (checkForCliUpdate + reExecFromNewVersion) already
-        // printed the update message before re-exec.
+        // printed the update message before re-exec. Also skip when path 2
+        // (the symlink-flip detector above) already printed in this same
+        // process — otherwise npx invocations print the message twice.
         /* v8 ignore start -- CLI update detection: tested via daemon-cli-version-detect.test.ts @preserve */
-        if (previousCliVersion && previousCliVersion !== currentVersion && linkedVersionBeforeUp !== currentVersion) {
+        if (!printedUpdateMessage
+            && previousCliVersion
+            && previousCliVersion !== currentVersion
+            && linkedVersionBeforeUp !== currentVersion) {
             deps.writeStdout(`ouro updated to ${currentVersion} (was ${previousCliVersion})`);
             const changelogCommand = (0, ouro_version_manager_1.buildChangelogCommand)(previousCliVersion, currentVersion);
             /* v8 ignore next -- buildChangelogCommand is non-null when previous/current runtime versions differ @preserve */
@@ -1122,12 +1149,29 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
         else {
             content = `[Claude Code hook: ${eventType} in session ${sessionId}]`;
         }
-        // Send to the specific agent configured for this hook
-        try {
-            await deps.sendCommand(deps.socketPath, { kind: "message.send", from: `claude-code:${sessionId}`, to: command.agent, content }).catch(() => { });
-            await deps.sendCommand(deps.socketPath, { kind: "inner.wake", agent: command.agent }).catch(() => { });
+        // Send to the specific agent configured for this hook. Short-circuit
+        // when the daemon socket file doesn't exist — otherwise every
+        // Claude Code lifecycle event during a daemon-down window logs two
+        // ENOENT errors in ouro.ndjson (one for message.send, one for
+        // inner.wake) which makes it hard to read the log around outages.
+        // The hook is best-effort: dropping notifications when the daemon
+        // is down is the correct behavior; we just don't want to log spam
+        // about it.
+        if (require("fs").existsSync(deps.socketPath)) {
+            try {
+                await deps.sendCommand(deps.socketPath, { kind: "message.send", from: `claude-code:${sessionId}`, to: command.agent, content }).catch(() => { });
+                await deps.sendCommand(deps.socketPath, { kind: "inner.wake", agent: command.agent }).catch(() => { });
+            }
+            catch { /* daemon not running — silent */ }
+        }
+        else {
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.hook_skipped_no_socket",
+                message: "claude code hook skipped — daemon socket missing",
+                meta: { socketPath: deps.socketPath, eventType, agent: command.agent },
+            });
         }
-        catch { /* daemon not running — silent */ }
         // Output for Claude Code hook system
         deps.writeStdout(JSON.stringify({ continue: true }));
         return JSON.stringify({ continue: true });

package/dist/heart/daemon/daemon.js

@@ -54,6 +54,7 @@ const agent_config_v2_1 = require("./hooks/agent-config-v2");
 const bundle_manifest_1 = require("../../mind/bundle-manifest");
 const update_checker_1 = require("../versioning/update-checker");
 const staged_restart_1 = require("../versioning/staged-restart");
+const ouro_version_manager_1 = require("../versioning/ouro-version-manager");
 const child_process_1 = require("child_process");
 const pending_1 = require("../../mind/pending");
 const agent_service_1 = require("./agent-service");
@@ -427,17 +428,34 @@ class OuroDaemon {
                 onUpdate: /* v8 ignore start -- integration: real npm install + process spawn @preserve */ async (result) => {
                     if (!result.latestVersion)
                         return;
+                    // Install via the version manager (NOT `npm install -g`). The
+                    // global install path doesn't end up on the daemon process's
+                    // NODE_PATH, so the previous `require.resolve('@ouro.bot/cli')`
+                    // -based path lookup always returned null and the staged restart
+                    // never actually completed. Verified live on 2026-04-08:
+                    // alpha.268 daemon detected alpha.270 was available, ran the
+                    // staged restart, and bailed at `staged_restart_path_failed` —
+                    // meaning the daemon could never auto-update itself and required
+                    // manual `ouro up` to pick up new versions.
+                    //
+                    // Switch to the version-managed layout the CLI itself uses:
+                    // installVersion(version) puts files at
+                    //   ~/.ouro-cli/versions/{version}/node_modules/@ouro.bot/cli
+                    // which is a known path we can compute deterministically.
+                    // Then activateVersion(version) flips the CurrentVersion symlink
+                    // so the next `ouro up` from the user sees the same version
+                    // the daemon is running.
+                    const cliHome = (0, ouro_version_manager_1.getOuroCliHome)();
                     await (0, staged_restart_1.performStagedRestart)(result.latestVersion, {
                         execSync: (cmd) => (0, child_process_1.execSync)(cmd, { stdio: "inherit" }),
                         spawnSync: child_process_1.spawnSync,
-                        resolveNewCodePath: (_version) => {
-                            try {
-                                const resolved = (0, child_process_1.execSync)(`node -e "console.log(require.resolve('@ouro.bot/cli/package.json'))"`, { encoding: "utf-8" }).trim();
-                                return resolved ? path.dirname(resolved) : null;
-                            }
-                            catch {
-                                return null;
-                            }
+                        installNewVersion: (version) => {
+                            (0, ouro_version_manager_1.installVersion)(version, {});
+                            (0, ouro_version_manager_1.activateVersion)(version, {});
+                        },
+                        resolveNewCodePath: (version) => {
+                            const versionPath = path.join(cliHome, "versions", version, "node_modules", "@ouro.bot", "cli");
+                            return fs.existsSync(versionPath) ? versionPath : null;
                         },
                         gracefulShutdown: () => daemon.stop(),
                         spawnNewDaemon: (entryPath, sock) => {
@@ -745,9 +763,36 @@ class OuroDaemon {
         await this.processManager.stopAll();
         await this.senseManager?.stopAll();
         if (this.server) {
-            await new Promise((resolve) => {
-                this.server?.close(() => resolve());
-            });
+            // DO NOT `await` server.close() here. server.close() resolves only
+            // after every open connection has closed. When stop() is invoked
+            // from the daemon.stop command handler, the calling client's
+            // connection is STILL open — its flushResponse() is currently
+            // awaiting THIS function. Awaiting close() creates a deadlock:
+            //
+            //   client → flushResponse → handleRawPayload → daemon.stop case
+            //   → stop() → await server.close() (waits for client's connection)
+            //   → client's connection waits for flushResponse to call
+            //     connection.end() → DEADLOCK
+            //
+            // Both processes sit in kevent forever. Verified live on
+            // 2026-04-08: alpha.268 daemon hung at `daemon.server_end` log
+            // line for 5+ minutes after a client sent daemon.stop, while the
+            // client (alpha.270 ouro up) hung waiting for the response.
+            //
+            // This regressed when #303/#334/#339 stopped half-closing the
+            // client socket and switched the server to allowHalfOpen: true.
+            // Previously, the client called .end() after writing its command,
+            // which (with allowHalfOpen: false) caused node to auto-tear-down
+            // the server's writable side — incidentally unblocking
+            // server.close() before the response was sent. The half-close
+            // breakage masked this deadlock; the fix exposed it.
+            //
+            // Solution: fire close() and let it complete asynchronously. Once
+            // stop() returns, the daemon.stop case returns its response,
+            // flushResponse() calls connection.end(response), the connection
+            // closes, and server.close()'s pending callback fires. The event
+            // loop drains and the daemon exits cleanly.
+            this.server.close();
             this.server = null;
         }
         /* v8 ignore start -- outlookServer stop: only reachable when the outlook HTTP server successfully bound to port 6876 during start(). Coverage fluctuates locally because a running production daemon holds the port and tests get EADDRINUSE, leaving outlookServer null. In CI the port is free and this block runs. Not worth fighting port contention to cover two trivial lines. @preserve */

package/dist/heart/versioning/staged-restart.js

@@ -45,14 +45,22 @@ async function performStagedRestart(version, deps) {
     });
     // Step 1: Install new version
     try {
-        deps.execSync(`npm install -g @ouro.bot/cli@${version}`);
+        if (deps.installNewVersion) {
+            deps.installNewVersion(version);
+        }
+        else {
+            // Backward-compat fallback for callers that haven't migrated to the
+            // version-managed installer. Tests use this path with a mocked
+            // execSync; production callers inject installNewVersion.
+            deps.execSync(`npm install -g @ouro.bot/cli@${version}`);
+        }
     }
     catch (err) {
         const errorMessage = err instanceof Error ? err.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(err);
         (0, runtime_1.emitNervesEvent)({
             component: "daemon",
             event: "daemon.staged_restart_install_failed",
-            message: "npm install failed",
+            message: "install failed",
             meta: { version, error: errorMessage },
         });
         return { ok: false, error: errorMessage };

package/package.json

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