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

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.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": [

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) => {

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