@ouro.bot/cli 0.1.0-alpha.83 → 0.1.0-alpha.830

package/dist/heart/daemon/session-id-resolver.js

@@ -0,0 +1,131 @@
+"use strict";
+// Pluggable session ID resolver for MCP conversations.
+// Tries tool-specific methods first, falls back to UUID.
+//
+// Claude Code: walks parent PID chain -> reads ~/.claude/sessions/{pid}.json
+// Codex: reads thread_id from env (future)
+// Fallback: generates UUID
+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.resolveSessionId = resolveSessionId;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const crypto_1 = require("crypto");
+const runtime_1 = require("../../nerves/runtime");
+const DEFAULT_CLAUDE_SESSIONS_DIR = path.join(os.homedir(), ".claude", "sessions");
+const MAX_PID_WALK_DEPTH = 10;
+/**
+ * Try to read a Claude Code session ID from a PID-keyed session file.
+ * Returns the sessionId if found, null otherwise.
+ */
+function tryReadClaudeSession(sessionsDir, pid) {
+    const sessionFile = path.join(sessionsDir, `${pid}.json`);
+    if (!fs.existsSync(sessionFile))
+        return null;
+    try {
+        const raw = fs.readFileSync(sessionFile, "utf-8");
+        const data = JSON.parse(raw);
+        if (typeof data.sessionId === "string" && data.sessionId.length > 0) {
+            return data.sessionId;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Walk the parent PID chain looking for a Claude Code session file.
+ * Starts at the current process PID, walks up to parent, grandparent, etc.
+ * Returns the session ID from the first matching file, or null.
+ */
+function walkPidChain(sessionsDir) {
+    let currentPid = process.pid;
+    for (let depth = 0; depth < MAX_PID_WALK_DEPTH; depth++) {
+        const sessionId = tryReadClaudeSession(sessionsDir, currentPid);
+        if (sessionId) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.session_id_pid_walk_hit",
+                message: "found Claude session via PID walk",
+                meta: { pid: currentPid, depth, sessionId },
+            });
+            return sessionId;
+        }
+        // Walk to parent PID
+        // On macOS/Linux, process.ppid gives the parent. For deeper ancestry,
+        // we'd need /proc/{pid}/stat or ps -o ppid=. For now, we check current + parent.
+        if (depth === 0) {
+            currentPid = process.ppid;
+        }
+        else {
+            // Cannot walk further without OS-specific process tree APIs
+            break;
+        }
+    }
+    return null;
+}
+/**
+ * Resolve a session ID for the current MCP connection.
+ * Returns a stable identifier that ties MCP tool calls to a conversation session.
+ *
+ * Resolution order:
+ * 1. Claude Code PID walk: check ~/.claude/sessions/{pid}.json for current + parent PID
+ * 2. UUID fallback: generate a random UUID
+ */
+function resolveSessionId(options) {
+    const sessionsDir = options?.claudeSessionsDir ?? DEFAULT_CLAUDE_SESSIONS_DIR;
+    // Try Claude Code PID walk
+    const claudeSessionId = walkPidChain(sessionsDir);
+    if (claudeSessionId) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.session_id_resolved",
+            message: "session ID resolved via Claude Code PID walk",
+            meta: { sessionId: claudeSessionId, method: "claude-pid-walk" },
+        });
+        return claudeSessionId;
+    }
+    // Fallback: UUID
+    const sessionId = (0, crypto_1.randomUUID)();
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.session_id_resolved",
+        message: "session ID resolved via UUID fallback",
+        meta: { sessionId, method: "uuid-fallback" },
+    });
+    return sessionId;
+}

package/dist/heart/daemon/skill-management-installer.js

@@ -38,7 +38,7 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
 const identity_1 = require("../identity");
-const SKILL_MANAGEMENT_URL = "https://raw.githubusercontent.com/ouroborosbot/ouroboros-skills/main/skills/skill-management/SKILL.md";
+const SKILL_MANAGEMENT_URL = "https://raw.githubusercontent.com/ourostack/ouroboros-skills/main/skills/skill-management/SKILL.md";
 async function ensureSkillManagement() {
     const bundlesRoot = (0, identity_1.getAgentBundlesRoot)();
     if (!fs.existsSync(bundlesRoot))

package/dist/heart/daemon/socket-client.js

@@ -33,15 +33,93 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_DAEMON_SOCKET_PATH = void 0;
+exports.DEFAULT_DAEMON_STATUS_TIMEOUT_MS = exports.DEFAULT_DAEMON_COMMAND_TIMEOUT_MS = exports.DEFAULT_DAEMON_SOCKET_PATH = void 0;
+exports.__bypassVitestGuardForTests = __bypassVitestGuardForTests;
 exports.sendDaemonCommand = sendDaemonCommand;
 exports.checkDaemonSocketAlive = checkDaemonSocketAlive;
 exports.requestInnerWake = requestInnerWake;
+exports.requestPrivateWake = requestPrivateWake;
 const fs = __importStar(require("fs"));
 const net = __importStar(require("net"));
 const runtime_1 = require("../../nerves/runtime");
 exports.DEFAULT_DAEMON_SOCKET_PATH = "/tmp/ouroboros-daemon.sock";
-function sendDaemonCommand(socketPath, command) {
+exports.DEFAULT_DAEMON_COMMAND_TIMEOUT_MS = 10 * 60 * 1000;
+exports.DEFAULT_DAEMON_STATUS_TIMEOUT_MS = 5_000;
+/**
+ * Defense-in-depth: detect if we're running under vitest. Tests that forget
+ * to `vi.mock("../../heart/daemon/socket-client")` would otherwise leak real
+ * `inner.wake` commands (with whatever literal agent name the test uses,
+ * commonly "testagent") into whichever real daemon happens to be running on
+ * the developer's machine. That has caused real outages when test loops
+ * flooded the production-on-localhost daemon.
+ *
+ * We detect vitest via `process.argv` (not env vars — the project bans those)
+ * and convert all socket operations into safe no-ops. Individual tests are
+ * still expected to vi.mock this module so they can assert on call counts,
+ * but this guard guarantees that "I forgot to mock" can never again take
+ * down the daemon.
+ *
+ * The socket-client's OWN tests (which exercise the real functions against a
+ * test socket) call `__bypassVitestGuardForTests(true)` to opt out of the
+ * guard. We persist that flag on globalThis so it survives `vi.resetModules`
+ * (which clears the module cache between tests).
+ *
+ * HARDENING (cross-file leak protection): the bypass flag lives on globalThis
+ * and is process-wide. With vitest's default `fileParallelism: true`,
+ * concurrently-running test files in the same worker can have the bypass on
+ * even though they didn't ask for it — and any test that uses
+ * `name: "testagent"` and exercises a code path through this module will
+ * leak `inner.wake testagent` to the production daemon socket. We saw this
+ * cause a real outage on 2026-04-08 (daemon SIGTERMed mid-validation).
+ *
+ * Defense: even when the bypass flag is set, we ALWAYS hard-block calls that
+ * target the production daemon socket path. Test files that legitimately
+ * exercise the real socket-client code paths use a synthetic socket path like
+ * `/tmp/daemon.sock` or `/tmp/some-real-daemon.sock` — those keep working.
+ * Calls to `/tmp/ouroboros-daemon.sock` (DEFAULT_DAEMON_SOCKET_PATH) under
+ * vitest are unconditionally blocked, regardless of bypass state. This makes
+ * the cross-file leak vector impossible without restricting legitimate
+ * socket-client unit tests.
+ */
+const BYPASS_KEY = "__ouro_socket_client_bypass_vitest_guard__";
+/** ONLY for socket-client.test.ts. Do not call from any other test or production code. */
+function __bypassVitestGuardForTests(bypass) {
+    ;
+    globalThis[BYPASS_KEY] = bypass;
+}
+function isVitestProcess() {
+    /* v8 ignore next -- defensive: process and process.argv always exist in node @preserve */
+    if (typeof process === "undefined" || !Array.isArray(process.argv))
+        return false;
+    return process.argv.some((arg) => typeof arg === "string" && arg.includes("vitest"));
+}
+function isProductionDaemonSocket(socketPath) {
+    return socketPath === exports.DEFAULT_DAEMON_SOCKET_PATH;
+}
+/**
+ * Returns true when this socket call should be converted into a safe no-op
+ * because we're under vitest and the call would otherwise leak into a real
+ * daemon. The bypass flag short-circuits the guard for non-production socket
+ * paths only — production socket paths are ALWAYS blocked under vitest.
+ */
+function shouldSuppressSocketCall(socketPath) {
+    if (!isVitestProcess())
+        return false;
+    if (isProductionDaemonSocket(socketPath))
+        return true;
+    return globalThis[BYPASS_KEY] !== true;
+}
+function sendDaemonCommand(socketPath, command, options = {}) {
+    if (shouldSuppressSocketCall(socketPath)) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.socket_command_test_blocked",
+            message: "blocked socket command from leaking into real daemon under vitest",
+            meta: { socketPath, kind: command.kind, isProductionSocket: isProductionDaemonSocket(socketPath) },
+        });
+        return Promise.resolve({ ok: true, message: "test mode: socket call suppressed" });
+    }
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.socket_command_start",
@@ -51,14 +129,75 @@ function sendDaemonCommand(socketPath, command) {
     return new Promise((resolve, reject) => {
         const client = net.createConnection(socketPath);
         let raw = "";
+        let settled = false;
+        const timeoutMs = options.timeoutMs ?? exports.DEFAULT_DAEMON_COMMAND_TIMEOUT_MS;
+        let deadlineTimer;
+        const clearDeadline = () => {
+            clearTimeout(deadlineTimer);
+        };
+        const resolveOnce = (response) => {
+            /* v8 ignore next -- duplicate settlement guard; callers also guard event handlers before reaching this helper @preserve */
+            if (settled)
+                return;
+            settled = true;
+            clearDeadline();
+            resolve(response);
+        };
+        const rejectOnce = (error) => {
+            /* v8 ignore next -- duplicate timeout/error races should not re-reject the command promise @preserve */
+            if (settled)
+                return;
+            settled = true;
+            clearDeadline();
+            reject(error);
+        };
+        deadlineTimer = setTimeout(() => {
+            /* v8 ignore next -- terminal socket events clear this timer; guard protects a queued timer callback race @preserve */
+            if (settled)
+                return;
+            const error = new Error(`Daemon command ${command.kind} timed out after ${timeoutMs}ms waiting for a response.`);
+            error.code = "ETIMEDOUT";
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "daemon",
+                event: "daemon.socket_command_timeout",
+                message: "daemon socket command timed out",
+                meta: {
+                    socketPath,
+                    kind: command.kind,
+                    timeoutMs,
+                    error: error.message,
+                },
+            });
+            client.destroy();
+            rejectOnce(error);
+        }, timeoutMs);
         client.on("connect", () => {
-            client.write(JSON.stringify(command));
-            client.end();
+            // Write the command + newline delimiter. DO NOT call client.end()
+            // afterwards — the server closes the connection once it has written
+            // its response, which triggers our on("end") handler with the full
+            // response in `raw`.
+            //
+            // Calling client.end() here half-closes the TCP connection. The
+            // daemon server uses net.createServer() with the default
+            // allowHalfOpen: false, so when the server sees the client's FIN it
+            // auto-closes its own writable side — and any response the server
+            // tries to write after processing a long-running command (like
+            // agent.senseTurn, which runs a full LLM turn) gets dropped on the
+            // floor. Verified via repro: with client.end(), agent.senseTurn
+            // returns empty in ~149ms; without it, the same call returns the real
+            // response in ~5.8s. This is a regression of the fix in #303 that
+            // was silently reverted by 253e4b1f (commit titled "socket half-close
+            // fix" but actually *added* the half-close back).
+            client.write(JSON.stringify(command) + "\n");
         });
         client.on("data", (chunk) => {
             raw += chunk.toString("utf-8");
         });
         client.on("error", (error) => {
+            /* v8 ignore next -- duplicate post-settlement socket errors are ignored defensively @preserve */
+            if (settled)
+                return;
             (0, runtime_1.emitNervesEvent)({
                 level: "error",
                 component: "daemon",
@@ -70,9 +209,12 @@ function sendDaemonCommand(socketPath, command) {
                     error: error.message,
                 },
             });
-            reject(error);
+            rejectOnce(error);
         });
         client.on("end", () => {
+            /* v8 ignore next -- duplicate post-settlement socket end events are ignored defensively @preserve */
+            if (settled)
+                return;
             const trimmed = raw.trim();
             if (trimmed.length === 0 && command.kind === "daemon.stop") {
                 (0, runtime_1.emitNervesEvent)({
@@ -81,7 +223,7 @@ function sendDaemonCommand(socketPath, command) {
                     message: "daemon socket command completed",
                     meta: { socketPath, kind: command.kind, ok: true },
                 });
-                resolve({ ok: true, message: "daemon stopped" });
+                resolveOnce({ ok: true, message: "daemon stopped" });
                 return;
             }
             if (trimmed.length === 0) {
@@ -97,7 +239,7 @@ function sendDaemonCommand(socketPath, command) {
                         error: error.message,
                     },
                 });
-                reject(error);
+                rejectOnce(error);
                 return;
             }
             try {
@@ -112,7 +254,7 @@ function sendDaemonCommand(socketPath, command) {
                         ok: parsed.ok,
                     },
                 });
-                resolve(parsed);
+                resolveOnce(parsed);
             }
             catch (error) {
                 (0, runtime_1.emitNervesEvent)({
@@ -126,12 +268,15 @@ function sendDaemonCommand(socketPath, command) {
                         error: error instanceof Error ? error.message : String(error),
                     },
                 });
-                reject(error);
+                rejectOnce(error);
             }
         });
     });
 }
 function checkDaemonSocketAlive(socketPath) {
+    if (shouldSuppressSocketCall(socketPath)) {
+        return Promise.resolve(false);
+    }
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.socket_alive_check_start",
@@ -161,8 +306,10 @@ function checkDaemonSocketAlive(socketPath) {
             });
         }
         client.on("connect", () => {
-            client.write(JSON.stringify({ kind: "daemon.status" }));
-            client.end();
+            // Same half-close rationale as sendDaemonCommand: do NOT call
+            // client.end() here. The server closes after responding and that
+            // triggers the on("end") handler below.
+            client.write(JSON.stringify({ kind: "daemon.status" }) + "\n");
         });
         client.on("data", (chunk) => {
             raw += chunk.toString("utf-8");
@@ -184,11 +331,21 @@ function checkDaemonSocketAlive(socketPath) {
     });
 }
 async function requestInnerWake(agent, socketPath = exports.DEFAULT_DAEMON_SOCKET_PATH) {
+    if (shouldSuppressSocketCall(socketPath)) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.inner_wake_test_blocked",
+            message: "blocked legacy private-runtime wake alias from leaking into real daemon under vitest",
+            meta: { agent, socketPath, isProductionSocket: isProductionDaemonSocket(socketPath) },
+        });
+        return null;
+    }
     const socketAvailable = fs.existsSync(socketPath);
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.inner_wake_request",
-        message: "requesting daemon-managed inner wake",
+        message: "requesting daemon-managed legacy private-runtime wake alias",
         meta: {
             agent,
             socketPath,
@@ -200,3 +357,14 @@ async function requestInnerWake(agent, socketPath = exports.DEFAULT_DAEMON_SOCKE
     }
     return sendDaemonCommand(socketPath, { kind: "inner.wake", agent });
 }
+async function requestPrivateWake(agent, socketPath = exports.DEFAULT_DAEMON_SOCKET_PATH, options = {}) {
+    if (shouldSuppressSocketCall(socketPath))
+        return null;
+    if (!fs.existsSync(socketPath))
+        return null;
+    return sendDaemonCommand(socketPath, {
+        kind: "private.wake",
+        agent,
+        ...options,
+    });
+}

package/dist/heart/daemon/stale-bundle-prune.js

@@ -0,0 +1,113 @@
+"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.pruneStaleEphemeralBundles = pruneStaleEphemeralBundles;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const identity_1 = require("../identity");
+const runtime_1 = require("../../nerves/runtime");
+/**
+ * Scan the bundles root for `.ouro` directories that have no bundle contract
+ * or durable state markers (definitively dead ephemeral bundles) and delete
+ * them.
+ *
+ * Returns a list of pruned bundle directory names (e.g. `["stale.ouro"]`)
+ * for display purposes. Bundles that have `agent.json` -- even if disabled
+ * -- are never deleted. Task-doc-only bundles are also durable work state, so
+ * directories with state roots such as `tasks`, `desk`, `arc`, `state`, or
+ * `.git` are preserved. Errors on individual bundles are swallowed so that one
+ * permission-denied doesn't block pruning the rest.
+ */
+function pruneStaleEphemeralBundles(deps = {}) {
+    const bundlesRoot = deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
+    const readdirSync = deps.readdirSync ?? fs.readdirSync;
+    const existsSync = deps.existsSync ?? fs.existsSync;
+    const rmSync = deps.rmSync ?? fs.rmSync;
+    let entries;
+    try {
+        entries = readdirSync(bundlesRoot, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const pruned = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory() || !entry.name.endsWith(".ouro"))
+            continue;
+        const bundlePath = path.join(bundlesRoot, entry.name);
+        if (hasDurableBundleMarker(bundlePath, existsSync))
+            continue;
+        try {
+            rmSync(bundlePath, { recursive: true, force: true });
+            pruned.push(entry.name);
+            (0, runtime_1.emitNervesEvent)({
+                level: "info",
+                component: "daemon",
+                event: "daemon.stale_bundle_pruned",
+                message: `pruned stale ephemeral bundle: ${entry.name}`,
+                meta: { bundle: entry.name, bundlePath },
+            });
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.stale_bundle_prune_error",
+                message: `failed to prune stale bundle: ${entry.name}`,
+                meta: {
+                    bundle: entry.name,
+                    bundlePath,
+                    error: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
+    return pruned;
+}
+const DURABLE_BUNDLE_MARKERS = [
+    "agent.json",
+    "tasks",
+    "desk",
+    "arc",
+    "state",
+    "habits",
+    "friends",
+    "facts",
+    "vault",
+    ".git",
+];
+function hasDurableBundleMarker(bundlePath, existsSync) {
+    return DURABLE_BUNDLE_MARKERS.some((marker) => existsSync(path.join(bundlePath, marker)));
+}