@ouro.bot/cli 0.1.0-alpha.139 → 0.1.0-alpha.140

package/changelog.json

@@ -1,6 +1,18 @@
 {
   "_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.140",
+      "changes": [
+        "MCP server: agents can serve as MCP peers for dev tools (Claude Code, Codex) via ouro mcp-serve --agent <name>.",
+        "13 MCP tools: ask, status, catchup, delegate, get_context, search_memory, get_task, check_scope, request_decision, check_guidance, report_progress, report_blocker, report_complete.",
+        "Standalone mode: MCP shim calls agent-service directly, no daemon dependency for read-only ops.",
+        "Auto-detect framing: supports both Content-Length (Claude Code) and newline-delimited JSON (Codex).",
+        "Harness-level skills: 3-tier fallback (agent > protocol > harness), configure-dev-tools skill ships with npm package.",
+        "Codex spawner refactor: --ephemeral, --json, -c MCP injection, JSONL event parsing replaces magic strings.",
+        "Prompt awareness: body map lists ouro mcp-serve, runtime info mentions MCP serve capability."
+      ]
+    },
     {
       "version": "0.1.0-alpha.139",
       "changes": [

package/dist/heart/daemon/agent-service.js

@@ -0,0 +1,467 @@
+"use strict";
+/**
+ * Agent service layer — handles MCP-facing daemon commands.
+ * Each handler receives { agent, friendId, ...params } and returns DaemonResponse.
+ * For MVP, these read from agent state on the filesystem.
+ * Full inference support can come later.
+ */
+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.handleAgentStatus = handleAgentStatus;
+exports.handleAgentAsk = handleAgentAsk;
+exports.handleAgentCatchup = handleAgentCatchup;
+exports.handleAgentDelegate = handleAgentDelegate;
+exports.handleAgentGetContext = handleAgentGetContext;
+exports.handleAgentSearchMemory = handleAgentSearchMemory;
+exports.handleAgentGetTask = handleAgentGetTask;
+exports.handleAgentCheckScope = handleAgentCheckScope;
+exports.handleAgentRequestDecision = handleAgentRequestDecision;
+exports.handleAgentCheckGuidance = handleAgentCheckGuidance;
+exports.handleAgentReportProgress = handleAgentReportProgress;
+exports.handleAgentReportBlocker = handleAgentReportBlocker;
+exports.handleAgentReportComplete = handleAgentReportComplete;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const identity_1 = require("../identity");
+const runtime_1 = require("../../nerves/runtime");
+function readAgentFile(agent, ...segments) {
+    const filePath = path.join((0, identity_1.getAgentRoot)(agent), ...segments);
+    if (!fs.existsSync(filePath))
+        return null;
+    return fs.readFileSync(filePath, "utf-8");
+}
+/** Read agent memory from multiple possible locations. */
+function readAgentMemory(agent) {
+    // Try memory/MEMORY.md first, then psyche/memory/facts.jsonl
+    return readAgentFile(agent, "memory", "MEMORY.md")
+        ?? readAgentFile(agent, "psyche", "memory", "facts.jsonl");
+}
+function listStateFiles(agent, ...segments) {
+    const dirPath = path.join((0, identity_1.getAgentStateRoot)(agent), ...segments);
+    if (!fs.existsSync(dirPath))
+        return [];
+    return fs.readdirSync(dirPath).filter((f) => f.endsWith(".json") || f.endsWith(".jsonl") || f.endsWith(".md"));
+}
+async function handleAgentStatus(params) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_start",
+        message: "handling agent.status",
+        meta: { agent: params.agent, friendId: params.friendId },
+    });
+    const sessionFiles = listStateFiles(params.agent, "sessions");
+    const memoryContent = readAgentMemory(params.agent);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_end",
+        message: "completed agent.status",
+        meta: { agent: params.agent },
+    });
+    return {
+        ok: true,
+        message: `Agent ${params.agent} status`,
+        data: {
+            agent: params.agent,
+            status: "active",
+            sessionCount: sessionFiles.length,
+            hasMemory: memoryContent !== null,
+        },
+    };
+}
+async function handleAgentAsk(params) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_start",
+        message: "handling agent.ask",
+        meta: { agent: params.agent, friendId: params.friendId },
+    });
+    const question = params.question;
+    if (!question) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.agent_service_error",
+            message: "agent.ask missing question parameter",
+            meta: { agent: params.agent },
+        });
+        return { ok: false, error: "Missing required parameter: question" };
+    }
+    // MVP: return memory + recent session context without running inference
+    const memoryContent = readAgentMemory(params.agent);
+    const context = memoryContent
+        ? `Based on agent memory:\n${memoryContent.slice(0, 2000)}`
+        : `Agent ${params.agent} has no memory file. Question was: ${question}`;
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_end",
+        message: "completed agent.ask",
+        meta: { agent: params.agent },
+    });
+    return { ok: true, message: context };
+}
+async function handleAgentCatchup(params) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_start",
+        message: "handling agent.catchup",
+        meta: { agent: params.agent, friendId: params.friendId },
+    });
+    const sessionFiles = listStateFiles(params.agent, "sessions");
+    const recentSessions = sessionFiles.slice(-5);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_end",
+        message: "completed agent.catchup",
+        meta: { agent: params.agent },
+    });
+    return {
+        ok: true,
+        message: recentSessions.length > 0
+            ? `Recent activity: ${recentSessions.length} recent sessions found`
+            : `No recent activity for ${params.agent}`,
+        data: { recentSessions },
+    };
+}
+async function handleAgentDelegate(params) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_start",
+        message: "handling agent.delegate",
+        meta: { agent: params.agent, friendId: params.friendId },
+    });
+    const task = params.task;
+    if (!task) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.agent_service_error",
+            message: "agent.delegate missing task parameter",
+            meta: { agent: params.agent },
+        });
+        return { ok: false, error: "Missing required parameter: task" };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_end",
+        message: "completed agent.delegate",
+        meta: { agent: params.agent },
+    });
+    return {
+        ok: true,
+        message: `Task queued for delegate to ${params.agent}: ${task}`,
+        data: { task, context: params.context ?? null, queuedAt: new Date().toISOString() },
+    };
+}
+async function handleAgentGetContext(params) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_start",
+        message: "handling agent.getContext",
+        meta: { agent: params.agent, friendId: params.friendId },
+    });
+    const memoryContent = readAgentMemory(params.agent);
+    const taskFiles = listStateFiles(params.agent, "tasks");
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_end",
+        message: "completed agent.getContext",
+        meta: { agent: params.agent },
+    });
+    return {
+        ok: true,
+        data: {
+            agent: params.agent,
+            hasMemory: memoryContent !== null,
+            memorySummary: memoryContent ? memoryContent.slice(0, 500) : null,
+            taskCount: taskFiles.length,
+        },
+    };
+}
+async function handleAgentSearchMemory(params) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_start",
+        message: "handling agent.searchMemory",
+        meta: { agent: params.agent, friendId: params.friendId },
+    });
+    const query = params.query;
+    if (!query) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.agent_service_error",
+            message: "agent.searchMemory missing query parameter",
+            meta: { agent: params.agent },
+        });
+        return { ok: false, error: "Missing required parameter: query" };
+    }
+    // MVP: simple substring search in memory file
+    const memoryContent = readAgentMemory(params.agent);
+    const matches = [];
+    if (memoryContent) {
+        const lines = memoryContent.split("\n");
+        const queryLower = query.toLowerCase();
+        for (const line of lines) {
+            if (line.toLowerCase().includes(queryLower)) {
+                matches.push(line.trim());
+            }
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_end",
+        message: "completed agent.searchMemory",
+        meta: { agent: params.agent, matchCount: matches.length },
+    });
+    return {
+        ok: true,
+        message: matches.length > 0 ? `Found ${matches.length} matches` : "No matches found",
+        data: { query, matches: matches.slice(0, 20) },
+    };
+}
+async function handleAgentGetTask(params) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_start",
+        message: "handling agent.getTask",
+        meta: { agent: params.agent, friendId: params.friendId },
+    });
+    const taskFiles = listStateFiles(params.agent, "tasks");
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_end",
+        message: "completed agent.getTask",
+        meta: { agent: params.agent },
+    });
+    return {
+        ok: true,
+        message: taskFiles.length > 0
+            ? `Current tasks: ${taskFiles.join(", ")}`
+            : `No active tasks for ${params.agent}`,
+        data: { tasks: taskFiles },
+    };
+}
+async function handleAgentCheckScope(params) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_start",
+        message: "handling agent.checkScope",
+        meta: { agent: params.agent, friendId: params.friendId },
+    });
+    const item = params.item;
+    if (!item) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.agent_service_error",
+            message: "agent.checkScope missing item parameter",
+            meta: { agent: params.agent },
+        });
+        return { ok: false, error: "Missing required parameter: item" };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_end",
+        message: "completed agent.checkScope",
+        meta: { agent: params.agent },
+    });
+    return {
+        ok: true,
+        message: `Scope check for: ${item}`,
+        data: { item, inScope: true, reason: "MVP: scope check requires inference — defaulting to in-scope" },
+    };
+}
+async function handleAgentRequestDecision(params) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_start",
+        message: "handling agent.requestDecision",
+        meta: { agent: params.agent, friendId: params.friendId },
+    });
+    const topic = params.topic;
+    if (!topic) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.agent_service_error",
+            message: "agent.requestDecision missing topic parameter",
+            meta: { agent: params.agent },
+        });
+        return { ok: false, error: "Missing required parameter: topic" };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_end",
+        message: "completed agent.requestDecision",
+        meta: { agent: params.agent },
+    });
+    return {
+        ok: true,
+        message: `Decision request queued: ${topic}`,
+        data: {
+            topic,
+            options: params.options ?? null,
+            status: "pending",
+            note: "MVP: decision requires inference — queued for agent review",
+        },
+    };
+}
+async function handleAgentCheckGuidance(params) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_start",
+        message: "handling agent.checkGuidance",
+        meta: { agent: params.agent, friendId: params.friendId },
+    });
+    const topic = params.topic;
+    if (!topic) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.agent_service_error",
+            message: "agent.checkGuidance missing topic parameter",
+            meta: { agent: params.agent },
+        });
+        return { ok: false, error: "Missing required parameter: topic" };
+    }
+    // MVP: check memory for relevant guidance
+    const memoryContent = readAgentMemory(params.agent);
+    let guidance = `No specific guidance found for: ${topic}`;
+    if (memoryContent) {
+        const lines = memoryContent.split("\n");
+        const topicLower = topic.toLowerCase();
+        const relevant = lines.filter((line) => line.toLowerCase().includes(topicLower));
+        if (relevant.length > 0) {
+            guidance = `Relevant guidance:\n${relevant.slice(0, 10).join("\n")}`;
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_end",
+        message: "completed agent.checkGuidance",
+        meta: { agent: params.agent },
+    });
+    return { ok: true, message: guidance };
+}
+async function handleAgentReportProgress(params) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_start",
+        message: "handling agent.reportProgress",
+        meta: { agent: params.agent, friendId: params.friendId },
+    });
+    const summary = params.summary;
+    if (!summary) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.agent_service_error",
+            message: "agent.reportProgress missing summary parameter",
+            meta: { agent: params.agent },
+        });
+        return { ok: false, error: "Missing required parameter: summary" };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_end",
+        message: "completed agent.reportProgress",
+        meta: { agent: params.agent },
+    });
+    return {
+        ok: true,
+        message: `Progress noted: ${summary}`,
+        data: { summary, receivedAt: new Date().toISOString() },
+    };
+}
+async function handleAgentReportBlocker(params) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_start",
+        message: "handling agent.reportBlocker",
+        meta: { agent: params.agent, friendId: params.friendId },
+    });
+    const blocker = params.blocker;
+    if (!blocker) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.agent_service_error",
+            message: "agent.reportBlocker missing blocker parameter",
+            meta: { agent: params.agent },
+        });
+        return { ok: false, error: "Missing required parameter: blocker" };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_end",
+        message: "completed agent.reportBlocker",
+        meta: { agent: params.agent },
+    });
+    return {
+        ok: true,
+        message: `Blocker reported: ${blocker}`,
+        data: { blocker, receivedAt: new Date().toISOString() },
+    };
+}
+async function handleAgentReportComplete(params) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_start",
+        message: "handling agent.reportComplete",
+        meta: { agent: params.agent, friendId: params.friendId },
+    });
+    const summary = params.summary;
+    if (!summary) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.agent_service_error",
+            message: "agent.reportComplete missing summary parameter",
+            meta: { agent: params.agent },
+        });
+        return { ok: false, error: "Missing required parameter: summary" };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_end",
+        message: "completed agent.reportComplete",
+        meta: { agent: params.agent },
+    });
+    return {
+        ok: true,
+        message: `Completion reported: ${summary}`,
+        data: { summary, receivedAt: new Date().toISOString() },
+    };
+}

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

@@ -891,6 +891,28 @@ function parseMcpCommand(args) {
     }
     throw new Error(`Usage\n${usage()}`);
 }
+function parseMcpServeCommand(args) {
+    let agent;
+    let friendId;
+    let socketOverride;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--agent" && args[i + 1]) {
+            agent = args[++i];
+            continue;
+        }
+        if (args[i] === "--friend" && args[i + 1]) {
+            friendId = args[++i];
+            continue;
+        }
+        if (args[i] === "--socket" && args[i + 1]) {
+            socketOverride = args[++i];
+            continue;
+        }
+    }
+    if (!agent)
+        throw new Error("mcp-serve requires --agent <name>");
+    return { kind: "mcp-serve", agent, ...(friendId ? { friendId } : {}), ...(socketOverride ? { socketOverride } : {}) };
+}
 function parseOuroCommand(args) {
     const [head, second] = args;
     if (!head)
@@ -976,6 +998,8 @@ function parseOuroCommand(args) {
         return parsePokeCommand(args.slice(1));
     if (head === "link")
         return parseLinkCommand(args.slice(1));
+    if (head === "mcp-serve")
+        return parseMcpServeCommand(args.slice(1));
     throw new Error(`Unknown command '${args.join(" ")}'.\n${usage()}`);
 }
 function defaultStartDaemonProcess(socketPath) {
@@ -2169,6 +2193,36 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
         deps.tailLogs();
         return "";
     }
+    /* 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") {
+        const { createMcpServer } = await Promise.resolve().then(() => __importStar(require("./mcp-server")));
+        const friendId = command.friendId ?? `local-${os.userInfo().username}`;
+        const mcpSocketPath = command.socketOverride ?? deps.socketPath;
+        const server = createMcpServer({
+            agent: command.agent,
+            friendId,
+            socketPath: mcpSocketPath,
+            stdin: process.stdin,
+            stdout: process.stdout,
+        });
+        server.start();
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.mcp_serve_started",
+            message: "MCP server started via CLI",
+            meta: { agent: command.agent, friendId },
+        });
+        // Keep process alive until stdin closes
+        await new Promise((resolve) => {
+            process.stdin.on("end", () => {
+                server.stop();
+                resolve();
+            });
+        });
+        return "";
+    }
+    /* v8 ignore stop */
     // ── mcp subcommands (routed through daemon socket) ──
     if (command.kind === "mcp.list" || command.kind === "mcp.call") {
         const daemonCommand = toDaemonCommand(command);

package/dist/heart/daemon/daemon.js

@@ -51,6 +51,7 @@ const update_checker_1 = require("./update-checker");
 const staged_restart_1 = require("./staged-restart");
 const child_process_1 = require("child_process");
 const pending_1 = require("../../mind/pending");
+const agent_service_1 = require("./agent-service");
 const channel_1 = require("../../mind/friends/channel");
 const mcp_manager_1 = require("../../repertoire/mcp-manager");
 const PIDFILE_PATH = path.join(os.homedir(), ".ouro-cli", "daemon.pids");
@@ -519,6 +520,32 @@ class OuroDaemon {
             case "agent.restart":
                 await this.processManager.restartAgent?.(command.agent);
                 return { ok: true, message: `restarted ${command.agent}` };
+            case "agent.ask":
+                return (0, agent_service_1.handleAgentAsk)(command);
+            case "agent.status":
+                return (0, agent_service_1.handleAgentStatus)(command);
+            case "agent.catchup":
+                return (0, agent_service_1.handleAgentCatchup)(command);
+            case "agent.delegate":
+                return (0, agent_service_1.handleAgentDelegate)(command);
+            case "agent.getContext":
+                return (0, agent_service_1.handleAgentGetContext)(command);
+            case "agent.searchMemory":
+                return (0, agent_service_1.handleAgentSearchMemory)(command);
+            case "agent.getTask":
+                return (0, agent_service_1.handleAgentGetTask)(command);
+            case "agent.checkScope":
+                return (0, agent_service_1.handleAgentCheckScope)(command);
+            case "agent.requestDecision":
+                return (0, agent_service_1.handleAgentRequestDecision)(command);
+            case "agent.checkGuidance":
+                return (0, agent_service_1.handleAgentCheckGuidance)(command);
+            case "agent.reportProgress":
+                return (0, agent_service_1.handleAgentReportProgress)(command);
+            case "agent.reportBlocker":
+                return (0, agent_service_1.handleAgentReportBlocker)(command);
+            case "agent.reportComplete":
+                return (0, agent_service_1.handleAgentReportComplete)(command);
             case "cron.list": {
                 const jobs = this.scheduler.listJobs();
                 const summary = jobs.length === 0