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

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

@@ -0,0 +1,464 @@
+"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.createMcpServer = createMcpServer;
+exports.getToolSchemas = getToolSchemas;
+const socket_client_1 = require("./socket-client");
+const agentService = __importStar(require("./agent-service"));
+const runtime_1 = require("../../nerves/runtime");
+/**
+ * Maps MCP tool names to daemon command kinds.
+ */
+const TOOL_TO_COMMAND = {
+    ask: "agent.ask",
+    status: "agent.status",
+    catchup: "agent.catchup",
+    delegate: "agent.delegate",
+    get_context: "agent.getContext",
+    search_memory: "agent.searchMemory",
+    get_task: "agent.getTask",
+    check_scope: "agent.checkScope",
+    request_decision: "agent.requestDecision",
+    check_guidance: "agent.checkGuidance",
+    report_progress: "agent.reportProgress",
+    report_blocker: "agent.reportBlocker",
+    report_complete: "agent.reportComplete",
+};
+/**
+ * Create an MCP server that speaks JSON-RPC 2.0 over stdio.
+ * Handles initialize, initialized, tools/list, and tools/call.
+ * Forwards tool calls to the daemon via Unix socket.
+ */
+function createMcpServer(options) {
+    const { agent, friendId, socketPath, stdin, stdout } = options;
+    let buffer = "";
+    let running = false;
+    let useContentLengthFraming = true; // default to Content-Length, auto-detect from first message
+    function writeResponse(response) {
+        const body = JSON.stringify(response);
+        if (useContentLengthFraming) {
+            const header = `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n`;
+            stdout.write(header + body);
+        }
+        else {
+            stdout.write(body + "\n");
+        }
+    }
+    function tryParseContentLength() {
+        const headerEnd = buffer.indexOf("\r\n\r\n");
+        /* v8 ignore start -- partial header delivery only in real I/O */
+        if (headerEnd === -1)
+            return false;
+        /* v8 ignore stop */
+        const headerSection = buffer.slice(0, headerEnd);
+        const contentLengthMatch = headerSection.match(/Content-Length:\s*(\d+)/i);
+        if (!contentLengthMatch) {
+            buffer = buffer.slice(headerEnd + 4);
+            return true; // consumed invalid header, try again
+        }
+        const contentLength = parseInt(contentLengthMatch[1], 10);
+        const bodyStart = headerEnd + 4;
+        /* v8 ignore start -- partial body delivery only in real I/O */
+        if (buffer.length < bodyStart + contentLength)
+            return false;
+        /* v8 ignore stop */
+        const body = buffer.slice(bodyStart, bodyStart + contentLength);
+        buffer = buffer.slice(bodyStart + contentLength);
+        parseAndDispatch(body);
+        return true;
+    }
+    function tryParseNewlineDelimited() {
+        const newlineIdx = buffer.indexOf("\n");
+        /* v8 ignore start -- partial line delivery only in real I/O */
+        if (newlineIdx === -1)
+            return false;
+        /* v8 ignore stop */
+        const line = buffer.slice(0, newlineIdx).trim();
+        buffer = buffer.slice(newlineIdx + 1);
+        if (line.length === 0)
+            return true; // skip blank lines
+        parseAndDispatch(line);
+        return true;
+    }
+    function parseAndDispatch(body) {
+        let request;
+        try {
+            request = JSON.parse(body);
+        }
+        catch {
+            writeResponse({
+                jsonrpc: "2.0",
+                id: null,
+                error: { code: -32700, message: "Parse error" },
+            });
+            return;
+        }
+        void handleRequest(request);
+    }
+    let framingDetected = false;
+    function handleData(chunk) {
+        buffer += chunk.toString("utf-8");
+        // Auto-detect framing from first message and mirror it in responses
+        if (!framingDetected && buffer.length > 0) {
+            useContentLengthFraming = buffer.startsWith("Content-Length:");
+            framingDetected = true;
+        }
+        // Support both Content-Length framing (Claude Code) and newline-delimited JSON (Codex)
+        while (buffer.length > 0) {
+            const hasContentLength = buffer.startsWith("Content-Length:");
+            const parsed = hasContentLength ? tryParseContentLength() : tryParseNewlineDelimited();
+            /* v8 ignore start -- break on partial message only in real I/O */
+            if (!parsed)
+                break;
+            /* v8 ignore stop */
+        }
+    }
+    async function handleRequest(request) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.mcp_request_start",
+            message: "handling MCP request",
+            meta: { method: request.method, agent },
+        });
+        // Notifications (no id) don't get responses
+        if (request.id === undefined) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.mcp_request_end",
+                message: "handled MCP notification",
+                meta: { method: request.method, agent },
+            });
+            return;
+        }
+        switch (request.method) {
+            case "initialize":
+                await handleInitialize(request);
+                break;
+            case "tools/list":
+                handleToolsList(request);
+                break;
+            case "tools/call":
+                await handleToolsCall(request);
+                break;
+            default:
+                writeResponse({
+                    jsonrpc: "2.0",
+                    id: request.id,
+                    error: {
+                        code: -32601,
+                        message: `Method not found: ${request.method}`,
+                    },
+                });
+                break;
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.mcp_request_end",
+            message: "completed MCP request",
+            meta: { method: request.method, agent },
+        });
+    }
+    async function handleInitialize(request) {
+        // MCP server works standalone (agent-service reads filesystem directly)
+        // Daemon is optional — only needed for commands without a direct service handler
+        writeResponse({
+            jsonrpc: "2.0",
+            id: request.id,
+            result: {
+                protocolVersion: "2024-11-05",
+                serverInfo: {
+                    name: "ouro-mcp-server",
+                    version: "0.1.0",
+                },
+                capabilities: {
+                    tools: { listChanged: false },
+                },
+            },
+        });
+    }
+    function handleToolsList(request) {
+        const tools = getToolSchemas();
+        writeResponse({
+            jsonrpc: "2.0",
+            id: request.id,
+            result: { tools },
+        });
+    }
+    /** Map tool name → agent-service handler function name */
+    const TOOL_TO_SERVICE = {
+        ask: "handleAgentAsk",
+        status: "handleAgentStatus",
+        catchup: "handleAgentCatchup",
+        delegate: "handleAgentDelegate",
+        get_context: "handleAgentGetContext",
+        search_memory: "handleAgentSearchMemory",
+        get_task: "handleAgentGetTask",
+        check_scope: "handleAgentCheckScope",
+        request_decision: "handleAgentRequestDecision",
+        check_guidance: "handleAgentCheckGuidance",
+        report_progress: "handleAgentReportProgress",
+        report_blocker: "handleAgentReportBlocker",
+        report_complete: "handleAgentReportComplete",
+    };
+    async function handleToolsCall(request) {
+        /* v8 ignore start — ?? fallbacks are defensive; MCP clients always send params */
+        const params = request.params ?? {};
+        const toolName = params.name;
+        const toolArgs = (params.arguments ?? {});
+        /* v8 ignore stop */
+        const commandKind = TOOL_TO_COMMAND[toolName];
+        if (!commandKind) {
+            writeResponse({
+                jsonrpc: "2.0",
+                id: request.id,
+                result: {
+                    content: [{ type: "text", text: `Unknown tool: ${toolName}` }],
+                    isError: true,
+                },
+            });
+            return;
+        }
+        // Call agent-service directly (no daemon roundtrip needed for read-only ops)
+        const serviceHandler = TOOL_TO_SERVICE[toolName];
+        let response;
+        /* v8 ignore start — typeof guard always true; instanceof check defensive; else branch unreachable for known tools */
+        if (serviceHandler && typeof agentService[serviceHandler] === "function") {
+            const handlerFn = agentService[serviceHandler];
+            try {
+                response = await handlerFn({ agent, friendId, ...toolArgs });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                response = { ok: false, error: `Service error: ${errorMessage}` };
+            }
+        }
+        else {
+            try {
+                response = await (0, socket_client_1.sendDaemonCommand)(socketPath, {
+                    kind: commandKind, agent, friendId, ...toolArgs,
+                });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                response = { ok: false, error: `Daemon error: ${errorMessage}` };
+            }
+        }
+        /* v8 ignore stop */
+        const text = response.message
+            ?? response.summary
+            ?? JSON.stringify(response.data ?? { ok: response.ok });
+        writeResponse({
+            jsonrpc: "2.0",
+            id: request.id,
+            result: {
+                content: [{ type: "text", text }],
+                isError: !response.ok,
+            },
+        });
+    }
+    function onData(chunk) {
+        handleData(chunk);
+    }
+    return {
+        agent,
+        friendId,
+        start() {
+            if (running)
+                return;
+            running = true;
+            stdin.on("data", onData);
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.mcp_server_start",
+                message: "MCP server started",
+                meta: { agent, friendId, socketPath },
+            });
+        },
+        stop() {
+            if (!running)
+                return;
+            running = false;
+            stdin.removeListener("data", onData);
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.mcp_server_stop",
+                message: "MCP server stopped",
+                meta: { agent, friendId },
+            });
+        },
+    };
+}
+/**
+ * Returns the list of MCP tool schemas for all 13 agent tools.
+ * Each schema follows JSON Schema for inputSchema as required by MCP.
+ */
+function getToolSchemas() {
+    return [
+        {
+            name: "ask",
+            description: "Ask the agent a question. The agent uses its memory and recent session context to provide a useful answer.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    question: { type: "string", description: "The question to ask the agent" },
+                },
+                required: ["question"],
+            },
+        },
+        {
+            name: "status",
+            description: "Get the agent's current status including active sessions, memory state, and activity level.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+            },
+        },
+        {
+            name: "catchup",
+            description: "Get a summary of the agent's recent activity including recent sessions and what it has been working on.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+            },
+        },
+        {
+            name: "delegate",
+            description: "Request the agent to handle a task. The agent queues the task and will work on it when available.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    task: { type: "string", description: "Description of the task to delegate" },
+                    context: { type: "string", description: "Additional context about the task" },
+                },
+                required: ["task"],
+            },
+        },
+        {
+            name: "get_context",
+            description: "Get the agent's current working context including memory summary, active tasks, and relevant state.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+            },
+        },
+        {
+            name: "search_memory",
+            description: "Search the agent's memory for information about a specific topic. Returns matching lines from the agent's memory file.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: { type: "string", description: "Search term to look for in agent memory" },
+                },
+                required: ["query"],
+            },
+        },
+        {
+            name: "get_task",
+            description: "Get details about the agent's current task or list of active tasks.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+            },
+        },
+        {
+            name: "check_scope",
+            description: "Check whether a proposed item or change is in scope for the agent's current work.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    item: { type: "string", description: "The item or change to check scope for" },
+                },
+                required: ["item"],
+            },
+        },
+        {
+            name: "request_decision",
+            description: "Ask the agent to make a decision about a topic. Optionally provide a list of options to choose from.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    topic: { type: "string", description: "The topic requiring a decision" },
+                    options: { type: "string", description: "Comma-separated list of options to consider" },
+                },
+                required: ["topic"],
+            },
+        },
+        {
+            name: "check_guidance",
+            description: "Get guidance from the agent on how to approach a topic. The agent searches its memory for relevant guidance.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    topic: { type: "string", description: "The topic to get guidance on" },
+                },
+                required: ["topic"],
+            },
+        },
+        {
+            name: "report_progress",
+            description: "Report progress on delegated work back to the agent. The agent records the update.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    summary: { type: "string", description: "Summary of progress made" },
+                },
+                required: ["summary"],
+            },
+        },
+        {
+            name: "report_blocker",
+            description: "Report a blocker on delegated work to the agent. The agent records the blocker for review.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    blocker: { type: "string", description: "Description of the blocker" },
+                },
+                required: ["blocker"],
+            },
+        },
+        {
+            name: "report_complete",
+            description: "Report completion of delegated work to the agent. The agent records the completion.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    summary: { type: "string", description: "Summary of what was completed" },
+                },
+                required: ["summary"],
+            },
+        },
+    ];
+}
+// MCP server v0.1.0-alpha.140

package/dist/mind/prompt.js

@@ -198,6 +198,7 @@ my bones give me the \`ouro\` cli. always pass \`--agent ${agentName}\`:
   ouro auth switch --agent ${agentName} --provider <provider>
   ouro mcp list --agent ${agentName}
   ouro mcp call --agent ${agentName} <server> <tool> --args '{...}'
+  ouro mcp-serve --agent ${agentName}
   ouro versions --agent ${agentName}
   ouro rollback --agent ${agentName} [<version>]
   ouro --help
@@ -274,6 +275,7 @@ function runtimeInfoSection(channel) {
     lines.push(`current sense: ${channel}`);
     lines.push(`process type: ${processTypeLabel(channel)}`);
     lines.push(`daemon: ${daemonStatus()}`);
+    lines.push(`mcp serve: i can expose my tools to dev tools via \`ouro mcp-serve\`. see the configure-dev-tools skill for setup.`);
     if (channel === "cli") {
         lines.push("i introduce myself on boot with a fun random greeting.");
     }

package/dist/repertoire/coding/codex-jsonl.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * Codex JSONL event parser.
+ * Parses typed events from Codex --json output:
+ * thread.started, turn.started, turn.completed, item.completed.
+ * Maps events to coding session status transitions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCodexJsonlEvent = parseCodexJsonlEvent;
+const runtime_1 = require("../../nerves/runtime");
+const KNOWN_TYPES = new Set(["thread.started", "turn.started", "turn.completed", "item.completed"]);
+/**
+ * Parse a single JSONL line from Codex --json output.
+ * Returns null for invalid JSON, empty strings, or unknown event types.
+ */
+function parseCodexJsonlEvent(line) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch {
+        (0, runtime_1.emitNervesEvent)({
+            component: "repertoire",
+            event: "repertoire.codex_jsonl_parse_error",
+            message: "failed to parse codex JSONL line",
+            meta: { line: trimmed.slice(0, 100) },
+        });
+        return null;
+    }
+    const type = parsed.type;
+    if (!type || !KNOWN_TYPES.has(type))
+        return null;
+    const event = {
+        type: type,
+        threadId: typeof parsed.thread_id === "string" ? parsed.thread_id : undefined,
+        turnId: typeof parsed.turn_id === "string" ? parsed.turn_id : undefined,
+        item: typeof parsed.item === "object" && parsed.item !== null ? parsed.item : undefined,
+        raw: parsed,
+        statusHint: mapStatusHint(type),
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "repertoire",
+        event: "repertoire.codex_jsonl_event",
+        message: "parsed codex JSONL event",
+        meta: { type, threadId: event.threadId ?? null },
+    });
+    return event;
+}
+function mapStatusHint(type) {
+    switch (type) {
+        case "thread.started":
+        case "turn.started":
+            return "running";
+        case "turn.completed":
+        case "item.completed":
+            return null; // No automatic status change for completion events
+        /* v8 ignore next -- defensive default for unknown event types */
+        default:
+            return null;
+    }
+}

package/dist/repertoire/coding/spawner.js

@@ -39,7 +39,7 @@ const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
-function buildCommandArgs(runner, workdir) {
+function buildCommandArgs(runner, workdir, parentAgent) {
     if (runner === "claude") {
         return {
             command: "claude",
@@ -55,9 +55,26 @@ function buildCommandArgs(runner, workdir) {
             ],
         };
     }
+    const mcpConfig = JSON.stringify({
+        mcp_servers: {
+            ouro: {
+                command: "ouro",
+                args: ["mcp-serve", "--agent", parentAgent ?? "unknown"],
+            },
+        },
+    });
     return {
         command: "codex",
-        args: ["exec", "--skip-git-repo-check", "--cd", workdir],
+        args: [
+            "exec",
+            "--skip-git-repo-check",
+            "--cd",
+            workdir,
+            "--ephemeral",
+            "--json",
+            "-c",
+            mcpConfig,
+        ],
     };
 }
 function buildSpawnEnv(baseEnv, homeDir) {
@@ -108,7 +125,7 @@ function spawnCodingProcess(request, deps = {}) {
     const homeDir = deps.homeDir ?? os.homedir();
     const baseEnv = deps.baseEnv ?? process.env;
     const prompt = buildPrompt(request, { existsSync, readFileSync });
-    const { command, args } = buildCommandArgs(request.runner, request.workdir);
+    const { command, args } = buildCommandArgs(request.runner, request.workdir, request.parentAgent);
     const env = buildSpawnEnv(baseEnv, homeDir);
     (0, runtime_1.emitNervesEvent)({
         component: "repertoire",

package/dist/repertoire/skills.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSkillsDir = getSkillsDir;
+exports.getHarnessSkillsDir = getHarnessSkillsDir;
 exports.listSkills = listSkills;
 exports.loadSkill = loadSkill;
 exports.getLoadedSkills = getLoadedSkills;
@@ -50,6 +51,10 @@ function getSkillsDir() {
 function getProtocolMirrorDir() {
     return path.join(getSkillsDir(), "protocols");
 }
+// Harness-level skills live in {repoRoot}/skills/ directory.
+function getHarnessSkillsDir() {
+    return path.join((0, identity_1.getRepoRoot)(), "skills");
+}
 function listMarkdownBasenames(dir) {
     if (!fs.existsSync(dir))
         return [];
@@ -70,7 +75,10 @@ function listSkills() {
     });
     const baseSkills = listMarkdownBasenames(getSkillsDir());
     const protocolMirrors = listMarkdownBasenames(getProtocolMirrorDir());
-    const skills = [...new Set([...baseSkills, ...protocolMirrors])].sort();
+    const harnessSkills = listMarkdownBasenames(getHarnessSkillsDir());
+    // Agent skills (base + protocol) come first; harness skills are fallback.
+    // Set deduplicates by name — agent overrides harness.
+    const skills = [...new Set([...baseSkills, ...protocolMirrors, ...harnessSkills])].sort();
     (0, runtime_1.emitNervesEvent)({
         event: "repertoire.load_end",
         component: "repertoire",
@@ -88,6 +96,7 @@ function loadSkill(skillName) {
     });
     const directSkillPath = path.join(getSkillsDir(), `${skillName}.md`);
     const protocolMirrorPath = path.join(getProtocolMirrorDir(), `${skillName}.md`);
+    const harnessSkillPath = path.join(getHarnessSkillsDir(), `${skillName}.md`);
     let resolvedPath = null;
     // 1) Direct agent skill.
     if (fs.existsSync(directSkillPath)) {
@@ -97,6 +106,10 @@ function loadSkill(skillName) {
     else if (fs.existsSync(protocolMirrorPath)) {
         resolvedPath = protocolMirrorPath;
     }
+    // 3) Harness-level skill (ships with npm package).
+    else if (fs.existsSync(harnessSkillPath)) {
+        resolvedPath = harnessSkillPath;
+    }
     if (!resolvedPath) {
         (0, runtime_1.emitNervesEvent)({
             level: "error",
@@ -106,12 +119,13 @@ function loadSkill(skillName) {
             meta: {
                 operation: "loadSkill",
                 skill: skillName,
-                checkedPaths: [directSkillPath, protocolMirrorPath],
+                checkedPaths: [directSkillPath, protocolMirrorPath, harnessSkillPath],
             },
         });
         throw new Error(`skill '${skillName}' not found in:\n` +
             `- ${directSkillPath}\n` +
-            `- ${protocolMirrorPath}`);
+            `- ${protocolMirrorPath}\n` +
+            `- ${harnessSkillPath}`);
     }
     const content = fs.readFileSync(resolvedPath, "utf-8");
     if (!loadedSkills.includes(skillName)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.139",
+  "version": "0.1.0-alpha.140",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",
@@ -11,6 +11,7 @@
     "dist/",
     "AdoptionSpecialist.ouro/",
     "subagents/",
+    "skills/",
     "assets/",
     "changelog.json"
   ],