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

package/changelog.json

@@ -1,6 +1,21 @@
 {
   "_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.273",
+      "changes": [
+        "feat(version-manager): auto-prune old CLI versions during activate. The user observed `~/.ouro-cli/versions/` accumulating every CLI version they'd ever installed (alpha.85 from 2026-03-20 onward, ~100MB+ of dead node_modules trees) because nothing ever GCed. New `pruneOldVersions(retain=5, deps?)` walks `~/.ouro-cli/versions/`, sorts by alpha-suffix numerically, and deletes everything outside the retention window — except always preserves (a) the currently-active version (CurrentVersion symlink target), and (b) the previous version (previous symlink target), so `ouro rollback` stays one command away. Wired into `cli-defaults.ts` via `ensureCurrentVersionInstalled` and `activateCliVersion` — every successful version activation self-prunes. New helpers `compareCliVersions(a, b)` and `selectVersionsToPrune(installed, protected, retain)` are pure and exported for direct unit coverage. 9 new tests covering version comparison, retention selection, current/previous protection, partial-failure handling, missing-symlink fallback, and non-directory entry filtering.",
+        "test(contract): new OURO_DAEMON_INSTANTIATION_ALLOWLIST in test-isolation.contract.test.ts flags any new test file that constructs `new OuroDaemon(...)` outside the 11 grandfathered files. Constructing a real daemon and calling start() runs killOrphanProcesses() and writePidfile() against the production pidfile at ~/.ouro-cli/daemon.pids. The runtime guards added in #346 short-circuit those functions under vitest, but if a future change to start() adds a NEW production-state side-effect, the existing 11 tests would silently exercise it. The contract test forces conscious review of each new file taking this shape — same defense-in-depth pattern as BYPASS_USE_ALLOWLIST in alpha.265."
+      ]
+    },
+    {
+      "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-defaults.js

@@ -494,6 +494,14 @@ function createDefaultOuroCliDeps(socketPath = socket_client_1.DEFAULT_DAEMON_SO
                 (0, ouro_version_manager_1.installVersion)(version, {});
             }
             (0, ouro_version_manager_1.activateVersion)(version, {});
+            // Self-prune: every successful version activation cleans up old
+            // versions outside the retention window. Without this, every CLI
+            // version ever installed accumulates indefinitely under
+            // ~/.ouro-cli/versions/ — the user observed installs going back to
+            // alpha.85 from March 20 (~100MB of dead node_modules trees).
+            // pruneOldVersions keeps the 5 most recent + the active + the
+            // previous version, so rollback stays one command away.
+            (0, ouro_version_manager_1.pruneOldVersions)(undefined, {});
         },
         /* v8 ignore stop */
         /* v8 ignore start -- CLI version management defaults: integration code @preserve */
@@ -508,7 +516,14 @@ function createDefaultOuroCliDeps(socketPath = socket_client_1.DEFAULT_DAEMON_SO
             });
         },
         installCliVersion: async (version) => { (0, ouro_version_manager_1.installVersion)(version, {}); },
-        activateCliVersion: (version) => { (0, ouro_version_manager_1.activateVersion)(version, {}); },
+        activateCliVersion: (version) => {
+            (0, ouro_version_manager_1.activateVersion)(version, {});
+            // Same self-prune as ensureCurrentVersionInstalled — fires from the
+            // checkForCliUpdate path 1 (in-process update detected → activate
+            // → re-exec). Without this, the path 1 code path never triggers
+            // a prune.
+            (0, ouro_version_manager_1.pruneOldVersions)(undefined, {});
+        },
         getCurrentCliVersion: () => (0, ouro_version_manager_1.getCurrentVersion)({}),
         getPreviousCliVersion: () => (0, ouro_version_manager_1.getPreviousVersion)({}),
         listCliVersions: () => (0, ouro_version_manager_1.listInstalledVersions)({}),

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/ouro-version-manager.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_RETAIN_VERSIONS = void 0;
 exports.getOuroCliHome = getOuroCliHome;
 exports.getCurrentVersion = getCurrentVersion;
 exports.getPreviousVersion = getPreviousVersion;
@@ -40,11 +41,16 @@ exports.buildChangelogCommand = buildChangelogCommand;
 exports.listInstalledVersions = listInstalledVersions;
 exports.installVersion = installVersion;
 exports.activateVersion = activateVersion;
+exports.compareCliVersions = compareCliVersions;
+exports.selectVersionsToPrune = selectVersionsToPrune;
+exports.pruneOldVersions = pruneOldVersions;
 exports.ensureLayout = ensureLayout;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
+/** Maximum number of installed CLI versions to retain after pruning. */
+exports.DEFAULT_RETAIN_VERSIONS = 5;
 function getOuroCliHome(homeDir) {
     /* v8 ignore next -- dep default: tests always inject @preserve */
     const home = homeDir ?? os.homedir();
@@ -155,6 +161,124 @@ function activateVersion(version, deps) {
     }
     symlinkSync(newTarget, currentVersionPath);
 }
+/**
+ * Compare two version strings of the form `0.1.0-alpha.{n}`. Returns
+ * positive when `a` is newer, negative when `b` is newer, 0 when equal.
+ *
+ * The harness only ships `0.1.0-alpha.{n}` versions today; this comparator
+ * extracts the numeric tail and falls back to a lexicographic compare for
+ * any version that doesn't match the pattern (so unexpected version
+ * formats sort consistently rather than throwing).
+ */
+function compareCliVersions(a, b) {
+    const aMatch = /alpha\.(\d+)/.exec(a);
+    const bMatch = /alpha\.(\d+)/.exec(b);
+    if (aMatch && bMatch) {
+        const aN = parseInt(aMatch[1], 10);
+        const bN = parseInt(bMatch[1], 10);
+        return aN - bN;
+    }
+    // Fallback: lexicographic. Both-mismatched and one-mismatched cases land
+    // here. Predictable, even if not strictly semver-correct.
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+}
+/**
+ * Identify which installed CLI versions can be safely deleted, given a
+ * retention policy. Pure: takes the full version list and the protected
+ * (current/previous) versions, returns the versions to delete.
+ *
+ * Retention rules:
+ *   - Always keep the N most recent versions (default 5).
+ *   - Always keep the currently-active version (CurrentVersion symlink target).
+ *   - Always keep the previous version (previous symlink target) so rollback
+ *     stays one command away.
+ *   - Delete everything else.
+ *
+ * Exported so tests can pin the policy without shelling out to a real fs.
+ */
+function selectVersionsToPrune(installedVersions, protectedVersions, retain = exports.DEFAULT_RETAIN_VERSIONS) {
+    if (installedVersions.length <= retain)
+        return [];
+    const sorted = [...installedVersions].sort(compareCliVersions).reverse();
+    const keepers = new Set(sorted.slice(0, retain));
+    if (protectedVersions.current)
+        keepers.add(protectedVersions.current);
+    if (protectedVersions.previous)
+        keepers.add(protectedVersions.previous);
+    return installedVersions.filter((v) => !keepers.has(v));
+}
+/**
+ * Prune installed CLI versions according to the retention policy. Removes
+ * `~/.ouro-cli/versions/{version}/` directories for versions outside the
+ * retention window. Best-effort: per-version delete failures are logged
+ * via nerves but don't propagate.
+ *
+ * Called from the activate path (cli-defaults.ts) so that every successful
+ * `ouro up` self-prunes. The user observed `~/.ouro-cli/versions/` going
+ * back to alpha.85 from March 20 — every CLI version they'd ever installed
+ * was still on disk because nothing ever GCed.
+ */
+function pruneOldVersions(retain = exports.DEFAULT_RETAIN_VERSIONS, deps = {}) {
+    const cliHome = getOuroCliHome(deps.homeDir);
+    /* v8 ignore start -- dep defaults: tests always inject @preserve */
+    const readdirSync = deps.readdirSync ?? ((p, opts) => fs.readdirSync(p, opts));
+    const readlinkSync = deps.readlinkSync ?? fs.readlinkSync;
+    const rmSync = deps.rmSync ?? fs.rmSync;
+    /* v8 ignore stop */
+    const versionsDir = path.join(cliHome, "versions");
+    let installed;
+    try {
+        installed = readdirSync(versionsDir, { withFileTypes: true })
+            .filter((e) => e.isDirectory())
+            .map((e) => e.name);
+    }
+    catch {
+        return { kept: [], deleted: [], failed: [] };
+    }
+    const current = (() => {
+        try {
+            return path.basename(readlinkSync(path.join(cliHome, "CurrentVersion")));
+        }
+        catch {
+            return null;
+        }
+    })();
+    const previous = (() => {
+        try {
+            return path.basename(readlinkSync(path.join(cliHome, "previous")));
+        }
+        catch {
+            return null;
+        }
+    })();
+    const toDelete = selectVersionsToPrune(installed, { current, previous }, retain);
+    const deleted = [];
+    const failed = [];
+    for (const version of toDelete) {
+        const versionDir = path.join(versionsDir, version);
+        try {
+            rmSync(versionDir, { recursive: true, force: true });
+            deleted.push(version);
+        }
+        catch (error) {
+            failed.push({
+                version,
+                error: error instanceof Error ? error.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(error),
+            });
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.cli_versions_pruned",
+        message: `pruned ${deleted.length} old CLI versions`,
+        meta: { retain, deleted, failed: failed.length, kept: installed.filter((v) => !deleted.includes(v)) },
+    });
+    return { kept: installed.filter((v) => !deleted.includes(v)), deleted, failed };
+}
 function ensureLayout(deps) {
     const cliHome = getOuroCliHome(deps.homeDir);
     /* v8 ignore next -- dep default: tests always inject @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.271",
+  "version": "0.1.0-alpha.273",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",