@ouro.bot/cli 0.1.0-alpha.17 → 0.1.0-alpha.170

package/dist/heart/daemon/runtime-metadata.js

@@ -0,0 +1,219 @@
+"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.getRuntimeMetadata = getRuntimeMetadata;
+const crypto_1 = require("crypto");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const childProcess = __importStar(require("child_process"));
+const identity_1 = require("../identity");
+const runtime_1 = require("../../nerves/runtime");
+const UNKNOWN_METADATA = "unknown";
+function optionalFunction(target, key) {
+    try {
+        const candidate = target[key];
+        return typeof candidate === "function" ? candidate : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readVersion(packageJsonPath, readFileSyncImpl) {
+    try {
+        const parsed = JSON.parse(readFileSyncImpl(packageJsonPath, "utf-8"));
+        return typeof parsed.version === "string" && parsed.version.trim().length > 0
+            ? parsed.version.trim()
+            : UNKNOWN_METADATA;
+    }
+    catch {
+        return UNKNOWN_METADATA;
+    }
+}
+function readLastUpdated(repoRoot, packageJsonPath, statSyncImpl, execFileSyncImpl) {
+    try {
+        const raw = execFileSyncImpl("git", ["log", "-1", "--format=%cI"], {
+            cwd: repoRoot,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        if (raw.length > 0) {
+            return { value: raw, source: "git" };
+        }
+    }
+    catch {
+        // fall through to mtime fallback
+    }
+    try {
+        const stats = statSyncImpl(packageJsonPath);
+        return {
+            value: stats.mtime.toISOString(),
+            source: "package-json-mtime",
+        };
+    }
+    catch {
+        return { value: UNKNOWN_METADATA, source: "unknown" };
+    }
+}
+function readHomeDir() {
+    const homedirImpl = optionalFunction(os, "homedir");
+    if (!homedirImpl) {
+        return null;
+    }
+    try {
+        return homedirImpl.call(os);
+    }
+    catch {
+        return null;
+    }
+}
+function listConfigTargets(bundlesRoot, secretsRoot, daemonLoggingPath, readdirSyncImpl) {
+    if (!readdirSyncImpl)
+        return [];
+    const targets = new Set();
+    if (daemonLoggingPath) {
+        targets.add(daemonLoggingPath);
+    }
+    try {
+        const bundleEntries = readdirSyncImpl(bundlesRoot, { withFileTypes: true });
+        for (const entry of bundleEntries) {
+            if (!entry.isDirectory() || !entry.name.endsWith(".ouro"))
+                continue;
+            targets.add(path.join(bundlesRoot, entry.name, "agent.json"));
+        }
+    }
+    catch {
+        // ignore unreadable bundle roots
+    }
+    if (secretsRoot) {
+        try {
+            const secretEntries = readdirSyncImpl(secretsRoot, { withFileTypes: true });
+            for (const entry of secretEntries) {
+                if (!entry.isDirectory())
+                    continue;
+                targets.add(path.join(secretsRoot, entry.name, "secrets.json"));
+            }
+        }
+        catch {
+            // ignore unreadable secrets roots
+        }
+    }
+    return [...targets].sort();
+}
+function readConfigFingerprint(targets, readFileSyncImpl, existsSyncImpl) {
+    if (!readFileSyncImpl || !existsSyncImpl) {
+        return {
+            value: UNKNOWN_METADATA,
+            source: "unknown",
+            trackedFiles: targets.length,
+            presentFiles: 0,
+        };
+    }
+    const hash = (0, crypto_1.createHash)("sha256");
+    let presentFiles = 0;
+    for (const target of targets) {
+        hash.update(target);
+        hash.update("\0");
+        if (!existsSyncImpl(target)) {
+            hash.update("missing");
+            hash.update("\0");
+            continue;
+        }
+        presentFiles += 1;
+        hash.update("present");
+        hash.update("\0");
+        try {
+            hash.update(readFileSyncImpl(target, "utf-8"));
+        }
+        catch {
+            hash.update("unreadable");
+        }
+        hash.update("\0");
+    }
+    return {
+        value: hash.digest("hex"),
+        source: "content-hash",
+        trackedFiles: targets.length,
+        presentFiles,
+    };
+}
+function getRuntimeMetadata(deps = {}) {
+    const repoRoot = deps.repoRoot ?? (0, identity_1.getRepoRoot)();
+    const bundlesRoot = deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
+    const homeDir = readHomeDir();
+    const secretsRoot = deps.secretsRoot ?? (homeDir ? path.join(homeDir, ".agentsecrets") : null);
+    const daemonLoggingPath = deps.daemonLoggingPath ?? (0, identity_1.getAgentDaemonLoggingConfigPath)();
+    const readFileSyncImpl = deps.readFileSync ?? optionalFunction(fs, "readFileSync")?.bind(fs) ?? null;
+    const statSyncImpl = deps.statSync ?? optionalFunction(fs, "statSync")?.bind(fs) ?? null;
+    const readdirSyncImpl = deps.readdirSync ?? optionalFunction(fs, "readdirSync")?.bind(fs) ?? null;
+    const existsSyncImpl = deps.existsSync ?? optionalFunction(fs, "existsSync")?.bind(fs) ?? null;
+    const execFileSyncImpl = deps.execFileSync
+        ?? optionalFunction(childProcess, "execFileSync")?.bind(childProcess)
+        ?? null;
+    const packageJsonPath = path.join(repoRoot, "package.json");
+    const version = readFileSyncImpl
+        ? readVersion(packageJsonPath, readFileSyncImpl)
+        : UNKNOWN_METADATA;
+    const lastUpdated = statSyncImpl
+        ? readLastUpdated(repoRoot, packageJsonPath, statSyncImpl, execFileSyncImpl ?? (() => {
+            throw new Error("git unavailable");
+        }))
+        : { value: UNKNOWN_METADATA, source: "unknown" };
+    const configTargets = listConfigTargets(bundlesRoot, secretsRoot, daemonLoggingPath, readdirSyncImpl);
+    const configFingerprint = readConfigFingerprint(configTargets, readFileSyncImpl, existsSyncImpl);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.runtime_metadata_read",
+        message: "read runtime metadata",
+        meta: {
+            version,
+            lastUpdated: lastUpdated.value,
+            lastUpdatedSource: lastUpdated.source,
+            repoRoot,
+            configFingerprint: configFingerprint.value === UNKNOWN_METADATA
+                ? UNKNOWN_METADATA
+                : configFingerprint.value.slice(0, 12),
+            configFingerprintSource: configFingerprint.source,
+            configTrackedFiles: configFingerprint.trackedFiles,
+            configPresentFiles: configFingerprint.presentFiles,
+        },
+    });
+    return {
+        version,
+        lastUpdated: lastUpdated.value,
+        repoRoot,
+        configFingerprint: configFingerprint.value,
+    };
+}

package/dist/heart/daemon/runtime-mode.js

@@ -0,0 +1,67 @@
+"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.detectRuntimeMode = detectRuntimeMode;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+function detectRuntimeMode(rootPath, deps = {}) {
+    const checkExists = deps.existsSync ?? fs.existsSync;
+    // 1. Production: installed via npm
+    if (rootPath.includes("node_modules/@ouro.bot/cli") ||
+        rootPath.includes("node_modules/ouro.bot")) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.runtime_mode_detected",
+            message: "detected runtime mode",
+            meta: { rootPath, mode: "production" },
+        });
+        return "production";
+    }
+    // 2-4. Everything else is dev: worktrees, git repos, unknown paths
+    // (conservative default: assume dev unless proven production)
+    const reason = rootPath.includes(".claude/worktrees/")
+        ? "worktree"
+        : checkExists(path.join(rootPath, ".git"))
+            ? "git-repo"
+            : "unknown";
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.runtime_mode_detected",
+        message: "detected runtime mode",
+        meta: { rootPath, mode: "dev", reason },
+    });
+    return "dev";
+}

package/dist/heart/daemon/safe-mode.js

@@ -0,0 +1,161 @@
+"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.SAFE_MODE_OVERRIDE_FILENAME = void 0;
+exports.detectSafeMode = detectSafeMode;
+exports.pruneOldCrashes = pruneOldCrashes;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+exports.SAFE_MODE_OVERRIDE_FILENAME = "safe-mode-override.json";
+/** 3+ crashes within this window triggers safe mode */
+const CRASH_WINDOW_MS = 5 * 60 * 1000; // 5 minutes
+const CRASH_THRESHOLD = 3;
+/**
+ * Reads crash history from the tombstone file and determines if safe mode should be active.
+ * Returns active if 3+ crashes occurred within 5 minutes.
+ *
+ * Safe mode is bypassed when:
+ * - devMode is true
+ * - A safe-mode override file exists (written by `ouro up --force`)
+ */
+function detectSafeMode(tombstonePath, options) {
+    const inactive = { active: false, reason: "", enteredAt: "" };
+    // Dev mode: never enter safe mode
+    if (options?.devMode) {
+        return inactive;
+    }
+    // Check for override file (--force)
+    const overridePath = path.join(path.dirname(tombstonePath), exports.SAFE_MODE_OVERRIDE_FILENAME);
+    try {
+        if (fs.existsSync(overridePath)) {
+            return inactive;
+        }
+    }
+    catch {
+        // Best-effort check
+    }
+    // Read tombstone
+    let parsed;
+    try {
+        const raw = fs.readFileSync(tombstonePath, "utf-8");
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return inactive;
+    }
+    // Extract recentCrashes
+    if (!Array.isArray(parsed.recentCrashes)) {
+        return inactive;
+    }
+    const nowMs = options?.now ? options.now() : Date.now();
+    const windowStart = nowMs - CRASH_WINDOW_MS;
+    // Filter to valid string timestamps within the crash window
+    const recentInWindow = parsed.recentCrashes.filter((entry) => {
+        if (typeof entry !== "string")
+            return false;
+        const ts = new Date(entry).getTime();
+        if (isNaN(ts))
+            return false;
+        return ts >= windowStart;
+    });
+    if (recentInWindow.length < CRASH_THRESHOLD) {
+        return inactive;
+    }
+    const result = {
+        active: true,
+        reason: `crash loop detected: ${recentInWindow.length} crashes in last 5 minutes`,
+        enteredAt: new Date(nowMs).toISOString(),
+    };
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "daemon",
+        event: "daemon.safe_mode_entered",
+        message: result.reason,
+        meta: {
+            crashCount: recentInWindow.length,
+            windowMs: CRASH_WINDOW_MS,
+            tombstonePath,
+        },
+    });
+    return result;
+}
+/**
+ * Prunes crash entries older than 5 minutes from the tombstone's recentCrashes.
+ * Also removes the safe-mode override file if present.
+ * Called after successful startup (uptime > stability threshold).
+ */
+function pruneOldCrashes(tombstonePath, options) {
+    // Remove override file
+    const overridePath = path.join(path.dirname(tombstonePath), exports.SAFE_MODE_OVERRIDE_FILENAME);
+    try {
+        if (fs.existsSync(overridePath)) {
+            fs.unlinkSync(overridePath);
+        }
+    }
+    catch {
+        // Best-effort
+    }
+    // Read existing tombstone
+    let parsed;
+    try {
+        const raw = fs.readFileSync(tombstonePath, "utf-8");
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return;
+    }
+    if (!Array.isArray(parsed.recentCrashes)) {
+        return;
+    }
+    const nowMs = options?.now ? options.now() : Date.now();
+    const windowStart = nowMs - CRASH_WINDOW_MS;
+    // Keep only entries within the window
+    const pruned = parsed.recentCrashes.filter((entry) => {
+        if (typeof entry !== "string")
+            return false;
+        const ts = new Date(entry).getTime();
+        if (isNaN(ts))
+            return false;
+        return ts >= windowStart;
+    });
+    parsed.recentCrashes = pruned;
+    try {
+        fs.writeFileSync(tombstonePath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+    }
+    catch {
+        // Best-effort
+    }
+}

package/dist/heart/daemon/sense-manager.js

@@ -38,12 +38,14 @@ const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
+const bluebubbles_runtime_state_1 = require("../../senses/bluebubbles-runtime-state");
 const identity_1 = require("../identity");
 const sense_truth_1 = require("../sense-truth");
 const process_manager_1 = require("./process-manager");
 const DEFAULT_TEAMS_PORT = 3978;
 const DEFAULT_BLUEBUBBLES_PORT = 18790;
 const DEFAULT_BLUEBUBBLES_WEBHOOK_PATH = "/bluebubbles-webhook";
+const BLUEBUBBLES_RUNTIME_FRESHNESS_WINDOW_MS = 90_000;
 function defaultSenses() {
     return {
         cli: { ...identity_1.DEFAULT_AGENT_SENSES.cli },
@@ -175,12 +177,45 @@ function runtimeInfoFor(status) {
         return { runtime: "running" };
     return { runtime: "error" };
 }
+function blueBubblesRuntimeStateIsFresh(lastCheckedAt, now = Date.now()) {
+    if (!lastCheckedAt) {
+        return false;
+    }
+    const checkedAt = Date.parse(lastCheckedAt);
+    if (!Number.isFinite(checkedAt)) {
+        return false;
+    }
+    return checkedAt >= now - BLUEBUBBLES_RUNTIME_FRESHNESS_WINDOW_MS;
+}
+function readBlueBubblesRuntimeFacts(agent, bundlesRoot, snapshot) {
+    const agentRoot = path.join(bundlesRoot, `${agent}.ouro`);
+    const runtimePath = path.join(agentRoot, "state", "senses", "bluebubbles", "runtime.json");
+    if (!fs.existsSync(runtimePath)) {
+        return { runtime: snapshot?.runtime };
+    }
+    const state = (0, bluebubbles_runtime_state_1.readBlueBubblesRuntimeState)(agent, agentRoot);
+    if (!blueBubblesRuntimeStateIsFresh(state.lastCheckedAt)) {
+        return { runtime: snapshot?.runtime };
+    }
+    if (state.upstreamStatus === "error") {
+        return {
+            runtime: "error",
+            detail: state.detail,
+        };
+    }
+    if (state.upstreamStatus === "ok") {
+        return { runtime: "running" };
+    }
+    return { runtime: snapshot?.runtime };
+}
 class DaemonSenseManager {
     processManager;
     contexts;
+    bundlesRoot;
     constructor(options) {
         const bundlesRoot = options.bundlesRoot ?? path.join(os.homedir(), "AgentBundles");
         const secretsRoot = options.secretsRoot ?? path.join(os.homedir(), ".agentsecrets");
+        this.bundlesRoot = bundlesRoot;
         this.contexts = new Map(options.agents.map((agent) => {
             const senses = readAgentSenses(path.join(bundlesRoot, `${agent}.ouro`, "agent.json"));
             const facts = senseFactsFromSecrets(agent, senses, path.join(secretsRoot, agent, "secrets.json"));
@@ -216,6 +251,13 @@ class DaemonSenseManager {
     async stopAll() {
         await this.processManager.stopAll();
     }
+    /* v8 ignore start -- pid collection for orphan cleanup pidfile @preserve */
+    listManagedPids() {
+        return this.processManager.listAgentSnapshots()
+            .map((s) => s.pid)
+            .filter((pid) => pid !== null && pid !== undefined);
+    }
+    /* v8 ignore stop */
     listSenseRows() {
         const runtime = new Map();
         for (const snapshot of this.processManager.listAgentSnapshots()) {
@@ -227,6 +269,7 @@ class DaemonSenseManager {
             runtime.set(parsed.agent, current);
         }
         const rows = [...this.contexts.entries()].flatMap(([agent, context]) => {
+            const blueBubblesRuntimeFacts = readBlueBubblesRuntimeFacts(agent, this.bundlesRoot, runtime.get(agent)?.bluebubbles);
             const runtimeInfo = {
                 cli: { configured: true },
                 teams: {
@@ -235,7 +278,7 @@ class DaemonSenseManager {
                 },
                 bluebubbles: {
                     configured: context.facts.bluebubbles.configured,
-                    ...(runtime.get(agent)?.bluebubbles ?? {}),
+                    ...blueBubblesRuntimeFacts,
                 },
             };
             const inventory = (0, sense_truth_1.getSenseInventory)({ senses: context.senses }, runtimeInfo);
@@ -245,7 +288,12 @@ class DaemonSenseManager {
                 label: entry.label,
                 enabled: entry.enabled,
                 status: entry.status,
-                detail: entry.enabled ? context.facts[entry.sense].detail : "not enabled in agent.json",
+                detail: entry.enabled
+                    ? entry.sense === "bluebubbles"
+                        ? blueBubblesRuntimeFacts.detail
+                            ?? context.facts[entry.sense].detail
+                        : context.facts[entry.sense].detail
+                    : "not enabled in agent.json",
             }));
         });
         (0, runtime_1.emitNervesEvent)({

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;
+}