@ouro.bot/cli 0.1.0-alpha.16 → 0.1.0-alpha.160

package/dist/repertoire/mcp-client.js

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpClient = void 0;
+const child_process_1 = require("child_process");
+const readline_1 = require("readline");
+const runtime_1 = require("../nerves/runtime");
+const MCP_PROTOCOL_VERSION = "2024-11-05";
+const DEFAULT_TOOL_CALL_TIMEOUT = 30_000;
+class McpClient {
+    config;
+    process = null;
+    nextId = 1;
+    pending = new Map();
+    connected = false;
+    cachedTools = null;
+    onCloseCallback = null;
+    constructor(config) {
+        this.config = config;
+    }
+    async connect() {
+        (0, runtime_1.emitNervesEvent)({
+            event: "mcp.connect_start",
+            component: "repertoire",
+            message: "starting MCP server connection",
+            meta: { command: this.config.command },
+        });
+        const env = { ...process.env, ...this.config.env };
+        this.process = (0, child_process_1.spawn)(this.config.command, this.config.args ?? [], {
+            env,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        this.setupLineReader();
+        this.setupProcessHandlers();
+        try {
+            await this.initialize();
+            this.connected = true;
+            (0, runtime_1.emitNervesEvent)({
+                event: "mcp.connect_end",
+                component: "repertoire",
+                message: "MCP server connected",
+                meta: { command: this.config.command },
+            });
+        }
+        catch (error) {
+            this.connected = false;
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "mcp.connect_error",
+                component: "repertoire",
+                message: "MCP server connection failed",
+                meta: {
+                    command: this.config.command,
+                    /* v8 ignore next -- defensive: spawn errors are always Error instances @preserve */
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+            throw error;
+        }
+    }
+    async listTools() {
+        if (this.cachedTools) {
+            return this.cachedTools;
+        }
+        const allTools = [];
+        let cursor;
+        do {
+            const params = {};
+            if (cursor) {
+                params.cursor = cursor;
+            }
+            const result = await this.sendRequest("tools/list", params);
+            allTools.push(...result.tools);
+            cursor = result.nextCursor;
+        } while (cursor);
+        this.cachedTools = allTools;
+        return allTools;
+    }
+    async callTool(name, args, timeout = DEFAULT_TOOL_CALL_TIMEOUT) {
+        (0, runtime_1.emitNervesEvent)({
+            event: "mcp.tool_call_start",
+            component: "repertoire",
+            message: `calling MCP tool: ${name}`,
+            meta: { tool: name },
+        });
+        try {
+            const result = await this.sendRequest("tools/call", {
+                name,
+                arguments: args,
+            }, timeout);
+            (0, runtime_1.emitNervesEvent)({
+                event: "mcp.tool_call_end",
+                component: "repertoire",
+                message: `MCP tool call completed: ${name}`,
+                meta: { tool: name },
+            });
+            return result;
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "mcp.tool_call_error",
+                component: "repertoire",
+                message: `MCP tool call failed: ${name}`,
+                meta: {
+                    tool: name,
+                    /* v8 ignore next -- defensive: callTool errors are always Error instances @preserve */
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+            throw error;
+        }
+    }
+    shutdown() {
+        this.connected = false;
+        this.rejectAllPending(new Error("Client shutdown"));
+        /* v8 ignore next -- defensive: process always exists during normal shutdown @preserve */
+        if (this.process && !this.process.killed) {
+            this.process.kill();
+        }
+        this.process = null;
+    }
+    isConnected() {
+        return this.connected;
+    }
+    onClose(callback) {
+        this.onCloseCallback = callback;
+    }
+    async initialize() {
+        const result = await this.sendRequest("initialize", {
+            protocolVersion: MCP_PROTOCOL_VERSION,
+            clientInfo: { name: "ouroboros", version: "1.0" },
+            capabilities: {},
+        });
+        // Send initialized notification (no id, no response expected)
+        this.writeMessage({
+            jsonrpc: "2.0",
+            method: "initialized",
+        });
+        return result;
+    }
+    sendRequest(method, params, timeout) {
+        return new Promise((resolve, reject) => {
+            if (!this.process || !this.connected && method !== "initialize") {
+                reject(new Error("MCP client is disconnected"));
+                return;
+            }
+            const id = this.nextId++;
+            const pending = { resolve, reject };
+            if (timeout) {
+                pending.timer = setTimeout(() => {
+                    this.pending.delete(id);
+                    reject(new Error(`MCP request timeout after ${timeout}ms: ${method}`));
+                }, timeout);
+            }
+            this.pending.set(id, pending);
+            const request = {
+                jsonrpc: "2.0",
+                id,
+                method,
+                params,
+            };
+            this.writeMessage(request);
+        });
+    }
+    writeMessage(message) {
+        /* v8 ignore next -- defensive: stdin always writable during active connection @preserve */
+        if (this.process?.stdin?.writable) {
+            this.process.stdin.write(JSON.stringify(message) + "\n");
+        }
+    }
+    setupLineReader() {
+        /* v8 ignore next -- defensive: stdout always exists after spawn @preserve */
+        if (!this.process?.stdout)
+            return;
+        const rl = (0, readline_1.createInterface)({ input: this.process.stdout });
+        rl.on("line", (line) => {
+            this.handleLine(line);
+        });
+    }
+    handleLine(line) {
+        let response;
+        try {
+            response = JSON.parse(line);
+        }
+        catch {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                event: "mcp.connect_error",
+                component: "repertoire",
+                message: "received malformed JSON from MCP server",
+                meta: { line },
+            });
+            return;
+        }
+        if (response.id === undefined || response.id === null) {
+            // Notification or invalid — ignore
+            return;
+        }
+        const pending = this.pending.get(response.id);
+        if (!pending)
+            return;
+        this.pending.delete(response.id);
+        if (pending.timer) {
+            clearTimeout(pending.timer);
+        }
+        if (response.error) {
+            pending.reject(new Error(response.error.message));
+        }
+        else {
+            pending.resolve(response.result);
+        }
+    }
+    setupProcessHandlers() {
+        /* v8 ignore next -- defensive: process always exists after spawn @preserve */
+        if (!this.process)
+            return;
+        this.process.on("error", (error) => {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "mcp.connect_error",
+                component: "repertoire",
+                message: "MCP server process error",
+                meta: { reason: error.message },
+            });
+        });
+        this.process.on("close", (code) => {
+            const wasConnected = this.connected;
+            this.connected = false;
+            this.rejectAllPending(new Error(`MCP server process closed with code ${code}`));
+            if (wasConnected) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    event: "mcp.connect_error",
+                    component: "repertoire",
+                    message: "MCP server process exited unexpectedly",
+                    meta: { exitCode: code },
+                });
+            }
+            if (this.onCloseCallback) {
+                this.onCloseCallback();
+            }
+        });
+    }
+    rejectAllPending(error) {
+        for (const [id, pending] of this.pending) {
+            if (pending.timer) {
+                clearTimeout(pending.timer);
+            }
+            pending.reject(error);
+            this.pending.delete(id);
+        }
+    }
+}
+exports.McpClient = McpClient;

package/dist/repertoire/mcp-manager.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpManager = void 0;
+exports.getSharedMcpManager = getSharedMcpManager;
+exports.shutdownSharedMcpManager = shutdownSharedMcpManager;
+exports.resetSharedMcpManager = resetSharedMcpManager;
+const mcp_client_1 = require("./mcp-client");
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+const MAX_RESTART_RETRIES = 5;
+const RESTART_DELAY_MS = 1000;
+class McpManager {
+    servers = new Map();
+    shuttingDown = false;
+    async start(servers) {
+        (0, runtime_1.emitNervesEvent)({
+            event: "mcp.manager_start",
+            component: "repertoire",
+            message: "starting MCP manager",
+            meta: { serverCount: Object.keys(servers).length },
+        });
+        const entries = Object.entries(servers);
+        for (const [name, config] of entries) {
+            await this.connectServer(name, config);
+        }
+    }
+    listAllTools() {
+        const result = [];
+        for (const [name, entry] of this.servers) {
+            result.push({ server: name, tools: entry.cachedTools });
+        }
+        return result;
+    }
+    async callTool(server, tool, args) {
+        const entry = this.servers.get(server);
+        if (!entry) {
+            throw new Error(`Unknown server: ${server}`);
+        }
+        if (!entry.client.isConnected()) {
+            throw new Error(`Server "${server}" is disconnected`);
+        }
+        return entry.client.callTool(tool, args);
+    }
+    shutdown() {
+        this.shuttingDown = true;
+        (0, runtime_1.emitNervesEvent)({
+            event: "mcp.manager_stop",
+            component: "repertoire",
+            message: "shutting down MCP manager",
+            meta: { serverCount: this.servers.size },
+        });
+        for (const [, entry] of this.servers) {
+            entry.client.shutdown();
+        }
+        this.servers.clear();
+    }
+    async connectServer(name, config) {
+        const client = new mcp_client_1.McpClient(config);
+        const entry = {
+            name,
+            config,
+            client,
+            cachedTools: [],
+            consecutiveFailures: 0,
+        };
+        this.servers.set(name, entry);
+        client.onClose(() => {
+            if (this.shuttingDown)
+                return;
+            this.handleServerCrash(name);
+        });
+        try {
+            await client.connect();
+            const tools = await client.listTools();
+            entry.cachedTools = tools;
+            entry.consecutiveFailures = 0;
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "mcp.connect_error",
+                component: "repertoire",
+                message: `failed to connect MCP server "${name}" (command: ${config.command}). Check that the command exists and is properly configured. Reason: ${reason}`,
+                meta: {
+                    server: name,
+                    command: config.command,
+                    args: config.args,
+                    reason,
+                },
+            });
+        }
+    }
+    handleServerCrash(name) {
+        const entry = this.servers.get(name);
+        /* v8 ignore next -- defensive: entry removed between close event and handler @preserve */
+        if (!entry)
+            return;
+        entry.consecutiveFailures++;
+        if (entry.consecutiveFailures > MAX_RESTART_RETRIES) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "mcp.connect_error",
+                component: "repertoire",
+                message: `MCP server "${name}" exceeded max restart retries (${MAX_RESTART_RETRIES}). Giving up — check that "${entry.config.command}" exists and is properly configured in agent.json mcpServers.`,
+                meta: { server: name, command: entry.config.command, failures: entry.consecutiveFailures },
+            });
+            return;
+        }
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            event: "mcp.server_restart",
+            component: "repertoire",
+            message: `restarting crashed MCP server: ${name}`,
+            meta: { server: name, attempt: entry.consecutiveFailures },
+        });
+        /* v8 ignore start -- timer callback: covered by mcp-manager.test.ts via fake timers but v8 can't trace @preserve */
+        setTimeout(() => {
+            if (this.shuttingDown)
+                return;
+            this.restartServer(name).catch(() => {
+                // Error handling is inside restartServer
+            });
+        }, RESTART_DELAY_MS);
+        /* v8 ignore stop */
+    }
+    /* v8 ignore start -- called from timer callback: covered by mcp-manager.test.ts via fake timers but v8 can't trace @preserve */
+    async restartServer(name) {
+        const entry = this.servers.get(name);
+        if (!entry)
+            return;
+        // Remove old entry and reconnect
+        this.servers.delete(name);
+        await this.connectServer(name, entry.config);
+        // Preserve failure count
+        const newEntry = this.servers.get(name);
+        if (newEntry) {
+            newEntry.consecutiveFailures = entry.consecutiveFailures;
+        }
+    }
+}
+exports.McpManager = McpManager;
+let _sharedManager = null;
+let _sharedManagerPromise = null;
+/**
+ * Get or create a shared McpManager instance from the agent's config.
+ * Returns null if no mcpServers are configured.
+ * Safe to call from multiple senses — will only create one instance.
+ */
+async function getSharedMcpManager() {
+    if (_sharedManager)
+        return _sharedManager;
+    /* v8 ignore next -- race guard: deduplicates concurrent initialization calls @preserve */
+    if (_sharedManagerPromise)
+        return _sharedManagerPromise;
+    _sharedManagerPromise = (async () => {
+        try {
+            const config = (0, identity_1.loadAgentConfig)();
+            const servers = config.mcpServers;
+            if (!servers || Object.keys(servers).length === 0)
+                return null;
+            const manager = new McpManager();
+            await manager.start(servers);
+            _sharedManager = manager;
+            return manager;
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "mcp.manager_start",
+                component: "repertoire",
+                message: "failed to initialize shared MCP manager",
+                /* v8 ignore next -- both branches tested: Error in wiring test, non-Error is defensive @preserve */
+                meta: { reason: error instanceof Error ? error.message : String(error) },
+            });
+            return null;
+        }
+        finally {
+            _sharedManagerPromise = null;
+        }
+    })();
+    return _sharedManagerPromise;
+}
+/**
+ * Shut down the shared MCP manager and clear the singleton.
+ * Called during daemon/agent shutdown.
+ */
+function shutdownSharedMcpManager() {
+    if (_sharedManager) {
+        _sharedManager.shutdown();
+        _sharedManager = null;
+    }
+}
+/** Reset for testing only */
+function resetSharedMcpManager() {
+    _sharedManager = null;
+    _sharedManagerPromise = null;
+}

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,9 +51,9 @@ function getSkillsDir() {
 function getProtocolMirrorDir() {
     return path.join(getSkillsDir(), "protocols");
 }
-// Canonical protocol source lives in {repoRoot}/subagents/.
-function getCanonicalProtocolsDir() {
-    return path.join((0, identity_1.getRepoRoot)(), "subagents");
+// 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))
@@ -74,8 +75,10 @@ function listSkills() {
     });
     const baseSkills = listMarkdownBasenames(getSkillsDir());
     const protocolMirrors = listMarkdownBasenames(getProtocolMirrorDir());
-    const canonicalProtocols = listMarkdownBasenames(getCanonicalProtocolsDir());
-    const skills = [...new Set([...baseSkills, ...protocolMirrors, ...canonicalProtocols])].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",
@@ -93,7 +96,7 @@ function loadSkill(skillName) {
     });
     const directSkillPath = path.join(getSkillsDir(), `${skillName}.md`);
     const protocolMirrorPath = path.join(getProtocolMirrorDir(), `${skillName}.md`);
-    const canonicalProtocolPath = path.join(getCanonicalProtocolsDir(), `${skillName}.md`);
+    const harnessSkillPath = path.join(getHarnessSkillsDir(), `${skillName}.md`);
     let resolvedPath = null;
     // 1) Direct agent skill.
     if (fs.existsSync(directSkillPath)) {
@@ -103,21 +106,9 @@ function loadSkill(skillName) {
     else if (fs.existsSync(protocolMirrorPath)) {
         resolvedPath = protocolMirrorPath;
     }
-    // 3) Canonical protocol fallback.
-    else if (fs.existsSync(canonicalProtocolPath)) {
-        (0, runtime_1.emitNervesEvent)({
-            level: "warn",
-            event: "repertoire.error",
-            component: "repertoire",
-            message: "protocol mirror missing; using canonical fallback",
-            meta: {
-                operation: "loadSkill",
-                skill: skillName,
-                mirrorPath: protocolMirrorPath,
-                canonicalPath: canonicalProtocolPath,
-            },
-        });
-        resolvedPath = canonicalProtocolPath;
+    // 3) Harness-level skill (ships with npm package).
+    else if (fs.existsSync(harnessSkillPath)) {
+        resolvedPath = harnessSkillPath;
     }
     if (!resolvedPath) {
         (0, runtime_1.emitNervesEvent)({
@@ -128,13 +119,13 @@ function loadSkill(skillName) {
             meta: {
                 operation: "loadSkill",
                 skill: skillName,
-                checkedPaths: [directSkillPath, protocolMirrorPath, canonicalProtocolPath],
+                checkedPaths: [directSkillPath, protocolMirrorPath, harnessSkillPath],
             },
         });
         throw new Error(`skill '${skillName}' not found in:\n` +
             `- ${directSkillPath}\n` +
             `- ${protocolMirrorPath}\n` +
-            `- ${canonicalProtocolPath}`);
+            `- ${harnessSkillPath}`);
     }
     const content = fs.readFileSync(resolvedPath, "utf-8");
     if (!loadedSkills.includes(skillName)) {

package/dist/repertoire/tasks/board.js

@@ -7,14 +7,21 @@ exports.boardDeps = boardDeps;
 exports.boardSessions = boardSessions;
 const runtime_1 = require("../../nerves/runtime");
 const transitions_1 = require("./transitions");
-const BOARD_STATUS_ORDER = [
+const BOARD_ACTIVE_ORDER = [
     "blocked",
     "processing",
     "collaborating",
     "drafting",
     "validating",
     "paused",
+];
+const BOARD_TERMINAL_ORDER = [
     "done",
+    "cancelled",
+];
+const BOARD_STATUS_ORDER = [
+    ...BOARD_ACTIVE_ORDER,
+    ...BOARD_TERMINAL_ORDER,
 ];
 function compactName(task) {
     const suffix = task.stem.replace(/^\d{4}-\d{2}-\d{2}-\d{4}-/, "");
@@ -29,6 +36,7 @@ function groupByStatus(tasks) {
         paused: [],
         blocked: [],
         done: [],
+        cancelled: [],
     };
     for (const task of tasks) {
         grouped[task.status].push(compactName(task));
@@ -59,8 +67,26 @@ function activeSessionLines(tasks) {
     });
     return active.map((task) => task.stem).sort();
 }
+function activeBridgeLines(tasks) {
+    return tasks
+        .filter((task) => typeof task.frontmatter.active_bridge === "string" && String(task.frontmatter.active_bridge).trim())
+        .map((task) => `${task.stem} -> ${String(task.frontmatter.active_bridge).trim()}`)
+        .sort();
+}
+function buildHealthLine(issues) {
+    if (issues.length === 0)
+        return "health: clean";
+    const liveCount = issues.filter((i) => i.category === "live").length;
+    const migrationCount = issues.filter((i) => i.category === "migration").length;
+    const parts = [];
+    if (liveCount > 0)
+        parts.push(`${liveCount} live`);
+    if (migrationCount > 0)
+        parts.push(`${migrationCount} migration`);
+    return `health: ${parts.join(", ")}`;
+}
 function actionRequired(index, byStatus) {
-    const actions = [...index.parseErrors, ...index.invalidFilenames.map((filePath) => `bad filename: ${filePath}`)];
+    const actions = index.issues.map((issue) => `${issue.code}: ${issue.description} [${issue.target}]`);
     if (byStatus.blocked.length > 0) {
         actions.push(`blocked tasks: ${byStatus.blocked.join(", ")}`);
     }
@@ -77,14 +103,19 @@ function buildTaskBoard(index) {
         meta: { taskCount: index.tasks.length },
     });
     const byStatus = groupByStatus(index.tasks);
-    const counts = transitions_1.TASK_VALID_STATUSES.map((status) => `${status}:${byStatus[status].length}`).join(" ");
+    const activeCounts = BOARD_ACTIVE_ORDER.map((status) => `${status}:${byStatus[status].length}`).join(" ");
     const processing = byStatus.processing.length > 0 ? `\n processing: ${byStatus.processing.join(", ")}` : "";
     const blocked = byStatus.blocked.length > 0 ? `\n blocked: ${byStatus.blocked.join(", ")}` : "";
-    const compact = `[Tasks] ${counts}${processing}${blocked}`;
+    const terminalParts = BOARD_TERMINAL_ORDER
+        .filter((status) => byStatus[status].length > 0)
+        .map((status) => `${status}:${byStatus[status].length}`);
+    const terminalLine = terminalParts.length > 0 ? `\n terminal: ${terminalParts.join(" ")}` : "";
+    const healthLine = `\n ${buildHealthLine(index.issues)}`;
+    const compact = `[Tasks] ${activeCounts}${processing}${blocked}${terminalLine}${healthLine}`;
     const fullLines = [];
     for (const status of BOARD_STATUS_ORDER) {
         const names = byStatus[status];
-        if (status === "done" && names.length === 0)
+        if ((status === "done" || status === "cancelled") && names.length === 0)
             continue;
         fullLines.push(`## ${status}`);
         fullLines.push(names.length > 0 ? names.map((name) => `- ${name}`).join("\n") : "- (none)");
@@ -99,13 +130,20 @@ function buildTaskBoard(index) {
         fullLines.push("## active sessions");
         fullLines.push(active.map((line) => `- ${line}`).join("\n"));
     }
+    const activeBridges = activeBridgeLines(index.tasks);
+    if (activeBridges.length > 0) {
+        fullLines.push("## active bridges");
+        fullLines.push(activeBridges.map((line) => `- ${line}`).join("\n"));
+    }
     return {
         compact,
         full: fullLines.join("\n\n"),
         byStatus,
+        issues: index.issues,
         actionRequired: actionRequired(index, byStatus),
         unresolvedDependencies: unresolved,
         activeSessions: active,
+        activeBridges,
     };
 }
 function boardStatus(board, status) {