monomind 2.7.12 → 2.7.13

package/packages/@monomind/cli/bin/cli.js

@@ -1,379 +0,0 @@
-#!/usr/bin/env node
-/**
- * @monomind/cli - CLI Entry Point
- *
- * Monomind Command Line Interface
- *
- * MCP mode requires explicit `mcp start` subcommand or MONOMIND_MCP_AUTODETECT=1.
- * Usage: npx @monomind/cli mcp start
- */
-
-import { randomUUID } from 'crypto';
-
-// Check if we should run in MCP server mode.
-// SECURITY: only accept explicit `mcp start` plus piped stdin, OR the explicit
-// `MONOMIND_MCP_AUTODETECT=1` opt-in for the legacy "no args + non-TTY" path.
-// Previously any `monomind` invocation with redirected stdin (CI pipes, xargs,
-// editor integrations) silently flipped into MCP server mode and accepted
-// JSON-RPC tools/call — privilege escalation by environment.
-const cliArgs = process.argv.slice(2);
-const isExplicitMCP = cliArgs.length >= 1 && cliArgs[0] === 'mcp' && (cliArgs.length === 1 || cliArgs[1] === 'start');
-const allowAutoDetect = process.env.MONOMIND_MCP_AUTODETECT === '1';
-const isMCPMode = !process.stdin.isTTY && (isExplicitMCP || (allowAutoDetect && process.argv.length === 2));
-
-if (isMCPMode) {
-  // Run MCP server mode
-  const { listMCPTools, callMCPTool, hasTool } = await import('../dist/src/mcp-client.js');
-
-  // Read version from package.json instead of hardcoding (prevents stale
-  // version drift between bin entry and the published package).
-  let VERSION = '0.0.0';
-  try {
-    const { readFileSync } = await import('fs');
-    const { fileURLToPath } = await import('url');
-    const { dirname, join } = await import('path');
-    const pkgPath = join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
-    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-    if (typeof pkg.version === 'string') VERSION = pkg.version;
-  } catch { /* fall back to 0.0.0 */ }
-  const sessionId = `mcp-${Date.now()}-${randomUUID().slice(0, 8)}`;
-
-  // Don't leak nodeVersion/platform/arch/pid to stderr by default; gate behind
-  // MONOMIND_LOG_LEVEL=debug to reduce fingerprinting in shared log aggregators.
-  if (process.env.MONOMIND_LOG_LEVEL === 'debug') {
-    console.error(
-      `[${new Date().toISOString()}] INFO [monomind-mcp] (${sessionId}) Starting in stdio mode (node=${process.version} platform=${process.platform} arch=${process.arch})`
-    );
-  } else {
-    console.error(
-      `[${new Date().toISOString()}] INFO [monomind-mcp] (${sessionId}) Starting in stdio mode`
-    );
-  }
-
-  // Top-level safety nets — without these, an unhandled async error in a tool
-  // handler crashes the process with no observable cleanup.
-  process.on('uncaughtException', (err) => {
-    console.error(`[${new Date().toISOString()}] FATAL [monomind-mcp] uncaughtException: ${err && err.message ? err.message : String(err)}`);
-    process.exit(1);
-  });
-  process.on('unhandledRejection', (reason) => {
-    const msg = reason instanceof Error ? reason.message : String(reason);
-    console.error(`[${new Date().toISOString()}] FATAL [monomind-mcp] unhandledRejection: ${msg}`);
-    process.exit(1);
-  });
-  const shutdown = (sig) => {
-    console.error(`[${new Date().toISOString()}] INFO [monomind-mcp] (${sessionId}) ${sig} received, shutting down`);
-    process.exit(0);
-  };
-  process.on('SIGINT', () => shutdown('SIGINT'));
-  process.on('SIGTERM', () => shutdown('SIGTERM'));
-
-  // Cap on accumulated input buffer so a peer pumping a single multi-GB line
-  // (or a slow trickle without newlines) cannot OOM-kill the process.
-  const MAX_BUFFER_BYTES = 10 * 1024 * 1024;
-  let buffer = '';
-  // Tracks handleMessage() calls still in flight when stdin closes — without
-  // this, 'end' calling process.exit(0) unconditionally could kill the process
-  // mid-handler and silently drop the response a client is still waiting on
-  // (issue #39).
-  let inFlight = 0;
-  let stdinEnded = false;
-  process.stdin.setEncoding('utf8');
-  // process.stdout.write() to a pipe is NOT guaranteed synchronous — for a
-  // large payload (e.g. a full tools/list response) the OS write can still be
-  // in flight when the call returns. console.log() doesn't expose that, so
-  // calling process.exit() right after it can truncate/drop the very response
-  // being protected. Wait for the actual flush callback before allowing exit.
-  function writeLine(str) {
-    return new Promise((resolve) => process.stdout.write(str + '\n', resolve));
-  }
-
-  process.stdin.on('data', async (chunk) => {
-    buffer += chunk;
-    if (buffer.length > MAX_BUFFER_BYTES) {
-      console.error(`[${new Date().toISOString()}] FATAL [monomind-mcp] input exceeds ${MAX_BUFFER_BYTES} bytes`);
-      process.exit(1);
-    }
-    let lines = buffer.split('\n');
-    buffer = lines.pop() || '';
-    const toProcess = lines.filter((line) => line.trim());
-    // Reserve the WHOLE batch synchronously, before any `await` yields control —
-    // otherwise 'end' can fire in the gap between two lines of the same chunk
-    // (inFlight transiently reads 0 after line 1 finishes but before line 2's
-    // own increment runs), exiting mid-batch and dropping the rest silently.
-    inFlight += toProcess.length;
-
-    for (const line of toProcess) {
-      let parsed;
-      try {
-        parsed = JSON.parse(line);
-      } catch {
-        await writeLine(JSON.stringify({
-          jsonrpc: '2.0',
-          id: null,
-          error: { code: -32700, message: 'Parse error' },
-        }));
-        inFlight--;
-        if (stdinEnded && inFlight === 0) process.exit(0);
-        continue;
-      }
-      try {
-        const response = await handleMessage(parsed);
-        if (response) {
-          await writeLine(JSON.stringify(response));
-        }
-      } catch (error) {
-        await writeLine(JSON.stringify({
-          jsonrpc: '2.0',
-          id: parsed.id ?? null,
-          error: { code: -32603, message: error instanceof Error ? error.message : 'Internal error' },
-        }));
-      } finally {
-        inFlight--;
-        if (stdinEnded && inFlight === 0) process.exit(0);
-      }
-    }
-  });
-
-  process.stdin.on('end', () => {
-    stdinEnded = true;
-    if (inFlight === 0) { process.exit(0); return; }
-    // Bounded safety net: don't hang forever if a handler is genuinely stuck.
-    const EXIT_GRACE_MS = 30000;
-    setTimeout(() => process.exit(0), EXIT_GRACE_MS).unref();
-  });
-
-  async function handleMessage(message) {
-    if (!message.method) {
-      return {
-        jsonrpc: '2.0',
-        id: message.id,
-        error: { code: -32600, message: 'Invalid Request: missing method' },
-      };
-    }
-
-    const params = message.params || {};
-
-    switch (message.method) {
-      case 'initialize':
-        return {
-          jsonrpc: '2.0',
-          id: message.id,
-          result: {
-            protocolVersion: '2024-11-05',
-            serverInfo: { name: 'monomind', version: VERSION },
-            capabilities: {
-              tools: { listChanged: true },
-              resources: { subscribe: true, listChanged: true },
-            },
-          },
-        };
-
-      case 'tools/list': {
-        const tools = await listMCPTools();
-        return {
-          jsonrpc: '2.0',
-          id: message.id,
-          result: {
-            tools: tools.map(tool => ({
-              name: tool.name,
-              description: tool.description,
-              inputSchema: tool.inputSchema,
-            })),
-          },
-        };
-      }
-
-      case 'tools/call': {
-        const toolName = params.name;
-        const toolParams = params.arguments || {};
-
-        if (!await hasTool(toolName)) {
-          return {
-            jsonrpc: '2.0',
-            id: message.id,
-            error: { code: -32601, message: `Tool not found: ${toolName}` },
-          };
-        }
-
-        try {
-          const result = await callMCPTool(toolName, toolParams, { sessionId });
-          return {
-            jsonrpc: '2.0',
-            id: message.id,
-            result: { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] },
-          };
-        } catch (error) {
-          return {
-            jsonrpc: '2.0',
-            id: message.id,
-            error: {
-              code: -32603,
-              message: error instanceof Error ? error.message : 'Tool execution failed',
-            },
-          };
-        }
-      }
-
-      case 'notifications/initialized':
-        return null;
-
-      case 'ping':
-        return { jsonrpc: '2.0', id: message.id, result: {} };
-
-      default:
-        return {
-          jsonrpc: '2.0',
-          id: message.id,
-          error: { code: -32601, message: `Method not found: ${message.method}` },
-        };
-    }
-  }
-} else {
-  // Run normal CLI mode.
-  // Install top-level handlers so an asynchronous error fired from an event-
-  // loop callback does not bypass the synchronous .catch below. Default Node
-  // handler prints the full stack to stderr — which on this codebase includes
-  // attacker-influenced bytes from registry/config error messages and full
-  // filesystem paths. Sanitize before logging and exit non-zero.
-  const safeMsg = (m) =>
-    String(m == null ? '' : m).replace(/[\x00-\x1f\x7f-\x9f]/g, '?').slice(0, 1000);
-  // Crash reporting: files a GitHub issue on monoes/monomind for uncaught
-  // crashes (on by default, `monomind crash-reporting disable` to opt out).
-  // Bounded so a crash handler can't hang the process indefinitely on a
-  // stalled network call — best-effort only, never blocks exit past 10s.
-  const reportAndExit = async (title, stack) => {
-    try {
-      const { reportCrash } = await import('../dist/src/services/crash-reporter.js');
-      const body = [
-        `Uncaught crash in \`monomind\` CLI.`,
-        ``,
-        `Node ${process.version}, ${process.platform}/${process.arch}`,
-        ``,
-        '```',
-        stack || title,
-        '```',
-      ].join('\n');
-      const result = await Promise.race([
-        reportCrash({ repo: 'monoes/monomind', title: `crash: ${title}`, body }),
-        new Promise((resolve) => setTimeout(() => resolve({ status: 'error', message: 'crash report timed out after 10s' }), 10_000)),
-      ]);
-      if (result && result.message) console.error(`[${new Date().toISOString()}] INFO [monomind] crash-report: ${result.message}`);
-    } catch {
-      // never let crash reporting itself crash the crash handler
-    }
-    process.exit(1);
-  };
-  // Not every uncaught error is a bug in monomind, and filing a PUBLIC GitHub
-  // issue for one that isn't is worse than useless — it leaks the user's paths
-  // into a tracker and buries real crashes in noise. Two classes are user
-  // environment or normal usage, never a product defect:
-  //
-  //   EPIPE / ERR_STREAM_DESTROYED — the reader closed the pipe first. This is
-  //     what `monomind hooks worker list | head` does every single time, and
-  //     what `| less` does when you quit early. Completely normal (issue #41).
-  //
-  //   ERR_MODULE_NOT_FOUND — a dependency is missing from the install: a
-  //     partial/corrupt node_modules, or the CLI being run straight out of an
-  //     extracted tarball. The user needs an actionable message, not a bug
-  //     report filed on their behalf (issues #46, #47).
-  //
-  // Anything else still reports as before.
-  const classifyFault = (err) => {
-    const code = err && err.code;
-    if (code === 'EPIPE' || code === 'ERR_STREAM_DESTROYED') return 'broken-pipe';
-    if (code === 'ERR_MODULE_NOT_FOUND') return 'missing-dependency';
-    return 'crash';
-  };
-
-  /** Handles the non-bug classes. Returns true if it fully handled the error. */
-  const handleExpectedFault = (err) => {
-    switch (classifyFault(err)) {
-      case 'broken-pipe':
-        // Downstream went away — there is nothing left to say and nowhere to
-        // say it. Exiting 0 keeps `monomind ... | head` from looking failed.
-        process.exit(0);
-        return true;
-      case 'missing-dependency': {
-        const pkg = /Cannot find package '([^']+)'/.exec(safeMsg(err && err.message))?.[1];
-        console.error(
-          pkg
-            ? `[monomind] Missing dependency: ${pkg}\n` +
-                `  This is an install problem, not a crash — nothing was reported.\n` +
-                `  Try: npm install ${pkg}   (or reinstall monomind: npm i -g monomind@latest)`
-            : `[monomind] A dependency could not be resolved: ${safeMsg(err && err.message)}\n` +
-                `  This is an install problem, not a crash — nothing was reported.`,
-        );
-        if (process.env.DEBUG) console.error(err && err.stack);
-        process.exit(1);
-        return true;
-      }
-      default:
-        return false;
-    }
-  };
-
-  // Belt and braces for the pipe case: handling 'error' on the streams keeps a
-  // mid-write EPIPE from becoming an uncaughtException at all.
-  for (const stream of [process.stdout, process.stderr]) {
-    stream.on('error', (err) => {
-      if (classifyFault(err) === 'broken-pipe') process.exit(0);
-    });
-  }
-
-  process.on('uncaughtException', (err) => {
-    if (handleExpectedFault(err)) return;
-    console.error(`[${new Date().toISOString()}] FATAL [monomind] uncaughtException: ${safeMsg(err && err.message)}`);
-    if (process.env.DEBUG) console.error(err && err.stack);
-    reportAndExit(safeMsg(err && err.message) || 'uncaughtException', err && err.stack);
-    return;
-  });
-  process.on('unhandledRejection', (reason) => {
-    if (reason instanceof Error && handleExpectedFault(reason)) return;
-    const msg = reason instanceof Error ? reason.message : String(reason);
-    console.error(`[${new Date().toISOString()}] FATAL [monomind] unhandledRejection: ${safeMsg(msg)}`);
-    if (process.env.DEBUG && reason instanceof Error) console.error(reason.stack);
-    reportAndExit(safeMsg(msg) || 'unhandledRejection', reason instanceof Error ? reason.stack : undefined);
-  });
-
-  const { CLI } = await import('../dist/src/index.js');
-  const cli = new CLI();
-  // A detached daemon child (`start --daemon --foreground-worker-internal`,
-  // see src/commands/start.ts) intentionally keeps a ref'd setInterval alive
-  // after its action resolves — that's what holds the process open as a real
-  // daemon. Unconditionally calling process.exit() here would kill it the
-  // instant the action's promise resolves, defeating the whole point.
-  const isDaemonChild = cliArgs.includes('--foreground-worker-internal');
-  cli.run().then(() => {
-    if (!isDaemonChild) {
-      // Do NOT call process.exit() here. See
-      // docs/adrs/ADR-R001-onnxruntime-process-teardown.md.
-      //
-      // Any command that touched embeddings has onnxruntime-node's thread pool
-      // loaded in-process (memory-bridge -> @huggingface/transformers), and
-      // forcing exit out from under it aborts:
-      //   libc++abi: terminating due to uncaught exception of type
-      //   std::__1::system_error: mutex lock failed: Invalid argument
-      // — exit code 134 on `doctor`, `memory store`, `memory search` etc.,
-      // despite the command itself having succeeded. Disposing the pipeline
-      // first does NOT help; only letting the loop drain does. (v2.7.4 bug,
-      // fixed 2.7.5. Guarded by src/__tests__/bin-cli-exit-path.test.ts.)
-      //
-      // NOTE the rule inverts for short-lived worker children, where onnx
-      // instead keeps the loop alive forever and you MUST force-exit — see
-      // src/routing/embed-worker.ts. Do not "unify" the two.
-      //
-      // So: publish the exit code and let node exit on its own once the loop
-      // empties. The unref'd timer below still fires if something lingers
-      // (it does not itself hold the process open), preserving the original
-      // guarantee that the CLI never hangs forever on a stray handle.
-      process.exitCode = process.exitCode ?? 0;
-      const FORCE_EXIT_MS = 5000;
-      setTimeout(() => process.exit(process.exitCode ?? 0), FORCE_EXIT_MS).unref();
-    }
-    // Daemon child: let the event loop stay alive on its own ref'd interval.
-  }).catch((error) => {
-    console.error('Fatal error:', safeMsg(error && error.message));
-    process.exit(1);
-  });
-}

package/packages/@monomind/cli/bin/mcp-server.js

@@ -1,208 +0,0 @@
-#!/usr/bin/env node
-/**
- * @monomind/cli - MCP Server Entry Point
- *
- * Direct stdio MCP server for Claude Code integration.
- * This entry point handles stdin/stdout directly for MCP protocol
- * without any CLI formatting output that would corrupt the protocol.
- */
-
-import { randomUUID } from 'crypto';
-import { listMCPTools, callMCPTool, hasTool } from '../dist/src/mcp-client.js';
-
-const VERSION = '3.0.0';
-const sessionId = `mcp-${Date.now()}-${randomUUID().slice(0, 8)}`;
-
-// Log to stderr (doesn't corrupt stdout for MCP protocol)
-console.error(
-  `[${new Date().toISOString()}] INFO [monomind-mcp] (${sessionId}) Starting in stdio mode`
-);
-console.error(JSON.stringify({
-  arch: process.arch,
-  mode: 'mcp-stdio',
-  nodeVersion: process.version,
-  pid: process.pid,
-  platform: process.platform,
-  protocol: 'stdio',
-  sessionId,
-  version: VERSION,
-}));
-
-// Handle stdin messages
-let buffer = '';
-
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', async (chunk) => {
-  buffer += chunk;
-
-  // Process complete JSON messages (newline-delimited)
-  let lines = buffer.split('\n');
-  buffer = lines.pop() || ''; // Keep incomplete line in buffer
-
-  for (const line of lines) {
-    if (line.trim()) {
-      let parsed;
-      try {
-        parsed = JSON.parse(line);
-      } catch {
-        console.log(JSON.stringify({
-          jsonrpc: '2.0',
-          id: null,
-          error: { code: -32700, message: 'Parse error' },
-        }));
-        continue;
-      }
-      try {
-        const response = await handleMessage(parsed);
-        if (response) {
-          console.log(JSON.stringify(response));
-        }
-      } catch (error) {
-        console.error(
-          `[${new Date().toISOString()}] ERROR [monomind-mcp] handler error:`,
-          error instanceof Error ? error.message : String(error)
-        );
-        console.log(JSON.stringify({
-          jsonrpc: '2.0',
-          id: parsed.id ?? null,
-          error: { code: -32603, message: error instanceof Error ? error.message : 'Internal error' },
-        }));
-      }
-    }
-  }
-});
-
-process.stdin.on('end', () => {
-  console.error(
-    `[${new Date().toISOString()}] INFO [monomind-mcp] (${sessionId}) stdin closed, shutting down...`
-  );
-  process.exit(0);
-});
-
-// Handle process termination
-process.on('SIGINT', () => {
-  console.error(`[${new Date().toISOString()}] INFO [monomind-mcp] Received SIGINT`);
-  process.exit(0);
-});
-
-process.on('SIGTERM', () => {
-  console.error(`[${new Date().toISOString()}] INFO [monomind-mcp] Received SIGTERM`);
-  process.exit(0);
-});
-
-/**
- * Handle MCP message
- */
-async function handleMessage(message) {
-  if (!message.method) {
-    return {
-      jsonrpc: '2.0',
-      id: message.id,
-      error: { code: -32600, message: 'Invalid Request: missing method' },
-    };
-  }
-
-  const params = message.params || {};
-
-  try {
-    switch (message.method) {
-      case 'initialize': {
-        const roots = params.roots ?? params.workspaceFolders ?? [];
-        if (roots.length > 0 && !process.env.MONOMIND_CWD) {
-          const rootUri = typeof roots[0] === 'string' ? roots[0] : (roots[0].uri ?? roots[0].path ?? '');
-          const rootPath = rootUri.startsWith('file://') ? decodeURIComponent(rootUri.slice(7)) : rootUri;
-          if (rootPath) {
-            process.env.MONOMIND_CWD = rootPath;
-            console.error(`[${new Date().toISOString()}] INFO [monomind-mcp] Project root set to ${rootPath}`);
-          }
-        }
-        return {
-          jsonrpc: '2.0',
-          id: message.id,
-          result: {
-            protocolVersion: '2024-11-05',
-            serverInfo: { name: 'monomind', version: VERSION },
-            capabilities: {
-              tools: { listChanged: true },
-              resources: { subscribe: true, listChanged: true },
-            },
-          },
-        };
-      }
-
-      case 'tools/list': {
-        const tools = await listMCPTools();
-        return {
-          jsonrpc: '2.0',
-          id: message.id,
-          result: {
-            tools: tools.map(tool => ({
-              name: tool.name,
-              description: tool.description,
-              inputSchema: tool.inputSchema,
-            })),
-          },
-        };
-      }
-
-      case 'tools/call': {
-        const toolName = params.name;
-        const toolParams = params.arguments || {};
-
-        if (!await hasTool(toolName)) {
-          return {
-            jsonrpc: '2.0',
-            id: message.id,
-            error: { code: -32601, message: `Tool not found: ${toolName}` },
-          };
-        }
-
-        try {
-          const result = await callMCPTool(toolName, toolParams, { sessionId });
-          return {
-            jsonrpc: '2.0',
-            id: message.id,
-            result: { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] },
-          };
-        } catch (error) {
-          return {
-            jsonrpc: '2.0',
-            id: message.id,
-            error: {
-              code: -32603,
-              message: error instanceof Error ? error.message : 'Tool execution failed',
-            },
-          };
-        }
-      }
-
-      case 'notifications/initialized':
-        console.error(`[${new Date().toISOString()}] INFO [monomind-mcp] Client initialized`);
-        return null; // No response for notifications
-
-      case 'ping':
-        return {
-          jsonrpc: '2.0',
-          id: message.id,
-          result: {},
-        };
-
-      default:
-        return {
-          jsonrpc: '2.0',
-          id: message.id,
-          error: { code: -32601, message: `Method not found: ${message.method}` },
-        };
-    }
-  } catch (error) {
-    console.error(`[${new Date().toISOString()}] ERROR [monomind-mcp] ${message.method}:`, error);
-    return {
-      jsonrpc: '2.0',
-      id: message.id,
-      error: {
-        code: -32603,
-        message: error instanceof Error ? error.message : 'Internal error',
-      },
-    };
-  }
-}

package/packages/@monomind/cli/bin/preinstall.cjs

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-// Preinstall hook — no-op (cache repair removed in 3.1.0-alpha.53)

package/packages/@monomind/cli/dist/src/agents/registry-builder.d.ts

@@ -1,64 +0,0 @@
-type TriggerPattern = {
-    pattern: string;
-    mode: 'glob' | 'regex' | 'exact';
-};
-type AgentRegistryEntry = {
-    slug: string;
-    name: string;
-    version: string;
-    category: string;
-    description: string;
-    capabilities: string[];
-    taskTypes: string[];
-    tools: string[];
-    triggers: TriggerPattern[];
-    deprecated: boolean;
-    deprecatedBy?: string;
-    dependencies: string[];
-    filePath: string;
-    registeredAt: string;
-    lastUpdated: string;
-};
-type AgentRegistry = {
-    version: string;
-    generatedAt: string;
-    totalAgents: number;
-    agents: AgentRegistryEntry[];
-};
-/**
- * Build the agent registry by scanning `.md` files under `agentsRoot`.
- *
- * @param agentsRoot - Root directory (or array of directories) to scan.
- * @param outputPath - Optional path to write the registry JSON file.
- * @returns The built AgentRegistry object.
- */
-export declare function buildRegistry(agentsRoot: string, outputPath?: string): AgentRegistry;
-/**
- * Compute the ordered list of agent-definition roots for `cwd`: extras
- * (canonical, from MONOMIND_EXTRA_AGENT_PATHS or a sibling `agency-agents`
- * dir) first, then the project's `.claude/agents`. Shared by CLI startup
- * and `monomind doctor` so both build the registry the same way.
- */
-export declare function computeAgentRoots(cwd: string): string[];
-/**
- * Build a unified agent registry from multiple root directories, deduplicating
- * by slug. When the same slug appears in more than one root, the entry from the
- * **first** root in the array wins (earlier roots are considered canonical).
- *
- * Typical usage — extras (agency-agents) listed first so they take precedence
- * over any locally duplicated copies in `.claude/agents/`:
- *
- * ```ts
- * buildUnifiedRegistry([
- *   '/path/to/agency-agents',   // canonical source — wins on conflict
- *   '.claude/agents',           // dev copies — used only for unique slugs
- * ], '.monomind/registry.json');
- * ```
- *
- * @param roots      - Ordered list of directories to scan (first-wins on slug conflict).
- * @param outputPath - Optional path to write the merged registry JSON file.
- * @returns The deduplicated AgentRegistry.
- */
-export declare function buildUnifiedRegistry(roots: string[], outputPath?: string): AgentRegistry;
-export {};
-//# sourceMappingURL=registry-builder.d.ts.map