@ouro.bot/cli 0.1.0-alpha.142 → 0.1.0-alpha.145

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

@@ -307,7 +307,11 @@ function usage() {
     ].join("\n");
 }
 function formatVersionOutput() {
-    return (0, runtime_metadata_1.getRuntimeMetadata)().version;
+    const version = (0, runtime_metadata_1.getRuntimeMetadata)().version;
+    const mode = (0, runtime_mode_1.detectRuntimeMode)((0, identity_1.getRepoRoot)());
+    /* v8 ignore start — cosmetic display toggle; dev mode always true in test env */
+    return mode === "dev" ? `${version} (dev)` : version;
+    /* v8 ignore stop */
 }
 function buildStoppedStatusPayload(socketPath) {
     const metadata = (0, runtime_metadata_1.getRuntimeMetadata)();
@@ -914,6 +918,27 @@ function parseMcpServeCommand(args) {
         throw new Error("mcp-serve requires --agent <name>");
     return { kind: "mcp-serve", agent, ...(friendId ? { friendId } : {}), ...(socketOverride ? { socketOverride } : {}) };
 }
+function parseSetupCommand(args) {
+    let tool;
+    let agent;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--tool" && args[i + 1]) {
+            tool = args[++i];
+            continue;
+        }
+        if (args[i] === "--agent" && args[i + 1]) {
+            agent = args[++i];
+            continue;
+        }
+    }
+    if (!tool)
+        throw new Error("setup requires --tool (claude-code | codex)");
+    if (tool !== "claude-code" && tool !== "codex")
+        throw new Error(`Unknown tool: ${tool}. Supported: claude-code, codex`);
+    if (!agent)
+        throw new Error("setup requires --agent <name>");
+    return { kind: "setup", tool, agent };
+}
 function parseOuroCommand(args) {
     const [head, second] = args;
     if (!head)
@@ -921,6 +946,12 @@ function parseOuroCommand(args) {
     if (head === "--agent" && second) {
         return parseOuroCommand(args.slice(2));
     }
+    if (head === "hook") {
+        const event = second;
+        if (!event)
+            throw new Error("hook requires an event name (session-start, stop, post-tool-use)");
+        return { kind: "hook", event };
+    }
     if (head === "up")
         return { kind: "daemon.up" };
     if (head === "dev") {
@@ -1005,6 +1036,8 @@ function parseOuroCommand(args) {
         return parseLinkCommand(args.slice(1));
     if (head === "mcp-serve")
         return parseMcpServeCommand(args.slice(1));
+    if (head === "setup")
+        return parseSetupCommand(args.slice(1));
     throw new Error(`Unknown command '${args.join(" ")}'.\n${usage()}`);
 }
 function defaultStartDaemonProcess(socketPath) {
@@ -1791,12 +1824,53 @@ function executeReminderCommand(command, taskMod) {
     }
 }
 /* v8 ignore start -- repo resolution for ouro dev: repoPath branch tested via daemon-cli-dev; clone requires real git/npm @preserve */
+function getDevConfigPath() {
+    return path.join((0, ouro_version_manager_1.getOuroCliHome)(), "dev-config.json");
+}
+function readPersistedDevPath() {
+    try {
+        const data = JSON.parse(fs.readFileSync(getDevConfigPath(), "utf-8"));
+        return typeof data.repoPath === "string" ? data.repoPath : null;
+    }
+    catch {
+        return null;
+    }
+}
+function persistDevPath(repoPath) {
+    try {
+        fs.mkdirSync(path.dirname(getDevConfigPath()), { recursive: true });
+        fs.writeFileSync(getDevConfigPath(), JSON.stringify({ repoPath }, null, 2));
+    }
+    catch { /* best effort */ }
+}
 function resolveDevRepoCwd(command, checkExists, deps) {
-    if (command.repoPath)
-        return path.resolve(command.repoPath);
+    // 1. Explicit --repo-path: use it and persist for next time
+    if (command.repoPath) {
+        const resolved = path.resolve(command.repoPath);
+        persistDevPath(resolved);
+        return resolved;
+    }
+    // 2. Clone request
     if (command.clone)
         return resolveClonePath(command, checkExists, deps);
-    return deps.getRepoCwd ? deps.getRepoCwd() : (0, identity_1.getRepoRoot)();
+    // 3. If test/internal deps provide getRepoCwd, use it directly
+    if (deps.getRepoCwd) {
+        return deps.getRepoCwd();
+    }
+    // 4. Check CWD — if we're inside a harness repo, use it
+    const cwd = process.cwd();
+    if (checkExists(path.join(cwd, ".git")) && checkExists(path.join(cwd, "src", "heart", "daemon"))) {
+        persistDevPath(cwd);
+        return cwd;
+    }
+    // 5. Read persisted path from last --repo-path
+    const persisted = readPersistedDevPath();
+    if (persisted && checkExists(path.join(persisted, ".git"))) {
+        deps.writeStdout(`using remembered dev path: ${persisted}`);
+        return persisted;
+    }
+    // 6. Fall back to getRepoRoot (works when running from installed binary → resolves to npm package)
+    return (0, identity_1.getRepoRoot)();
 }
 /* v8 ignore stop */
 /* v8 ignore start -- clone/build: requires real git clone + npm install on disk @preserve */
@@ -2075,6 +2149,19 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
             }
             /* v8 ignore stop */
         }
+        // Auto-build: always rebuild in dev mode so dist/ matches source
+        /* v8 ignore start -- dev auto-build: execSync in repo cwd, tested manually @preserve */
+        deps.writeStdout(`building from ${repoCwd}...`);
+        try {
+            (0, child_process_1.execSync)("npm run build", { cwd: repoCwd, stdio: "inherit" });
+            entryPath = path.join(repoCwd, "dist", "heart", "daemon", "daemon-entry.js");
+        }
+        catch {
+            const message = `build failed in ${repoCwd}. fix compilation errors and retry.`;
+            deps.writeStdout(message);
+            return message;
+        }
+        /* v8 ignore stop */
         /* v8 ignore start -- defensive: ensureDaemonBootPersistence always injected in tests @preserve */
         if (deps.ensureDaemonBootPersistence) {
             try {
@@ -2092,6 +2179,23 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
             }
             /* v8 ignore stop */
         }
+        // Disable launchd KeepAlive before killing — prevents the installed daemon from respawning
+        /* v8 ignore start -- dev launchd disable: requires real launchctl + plist on disk @preserve */
+        const launchdDevDeps = {
+            exec: (cmd) => { (0, child_process_1.execSync)(cmd); },
+            existsFile: (p) => fs.existsSync(p),
+            removeFile: (p) => { try {
+                fs.unlinkSync(p);
+            }
+            catch { /* best effort */ } },
+            homeDir: os.homedir(),
+            userUid: process.getuid?.() ?? 0,
+        };
+        if ((0, launchd_1.isDaemonInstalled)(launchdDevDeps)) {
+            (0, launchd_1.uninstallLaunchAgent)(launchdDevDeps);
+            deps.writeStdout("disabled launchd auto-restart for dev mode");
+        }
+        /* v8 ignore stop */
         // Always force-restart in dev mode — you rebuilt, you want this code running
         /* v8 ignore start -- dev force-restart: socket alive/stop/spawn tested via integration; tests inject mocks @preserve */
         const alive = await deps.checkSocketAlive(deps.socketPath);
@@ -2113,7 +2217,7 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
         /* v8 ignore stop */
         const started = await startDevDaemon(deps.socketPath);
         /* v8 ignore next -- defensive: pid is null only when spawn fails silently @preserve */
-        const message = `daemon running in dev mode from ${repoCwd} (pid ${started.pid ?? "unknown"})`;
+        const message = `daemon running in dev mode from ${repoCwd} (pid ${started.pid ?? "unknown"})\nrun 'ouro up' to return to production mode`;
         deps.writeStdout(message);
         return message;
     }
@@ -2198,6 +2302,122 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
         deps.tailLogs();
         return "";
     }
+    // ── hook: handle Claude Code lifecycle hooks ──
+    /* v8 ignore start -- hook handler: reads real stdin, sends to real daemon @preserve */
+    if (command.kind === "hook") {
+        let stdinData = "";
+        try {
+            stdinData = require("fs").readFileSync(0, "utf-8");
+        }
+        catch { /* no stdin */ }
+        let event = {};
+        try {
+            event = JSON.parse(stdinData);
+        }
+        catch { /* malformed */ }
+        const eventType = command.event;
+        const sessionId = event.session_id ?? "unknown";
+        const cwd = event.cwd ?? "";
+        // Build notification content based on event type
+        let content;
+        if (eventType === "session-start") {
+            const model = event.model ?? "";
+            const source = event.source ?? "";
+            content = `[Claude Code session started: ${sessionId}, cwd: ${cwd}${model ? `, model: ${model}` : ""}${source ? `, source: ${source}` : ""}]`;
+        }
+        else if (eventType === "stop") {
+            const lastMsg = event.last_assistant_message ?? "";
+            content = `[Claude Code session ended: ${sessionId}${lastMsg ? `, last: ${lastMsg.slice(0, 200)}` : ""}]`;
+        }
+        else if (eventType === "post-tool-use") {
+            const toolName = event.tool_name ?? "";
+            content = `[Claude Code used ${toolName} in session ${sessionId}]`;
+        }
+        else {
+            content = `[Claude Code hook: ${eventType} in session ${sessionId}]`;
+        }
+        // Send to daemon (best effort — daemon may not be running)
+        try {
+            const agents = require("fs").readdirSync(path.join(os.homedir(), "AgentBundles"))
+                .filter((f) => f.endsWith(".ouro"))
+                .map((f) => f.replace(".ouro", ""));
+            for (const agent of agents) {
+                await deps.sendCommand(deps.socketPath, { kind: "message.send", from: `claude-code:${sessionId}`, to: agent, content });
+            }
+            await deps.sendCommand(deps.socketPath, { kind: "inner.wake", agent: agents[0] }).catch(() => { });
+        }
+        catch { /* daemon not running — silent */ }
+        // Output for Claude Code hook system
+        deps.writeStdout(JSON.stringify({ continue: true }));
+        return JSON.stringify({ continue: true });
+    }
+    /* v8 ignore stop */
+    // ── setup: configure dev tool integration ──
+    if (command.kind === "setup") {
+        const { tool, agent: setupAgent } = command;
+        const sourceRoot = (0, identity_1.getRepoRoot)();
+        const runtimeMode = (0, runtime_mode_1.detectRuntimeMode)(sourceRoot);
+        const mcpServeCommand = runtimeMode === "dev"
+            ? `node ${path.join(sourceRoot, "dist", "heart", "daemon", "ouro-bot-entry.js")} mcp-serve --agent ${setupAgent}`
+            : `ouro mcp-serve --agent ${setupAgent}`;
+        if (tool === "claude-code") {
+            // 1. Register MCP server with Claude Code
+            const mcpAddCmd = `claude mcp add ouro-${setupAgent} -s user -- ${mcpServeCommand}`;
+            (0, child_process_1.execSync)(mcpAddCmd, { stdio: "pipe" });
+            // 2. Write hooks config to ~/.claude/settings.json
+            const settingsPath = path.join(os.homedir(), ".claude", "settings.json");
+            let settings = {};
+            if (fs.existsSync(settingsPath)) {
+                try {
+                    settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+                }
+                catch { /* start fresh */ }
+            }
+            // Use `ouro hook <event>` — resolves the right code based on dev vs installed mode.
+            // Bare `ouro` works because ouro is on PATH via ~/.ouro-cli/bin/.
+            settings.hooks = {
+                ...(settings.hooks ?? {}),
+                SessionStart: [{ hooks: [{ type: "command", command: "ouro hook session-start", timeout: 5 }] }],
+                Stop: [{ hooks: [{ type: "command", command: "ouro hook stop", timeout: 5 }] }],
+                PostToolUse: [{ matcher: "Bash|Edit|Write", hooks: [{ type: "command", command: "ouro hook post-tool-use", timeout: 5 }] }],
+            };
+            fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+            fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.setup_complete",
+                message: "dev tool setup complete",
+                meta: { tool, agent: setupAgent, runtimeMode },
+            });
+            // 3. Write conversation formatting instructions to ~/.claude/CLAUDE.md
+            const claudeMdPath = path.join(os.homedir(), ".claude", "CLAUDE.md");
+            const agentInstructions = `\n## Agent conversations (ouro)\nWhen using MCP \`send_message\` to talk to an ouro agent, format the exchange clearly:\n- Before the tool call, briefly say what you're asking/telling the agent\n- After the response, quote the agent's reply in a blockquote, then add your reaction\n- Example: **Me → Agent:** "question" / > **Agent:** "response" / Your synthesis here\n`;
+            let existingClaudeMd = "";
+            if (fs.existsSync(claudeMdPath)) {
+                existingClaudeMd = fs.readFileSync(claudeMdPath, "utf-8");
+            }
+            if (!existingClaudeMd.includes("Agent conversations (ouro)")) {
+                fs.writeFileSync(claudeMdPath, existingClaudeMd + agentInstructions);
+            }
+            const message = `setup complete: claude-code + ${setupAgent}\n  MCP server registered\n  hooks configured\n  conversation formatting instructions added`;
+            deps.writeStdout(message);
+            return message;
+        }
+        else {
+            // tool === "codex" (parseSetupCommand validates tool, so this is the only remaining option)
+            const mcpAddCmd = `codex mcp add ouro-${setupAgent} -- ${mcpServeCommand}`;
+            (0, child_process_1.execSync)(mcpAddCmd, { stdio: "pipe" });
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.setup_complete",
+                message: "dev tool setup complete",
+                meta: { tool, agent: setupAgent, runtimeMode },
+            });
+            const message = `setup complete: codex + ${setupAgent}\n  MCP server registered`;
+            deps.writeStdout(message);
+            return message;
+        }
+    }
     /* v8 ignore start — mcp-serve block binds to process.stdin/stdout; tested via mcp-server unit tests */
     // ── mcp-serve: start MCP server in-process on stdin/stdout ──
     if (command.kind === "mcp-serve") {

package/dist/heart/daemon/heartbeat-timer.js

@@ -57,8 +57,9 @@ class HeartbeatTimer {
         const nowMs = this.now();
         let delay;
         if (lastCompletedAt === null) {
-            // Never run before — fire immediately
-            delay = 0;
+            // Never run before — fire once after a full cadence (not immediately, to avoid spin loop
+            // when the agent has no inner dialog state to write lastCompletedAt)
+            delay = cadenceMs;
         }
         else {
             const elapsed = nowMs - lastCompletedAt;

package/dist/heart/daemon/mcp-server.js

@@ -38,6 +38,9 @@ exports.getToolSchemas = getToolSchemas;
 const socket_client_1 = require("./socket-client");
 const agentService = __importStar(require("./agent-service"));
 const runtime_1 = require("../../nerves/runtime");
+const shared_turn_1 = require("../../senses/shared-turn");
+const session_id_resolver_1 = require("./session-id-resolver");
+const pending_1 = require("../../mind/pending");
 /**
  * Maps MCP tool names to daemon command kinds.
  */
@@ -66,6 +69,8 @@ function createMcpServer(options) {
     let buffer = "";
     let running = false;
     let useContentLengthFraming = true; // default to Content-Length, auto-detect from first message
+    // Resolve session ID once per MCP server instance for conversation continuity
+    const sessionId = (0, session_id_resolver_1.resolveSessionId)();
     function writeResponse(response) {
         const body = JSON.stringify(response);
         if (useContentLengthFraming) {
@@ -238,6 +243,109 @@ function createMcpServer(options) {
         const toolName = params.name;
         const toolArgs = (params.arguments ?? {});
         /* v8 ignore stop */
+        // ── Conversation tools: send_message, check_response ──
+        if (toolName === "send_message") {
+            /* v8 ignore start — ?? fallback defensive; MCP clients always send message */
+            const message = toolArgs.message ?? "";
+            /* v8 ignore stop */
+            try {
+                const result = await (0, shared_turn_1.runSenseTurn)({
+                    agentName: agent,
+                    channel: "mcp",
+                    sessionKey: sessionId,
+                    friendId,
+                    userMessage: message,
+                });
+                writeResponse({
+                    jsonrpc: "2.0",
+                    id: request.id,
+                    result: {
+                        content: [{ type: "text", text: result.response }],
+                        isError: false,
+                    },
+                });
+            }
+            catch (error) {
+                /* v8 ignore start — instanceof guard defensive; thrown errors are always Error */
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                /* v8 ignore stop */
+                writeResponse({
+                    jsonrpc: "2.0",
+                    id: request.id,
+                    result: {
+                        content: [{ type: "text", text: `Error: ${errorMessage}` }],
+                        isError: true,
+                    },
+                });
+            }
+            return;
+        }
+        if (toolName === "check_response") {
+            const pendingDir = (0, pending_1.getPendingDir)(agent, friendId, "mcp", sessionId);
+            const pending = (0, pending_1.drainPending)(pendingDir);
+            if (pending.length === 0) {
+                writeResponse({
+                    jsonrpc: "2.0",
+                    id: request.id,
+                    result: {
+                        content: [{ type: "text", text: "no pending messages" }],
+                        isError: false,
+                    },
+                });
+            }
+            else {
+                const text = pending.map((m) => m.content).join("\n\n---\n\n");
+                writeResponse({
+                    jsonrpc: "2.0",
+                    id: request.id,
+                    result: {
+                        content: [{ type: "text", text }],
+                        isError: false,
+                    },
+                });
+            }
+            return;
+        }
+        // ── delegate: full conversation turn via runSenseTurn ──
+        if (toolName === "delegate") {
+            /* v8 ignore start — ?? fallback defensive; MCP clients always send task */
+            const task = toolArgs.task ?? "";
+            /* v8 ignore stop */
+            const context = toolArgs.context;
+            const delegateMessage = context ? `[delegate] ${task}\n\ncontext: ${context}` : `[delegate] ${task}`;
+            try {
+                const result = await (0, shared_turn_1.runSenseTurn)({
+                    agentName: agent,
+                    channel: "mcp",
+                    sessionKey: sessionId,
+                    friendId,
+                    userMessage: delegateMessage,
+                });
+                writeResponse({
+                    jsonrpc: "2.0",
+                    id: request.id,
+                    result: {
+                        content: [{ type: "text", text: result.response }],
+                        isError: false,
+                    },
+                });
+            }
+            catch (error) {
+                /* v8 ignore start — instanceof guard defensive; thrown errors are always Error */
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                /* v8 ignore stop */
+                writeResponse({
+                    jsonrpc: "2.0",
+                    id: request.id,
+                    result: {
+                        content: [{ type: "text", text: `Error: ${errorMessage}` }],
+                        isError: true,
+                    },
+                });
+            }
+            return;
+        }
+        // ── Legacy daemon/service tools ──
         const commandKind = TOOL_TO_COMMAND[toolName];
         if (!commandKind) {
             writeResponse({
@@ -321,7 +429,7 @@ function createMcpServer(options) {
     };
 }
 /**
- * Returns the list of MCP tool schemas for all 13 agent tools.
+ * Returns the list of MCP tool schemas for all 15 agent tools.
  * Each schema follows JSON Schema for inputSchema as required by MCP.
  */
 function getToolSchemas() {
@@ -459,6 +567,25 @@ function getToolSchemas() {
                 required: ["summary"],
             },
         },
+        {
+            name: "send_message",
+            description: "Send a message to the agent and get a synchronous response. This runs a full agent turn — the agent can use tools, think, and respond. For multi-turn conversations, call repeatedly — the agent remembers prior messages in this session.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    message: { type: "string", description: "The message to send to the agent" },
+                },
+                required: ["message"],
+            },
+        },
+        {
+            name: "check_response",
+            description: "Check for pending messages from the agent. Use this after send_message returns a ponder deferral, or to pick up proactive messages the agent has surfaced to you.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+            },
+        },
     ];
 }
 // MCP server v0.1.0-alpha.140

package/dist/heart/daemon/ouro-path-installer.js

@@ -39,6 +39,16 @@ const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
 const WRAPPER_SCRIPT = `#!/bin/sh
+# Check for dev mode — if dev-config.json exists, dispatch to the dev repo
+DEV_CONFIG="$HOME/.ouro-cli/dev-config.json"
+if [ -f "$DEV_CONFIG" ]; then
+  DEV_REPO=$(node -e "try{console.log(JSON.parse(require('fs').readFileSync('$DEV_CONFIG','utf-8')).repoPath)}catch{}" 2>/dev/null)
+  DEV_ENTRY="$DEV_REPO/dist/heart/daemon/ouro-entry.js"
+  if [ -n "$DEV_REPO" ] && [ -e "$DEV_ENTRY" ]; then
+    exec node "$DEV_ENTRY" "$@"
+  fi
+fi
+# Fall back to installed version
 ENTRY="$HOME/.ouro-cli/CurrentVersion/node_modules/@ouro.bot/cli/dist/heart/daemon/ouro-entry.js"
 if [ ! -e "$ENTRY" ]; then
   echo "ouro not installed. Run: npx ouro.bot" >&2

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

@@ -125,6 +125,17 @@ class DaemonProcessManager {
             message: "daemon started managed agent process",
             meta: { agent, pid: child.pid ?? null, cwd: runCwd },
         });
+        /* v8 ignore start — child process error handler; requires real spawn to trigger */
+        child.on("error", (err) => {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.agent_process_error",
+                message: "managed agent process emitted error",
+                meta: { agent, error: err.message },
+            });
+        });
+        /* v8 ignore stop */
         child.once("exit", (code, signal) => {
             this.onExit(state, code, signal);
         });

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/target-resolution.js

@@ -34,6 +34,10 @@ function activityPriority(source) {
     return source === "friend-facing" ? 0 : 1;
 }
 function describeDelivery(candidate) {
+    if (candidate.channel === "mcp") {
+        // MCP can't push (no proactive API), but can queue — dev tool picks up via check_response
+        return { mode: "queue_only", reason: "MCP session — message queued for dev tool to pick up via check_response" };
+    }
     if (candidate.channel !== "bluebubbles" && candidate.channel !== "teams") {
         return { mode: "blocked", reason: "this channel does not support proactive outward delivery yet" };
     }

package/dist/mind/friends/channel.js

@@ -43,6 +43,15 @@ const CHANNEL_CAPABILITIES = {
         supportsRichCards: false,
         maxMessageLength: Infinity,
     },
+    mcp: {
+        channel: "mcp",
+        senseType: "local",
+        availableIntegrations: [],
+        supportsMarkdown: true,
+        supportsStreaming: false,
+        supportsRichCards: false,
+        maxMessageLength: Infinity,
+    },
 };
 const DEFAULT_CAPABILITIES = {
     channel: "cli",