@opencoven/coven-code 0.0.3 → 0.0.6

package/src/commands/usage.mjs

@@ -1,34 +0,0 @@
-import { listThreads } from '../threads/store.mjs';
-import { estimateTokenCount } from '../agent/fixture.mjs';
-import { readEffectiveSettings } from '../settings/load.mjs';
-
-export function runUsage(parsed = {}) {
-  const summary = localUsageSummary();
-  const showCosts = readEffectiveSettings(parsed)['covenCode.showCosts'] !== false;
-  if (showCosts) console.log('remote_balance: unavailable (local recreation)');
-  console.log(`threads: ${summary.threads}`);
-  console.log(`turns: ${summary.turns}`);
-  if (showCosts) {
-    console.log(`input_tokens_estimate: ${summary.inputTokens}`);
-    console.log(`output_tokens_estimate: ${summary.outputTokens}`);
-  }
-}
-
-function localUsageSummary() {
-  const threads = listThreads();
-  let turns = 0;
-  let inputTokens = 0;
-  let outputTokens = 0;
-  for (const thread of threads) {
-    const messages = Array.isArray(thread.messages) ? thread.messages : [];
-    for (const message of messages) {
-      if (message.role === 'user') {
-        turns += 1;
-        inputTokens += estimateTokenCount(message.content ?? '');
-      } else if (message.role === 'assistant') {
-        outputTokens += estimateTokenCount(message.content ?? '');
-      }
-    }
-  }
-  return { threads: threads.length, turns, inputTokens, outputTokens };
-}

package/src/constants.mjs

@@ -1,52 +0,0 @@
-import { readFileSync } from 'node:fs';
-
-const packageJson = JSON.parse(
-  readFileSync(new URL('../package.json', import.meta.url), 'utf8'),
-);
-
-export const VERSION = packageJson.version;
-export const PRODUCT_NAME = 'Coven Code';
-export const CLI_NAME = 'coven-code';
-export const PACKAGE_NAME = '@opencoven/coven-code';
-export const CONFIG_SUBDIR = 'coven-code';
-export const PROJECT_SUBDIR = '.coven-code';
-export const THREAD_URL_BASE = 'https://coven-code.local/threads';
-
-export const FILE_MENTION_MAX_LINES = 500;
-export const FILE_MENTION_MAX_LINE_LENGTH = 2048;
-export const REPL_HISTORY_LIMIT = 500;
-
-export const AGENT_MODES = ['smart', 'deep', 'rush', 'large'];
-
-export const BUILTIN_TOOLS = [
-  ['Bash', 'built-in', "Executes the given shell command in the user's default shell"],
-  ['Read', 'built-in', 'Reads a UTF-8 text file from disk'],
-  ['Grep', 'built-in', 'Searches files by regular expression'],
-  ['glob', 'built-in', 'Finds files by glob pattern'],
-  ['create_file', 'built-in', 'Creates a new file'],
-  ['edit_file', 'built-in', 'Edits an existing file'],
-  ['oracle', 'built-in', 'Asks for second-opinion review or reasoning'],
-  ['librarian', 'built-in', 'Researches code across repositories or the current workspace'],
-  ['Task', 'built-in', 'Runs an isolated subagent for delegated work'],
-  ['painter', 'built-in', 'Generates or edits local image artifacts'],
-  ['mermaid', 'built-in', 'Renders a Mermaid diagram from the provided code'],
-  ['look_at', 'built-in', 'Inspects images, PDFs, or media files with a goal'],
-  ['web_search', 'built-in', 'Searches the web for information'],
-  ['read_web_page', 'built-in', 'Reads and extracts text from a web page'],
-  ['undo_edit', 'built-in', 'Undoes the latest edit_file change'],
-  ['find_thread', 'built-in', 'Finds prior threads by keyword, file, or task context'],
-  ['finder', 'built-in', 'Finds prior threads by keyword, file, or task context'],
-  ['read_mcp_resource', 'built-in', 'Reads a resource from a configured MCP server'],
-];
-
-export const BUILTIN_PERMISSIONS = [
-  ['allow', 'Bash', 'ls'],
-  ['allow', 'Bash', 'git status'],
-  ['allow', 'Bash', 'git diff'],
-  ['allow', 'Bash', 'git log'],
-  ['allow', 'Bash', 'npm test'],
-  ['allow', 'Bash', 'cargo build'],
-  ['ask', 'Bash', 'git push'],
-  ['ask', 'Bash', 'rm -rf'],
-  ['ask', 'Bash', 'sudo'],
-];

package/src/main.mjs

@@ -1,87 +0,0 @@
-import { parseGlobalArgs, UsageError } from './cli/parse.mjs';
-import { printHelp } from './cli/help.mjs';
-import { runCommand } from './cli/dispatch.mjs';
-import { runExecute } from './cli/execute.mjs';
-import { runInteractive } from './cli/repl.mjs';
-import { runTuiInteractive } from './cli/tui.mjs';
-import { runIdeConnect } from './commands/ide.mjs';
-import { readStdin } from './util/shell.mjs';
-import { AGENT_MODES, VERSION } from './constants.mjs';
-import { latestActiveThread, requireThread } from './threads/store.mjs';
-import { reasoningEffortForMode } from './cli/reasoning.mjs';
-
-export { UsageError };
-
-export async function main() {
-  const args = process.argv.slice(2);
-  const parsed = parseGlobalArgs(args);
-  const stdin = readStdin();
-
-  if (parsed.help) {
-    printHelp();
-    return;
-  }
-
-  if (parsed.version) {
-    console.log(VERSION);
-    return;
-  }
-
-  if (parsed.ide) {
-    runIdeConnect(parsed.ide);
-    return;
-  }
-
-  const command = parsed.positionals[0];
-  if (command) {
-    await runCommand(command, parsed.positionals.slice(1), parsed, stdin);
-    return;
-  }
-
-  if (parsed.streamJson && !parsed.execute) {
-    throw new UsageError('--stream-json requires --execute');
-  }
-  if (parsed.streamJsonInput && !parsed.streamJson) {
-    throw new UsageError('--stream-json-input requires --stream-json');
-  }
-  if (parsed.continueThread && !parsed.execute) {
-    throw new UsageError('--continue requires --execute');
-  }
-  if (!AGENT_MODES.includes(parsed.mode)) {
-    throw new UsageError(`mode must be one of: ${AGENT_MODES.join(', ')}`);
-  }
-  parsed.reasoningEffort = reasoningEffortForMode(parsed.mode, parsed.reasoningEffort);
-
-  if (parsed.execute || (stdin.length > 0 && !process.stdout.isTTY && process.env.COVEN_CODE_TUI_SCRIPTED !== '1')) {
-    await runExecute(parsed, stdin, { thread: continuationThread(parsed) });
-    return;
-  }
-
-  if (process.env.COVEN_CODE_TUI_SCRIPTED === '1' || (process.stdout.isTTY && (process.stdin.isTTY || stdin.length > 0))) {
-    const runner = selectInteractiveRunner({
-      stdinIsTTY: Boolean(process.stdin.isTTY),
-      stdoutIsTTY: Boolean(process.stdout.isTTY),
-      env: process.env,
-    });
-    if (runner === 'tui') await runTuiInteractive(parsed, stdin);
-    else await runInteractive(parsed, stdin);
-    return;
-  }
-
-  printHelp();
-}
-
-export function selectInteractiveRunner({ stdinIsTTY, stdoutIsTTY, env }) {
-  if (env.COVEN_CODE_TUI_SCRIPTED === '1') return 'tui';
-  if (env.COVEN_CODE_REPL === '1') return 'repl';
-  if (stdinIsTTY && stdoutIsTTY) return 'tui';
-  return 'repl';
-}
-
-function continuationThread(parsed) {
-  if (!parsed.continueThread) return undefined;
-  if (typeof parsed.continueThread === 'string') return requireThread(parsed.continueThread);
-  const thread = latestActiveThread();
-  if (!thread) throw new UsageError('No active thread to continue');
-  return thread;
-}

package/src/mcp/discover.mjs

@@ -1,154 +0,0 @@
-import { existsSync } from 'node:fs';
-import path from 'node:path';
-import { readManagedSettings, readSettings, readSettingsFile } from '../settings/load.mjs';
-import { findWorkspaceSettingsFile } from '../settings/paths.mjs';
-import {
-  isMcpServerAllowed,
-  mcpPermissionRules,
-  mcpPermissionStatus,
-  readWorkspaceMcpApprovals,
-} from './permissions.mjs';
-import { mcpRegistryGate, mcpRegistryStatus } from './registry.mjs';
-import { listSkills } from '../skills/discover.mjs';
-
-const MCP_SERVERS_SETTING = 'covenCode.mcpServers';
-
-export function listConfiguredMcpServers(parsed = {}) {
-  const { userSettings, workspaceSettings, managedSettings, approvals, permissionRules, registryGate } = mcpSettings(parsed);
-  const byName = new Map();
-
-  for (const [name, config] of Object.entries(userSettings[MCP_SERVERS_SETTING] ?? {})) {
-    const expandedConfig = expandMcpServerConfigEnv(config);
-    byName.set(name, {
-      name,
-      config: expandedConfig,
-      source: 'user',
-      status: mcpServerStatus('approved', expandedConfig, permissionRules, registryGate),
-    });
-  }
-  for (const [name, config] of Object.entries(workspaceSettings[MCP_SERVERS_SETTING] ?? {})) {
-    const expandedConfig = expandMcpServerConfigEnv(config);
-    byName.set(name, {
-      name,
-      config: expandedConfig,
-      source: 'workspace',
-      status: mcpServerStatus(approvals[name] ? 'approved' : 'awaiting approval', expandedConfig, permissionRules, registryGate),
-    });
-  }
-  for (const [name, config] of Object.entries(managedSettings[MCP_SERVERS_SETTING] ?? {})) {
-    const expandedConfig = expandMcpServerConfigEnv(config);
-    byName.set(name, {
-      name,
-      config: expandedConfig,
-      source: 'managed',
-      status: mcpServerStatus('approved', expandedConfig, permissionRules, registryGate),
-    });
-  }
-
-  return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
-}
-
-export function listActiveMcpServerEntries(parsed = {}, prompt = '') {
-  const { permissionRules, registryGate } = mcpSettings(parsed);
-  const inline = parseInlineMcpServers(parsed.mcpConfig)
-    .filter((server) => !isMcpServerDisabled(server.config))
-    .filter((server) => !mcpRegistryStatus(server.config, registryGate))
-    .filter((server) => isMcpServerAllowed(server.config, permissionRules))
-    .map((server) => ({
-      name: server.name,
-      status: 'connected',
-      source: 'cli',
-      config: server.config,
-    }));
-  const inlineNames = new Set(inline.map((server) => server.name));
-  const configured = listConfiguredMcpServers(parsed)
-    .filter((server) => server.status === 'approved')
-    .filter((server) => !inlineNames.has(server.name))
-    .map((server) => ({ ...server, status: 'connected' }));
-  const occupiedNames = new Set([...inline, ...configured].map((server) => server.name));
-  const skillServers = listSkillMcpServers(prompt, parsed)
-    .filter((server) => !isMcpServerDisabled(server.config))
-    .filter((server) => !mcpRegistryStatus(server.config, registryGate))
-    .filter((server) => isMcpServerAllowed(server.config, permissionRules))
-    .filter((server) => !occupiedNames.has(server.name))
-    .map((server) => ({ ...server, status: 'connected' }));
-  return [...inline, ...configured, ...skillServers];
-}
-
-function mcpSettings(parsed = {}) {
-  const userSettings = readSettings(parsed);
-  const workspacePath = findWorkspaceSettingsFile(process.cwd());
-  const workspaceSettings = workspacePath ? readSettingsFile(workspacePath) : {};
-  const managedSettings = readManagedSettings();
-  return {
-    userSettings,
-    workspaceSettings,
-    managedSettings,
-    approvals: readWorkspaceMcpApprovals(process.cwd()),
-    permissionRules: mcpPermissionRules(userSettings, workspaceSettings, managedSettings),
-    registryGate: mcpRegistryGate(userSettings, workspaceSettings, managedSettings),
-  };
-}
-
-function mcpServerStatus(defaultStatus, config, permissionRules, registryGate) {
-  if (isMcpServerDisabled(config)) return 'disabled';
-  const registryStatus = mcpRegistryStatus(config, registryGate);
-  if (registryStatus) return registryStatus;
-  return mcpPermissionStatus(defaultStatus, config, permissionRules);
-}
-
-function isMcpServerDisabled(config = {}) {
-  return config.disabled === true;
-}
-
-export function listActiveMcpServers(parsed = {}) {
-  return listActiveMcpServerEntries(parsed).map(({ name, source }) => ({
-    name,
-    status: 'connected',
-    source,
-  }));
-}
-
-export function parseInlineMcpServers(raw) {
-  if (!raw) return [];
-  try {
-    const parsed = JSON.parse(raw);
-    const servers = parsed.mcpServers ?? parsed[MCP_SERVERS_SETTING] ?? parsed;
-    return Object.keys(servers).map((name) => ({ name, config: expandMcpServerConfigEnv(servers[name]) }));
-  } catch {
-    return [{ name: 'inline', config: { command: expandEnvVars(raw) } }];
-  }
-}
-
-export function expandMcpServerConfigEnv(value) {
-  if (typeof value === 'string') return expandEnvVars(value);
-  if (Array.isArray(value)) return value.map((entry) => expandMcpServerConfigEnv(entry));
-  if (value && typeof value === 'object') {
-    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, expandMcpServerConfigEnv(entry)]));
-  }
-  return value;
-}
-
-export function expandEnvVars(value) {
-  return String(value).replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_, name) => process.env[name] ?? '');
-}
-
-export function formatMcpServerCommand(config) {
-  if (config.url) return config.url;
-  return [config.command, ...(config.args ?? [])].filter(Boolean).join(' ');
-}
-
-export function listSkillMcpServers(prompt = '', parsed = {}) {
-  const lower = prompt.toLowerCase();
-  const servers = [];
-  for (const skill of listSkills({ parsed })) {
-    if (!lower.includes(skill.name.toLowerCase())) continue;
-    const mcpPath = path.join(skill.dir, 'mcp.json');
-    if (!existsSync(mcpPath)) continue;
-    const mcp = readSettingsFile(mcpPath);
-    for (const [name, config] of Object.entries(mcp)) {
-      servers.push({ name, config: expandMcpServerConfigEnv(config), source: `skill:${skill.name}` });
-    }
-  }
-  return servers;
-}

package/src/mcp/local.mjs

@@ -1,55 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { parseMcpCallOutput, parseMcpResourceOutput, parseMcpToolsOutput } from './parsers.mjs';
-
-export function queryLocalMcpTools(config = {}) {
-  return parseMcpToolsOutput(queryLocalMcpToolsResult(config).stdout ?? '');
-}
-
-export function queryLocalMcpToolsResult(config = {}) {
-  if (!config.command) return [];
-  return spawnSync(config.command, config.args ?? [], {
-    input: localMcpRequestInput('tools/list', {}),
-    env: { ...process.env, ...(config.env ?? {}) },
-    encoding: 'utf8',
-    timeout: 1500,
-  });
-}
-
-export function callLocalMcpTool(config = {}, name, args = {}) {
-  if (!config.command) return '';
-  const result = spawnSync(config.command, config.args ?? [], {
-    input: localMcpRequestInput('tools/call', { name, arguments: args }),
-    env: { ...process.env, ...(config.env ?? {}) },
-    encoding: 'utf8',
-    timeout: 1500,
-  });
-  return parseMcpCallOutput(result.stdout);
-}
-
-export function readLocalMcpResource(config = {}, uri) {
-  if (!config.command) return '';
-  const result = spawnSync(config.command, config.args ?? [], {
-    input: localMcpRequestInput('resources/read', { uri }),
-    env: { ...process.env, ...(config.env ?? {}) },
-    encoding: 'utf8',
-    timeout: 1500,
-  });
-  return parseMcpResourceOutput(result.stdout);
-}
-
-function localMcpRequestInput(method, params = {}) {
-  return [
-    {
-      jsonrpc: '2.0',
-      id: 1,
-      method: 'initialize',
-      params: {
-        protocolVersion: '2025-06-18',
-        capabilities: {},
-        clientInfo: { name: 'coven-code', version: '0.0.0' },
-      },
-    },
-    { jsonrpc: '2.0', method: 'notifications/initialized' },
-    { jsonrpc: '2.0', id: 2, method, params },
-  ].map((message) => JSON.stringify(message)).join('\n') + '\n';
-}

package/src/mcp/parsers.mjs

@@ -1,46 +0,0 @@
-export function parseMcpCallOutput(stdout = '') {
-  for (const line of stdout.split(/\r?\n/).filter(Boolean)) {
-    try {
-      const message = JSON.parse(line);
-      const content = message.result?.content ?? message.content;
-      if (Array.isArray(content)) {
-        return content.map((entry) => entry.text ?? entry.content ?? JSON.stringify(entry)).join('\n');
-      }
-      if (typeof content === 'string') return content;
-      if (message.result !== undefined) return JSON.stringify(message.result);
-    } catch {
-      // Non-JSON diagnostic output from MCP server startup is ignored.
-    }
-  }
-  return '';
-}
-
-export function parseMcpResourceOutput(stdout = '') {
-  for (const line of stdout.split(/\r?\n/).filter(Boolean)) {
-    try {
-      const message = JSON.parse(line);
-      const contents = message.result?.contents ?? message.contents;
-      if (Array.isArray(contents)) {
-        return contents.map((entry) => entry.text ?? entry.content ?? entry.blob ?? JSON.stringify(entry)).join('\n');
-      }
-      if (typeof contents === 'string') return contents;
-      if (message.result !== undefined) return JSON.stringify(message.result);
-    } catch {
-      // Non-JSON diagnostic output from MCP server startup is ignored.
-    }
-  }
-  return '';
-}
-
-export function parseMcpToolsOutput(stdout = '') {
-  for (const line of stdout.split(/\r?\n/).filter(Boolean)) {
-    try {
-      const message = JSON.parse(line);
-      if (Array.isArray(message.result?.tools)) return message.result.tools;
-      if (Array.isArray(message.tools)) return message.tools;
-    } catch {
-      // Non-JSON diagnostic output from MCP server startup is ignored.
-    }
-  }
-  return [];
-}

package/src/mcp/permissions.mjs

@@ -1,52 +0,0 @@
-import path from 'node:path';
-import { findWorkspaceSettingsFile, workspaceSettingsFile } from '../settings/paths.mjs';
-import { readManagedSettings, readSettings, readSettingsFile, writeSettingsFile } from '../settings/load.mjs';
-import { globMatch } from '../util/glob.mjs';
-
-const MCP_PERMISSIONS_SETTING = 'covenCode.mcpPermissions';
-
-export function mcpPermissionRulesForCwd(parsed = {}) {
-  const userSettings = readSettings(parsed);
-  const workspacePath = findWorkspaceSettingsFile(process.cwd());
-  const workspaceSettings = workspacePath ? readSettingsFile(workspacePath) : {};
-  return mcpPermissionRules(userSettings, workspaceSettings, readManagedSettings());
-}
-
-export function mcpPermissionRules(userSettings = {}, workspaceSettings = {}, managedSettings = {}) {
-  if (Array.isArray(managedSettings[MCP_PERMISSIONS_SETTING])) return managedSettings[MCP_PERMISSIONS_SETTING];
-  if (Array.isArray(workspaceSettings[MCP_PERMISSIONS_SETTING])) return workspaceSettings[MCP_PERMISSIONS_SETTING];
-  if (Array.isArray(userSettings[MCP_PERMISSIONS_SETTING])) return userSettings[MCP_PERMISSIONS_SETTING];
-  return [];
-}
-
-export function mcpPermissionStatus(defaultStatus, config, rules) {
-  return isMcpServerAllowed(config, rules) ? defaultStatus : 'rejected';
-}
-
-export function isMcpServerAllowed(config = {}, rules = []) {
-  for (const rule of rules) {
-    if (!rule || typeof rule !== 'object' || !rule.matches || typeof rule.matches !== 'object') continue;
-    if (!mcpPermissionRuleMatches(config, rule.matches)) continue;
-    return rule.action !== 'reject';
-  }
-  return true;
-}
-
-function mcpPermissionRuleMatches(config = {}, matches = {}) {
-  const entries = Object.entries(matches);
-  if (entries.length === 0) return false;
-  return entries.every(([field, pattern]) => {
-    if (field === 'command') return globMatch(pattern, config.command ?? '');
-    if (field === 'args') return globMatch(pattern, (config.args ?? []).join(' '));
-    if (field === 'url') return globMatch(pattern, config.url ?? '');
-    return false;
-  });
-}
-
-export function readWorkspaceMcpApprovals(cwd) {
-  return readSettingsFile(path.join(path.dirname(workspaceSettingsFile(cwd)), 'mcp-approvals.json'));
-}
-
-export async function writeWorkspaceMcpApprovals(cwd, approvals) {
-  await writeSettingsFile(path.join(path.dirname(workspaceSettingsFile(cwd)), 'mcp-approvals.json'), approvals);
-}

package/src/mcp/probe.mjs

@@ -1,85 +0,0 @@
-import { globMatch } from '../util/glob.mjs';
-import {
-  callLocalMcpTool,
-  queryLocalMcpTools,
-  queryLocalMcpToolsResult,
-  readLocalMcpResource,
-} from './local.mjs';
-import { parseMcpToolsOutput } from './parsers.mjs';
-import {
-  callRemoteMcpTool,
-  queryRemoteMcpTools,
-  readRemoteMcpResource,
-} from './remote.mjs';
-
-export async function discoverMcpToolRows(servers) {
-  const rows = [];
-  for (const server of servers) {
-    const toolDefs = filterIncludedMcpTools(
-      server.config,
-      server.source?.startsWith('skill:')
-        ? skillMcpTools(server.config)
-        : await queryMcpTools(server.config, server.name),
-    );
-    for (const tool of toolDefs) {
-      rows.push([
-        `mcp__${server.name}__${tool.name}`,
-        'local-mcp',
-        tool.description || `Tool from ${server.name}`,
-      ]);
-    }
-  }
-  return rows;
-}
-
-export async function mcpServerHealth(config = {}, serverName = '') {
-  if (config.url) {
-    const tools = await queryRemoteMcpTools(config, serverName);
-    return formatToolHealth(tools);
-  }
-  const result = queryLocalMcpToolsResult(config);
-  if (result.error) return `error ${result.error.code ?? result.error.message}`;
-  if ((result.status ?? 0) !== 0) return `error exit ${result.status}`;
-  return formatToolHealth(parseMcpToolsOutput(result.stdout));
-}
-
-function formatToolHealth(tools = []) {
-  return `ok ${tools.length} ${tools.length === 1 ? 'tool' : 'tools'}`;
-}
-
-function filterIncludedMcpTools(config = {}, tools = []) {
-  return tools.filter((tool) => isMcpToolIncluded(config, tool.name));
-}
-
-export function isMcpToolIncluded(config = {}, toolName = '') {
-  if (!Array.isArray(config.includeTools) || config.includeTools.length === 0) return true;
-  return config.includeTools.some((pattern) => globMatch(pattern, toolName));
-}
-
-async function queryMcpTools(config = {}, serverName = '') {
-  if (config.url) return queryRemoteMcpTools(config, serverName);
-  return queryLocalMcpTools(config);
-}
-
-export async function callMcpTool(config = {}, name, args = {}, serverName = '') {
-  if (config.url) return callRemoteMcpTool(config, name, args, serverName);
-  return callLocalMcpTool(config, name, args);
-}
-
-export async function readMcpResource(config = {}, uri, serverName = '') {
-  if (config.url) return readRemoteMcpResource(config, uri, serverName);
-  return readLocalMcpResource(config, uri);
-}
-
-export function skillMcpTools(config = {}) {
-  return (config.includeTools ?? []).map((name) => ({
-    name,
-    description: `Tool from skill MCP server ${config.command || config.url || ''}`.trim(),
-  }));
-}
-
-export function parseMcpToolName(name) {
-  const match = name.match(/^mcp__([^_]+(?:_[^_]+)*)__([\s\S]+)$/);
-  if (!match) return undefined;
-  return { serverName: match[1], toolName: match[2] };
-}

package/src/mcp/registry.mjs

@@ -1,96 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-
-const MCP_REGISTRY_SETTING = 'covenCode.mcpRegistry';
-const MCP_REGISTRY_URL_SETTING = 'covenCode.mcpRegistry.url';
-
-export function mcpRegistryGate(userSettings = {}, workspaceSettings = {}, managedSettings = {}) {
-  const policy = registryPolicy(managedSettings) ?? registryPolicy(workspaceSettings) ?? registryPolicy(userSettings);
-  if (!policy?.url) return { enabled: false };
-  const payload = registryPayload(policy.url);
-  if (!payload) return { enabled: true, reachable: false, allowedNames: new Set(), allowedUrls: new Set() };
-  try {
-    return { enabled: true, reachable: true, ...registryAllowlist(JSON.parse(payload)) };
-  } catch {
-    return { enabled: true, reachable: false, allowedNames: new Set(), allowedUrls: new Set() };
-  }
-}
-
-export function mcpRegistryStatus(config = {}, gate = { enabled: false }) {
-  if (!gate.enabled) return undefined;
-  if (!gate.reachable) return 'registry-blocked';
-  return registryAllowsConfig(config, gate) ? undefined : 'registry-blocked';
-}
-
-function registryPolicy(settings = {}) {
-  const value = settings[MCP_REGISTRY_SETTING];
-  if (typeof value === 'string' && value.trim()) return { url: value.trim() };
-  if (value && typeof value === 'object' && typeof value.url === 'string' && value.url.trim()) {
-    return { url: value.url.trim() };
-  }
-  const url = settings[MCP_REGISTRY_URL_SETTING];
-  if (typeof url === 'string' && url.trim()) return { url: url.trim() };
-  return undefined;
-}
-
-function registryPayload(url) {
-  try {
-    if (/^https?:\/\//i.test(url)) return fetchRegistryUrlSync(url);
-    if (url.startsWith('file://')) return readFileSync(fileURLToPath(url), 'utf8');
-    return readFileSync(url, 'utf8');
-  } catch {
-    return undefined;
-  }
-}
-
-function fetchRegistryUrlSync(url) {
-  const script = `
-const url = process.env.COVEN_CODE_MCP_REGISTRY_URL;
-const timeout = AbortSignal.timeout(1500);
-try {
-  const response = await fetch(url, { signal: timeout });
-  if (!response.ok) process.exit(2);
-  process.stdout.write(await response.text());
-} catch {
-  process.exit(1);
-}
-`;
-  const result = spawnSync(process.execPath, ['--input-type=module', '-e', script], {
-    env: { ...process.env, COVEN_CODE_MCP_REGISTRY_URL: url },
-    encoding: 'utf8',
-    timeout: 2500,
-  });
-  return result.status === 0 ? result.stdout : undefined;
-}
-
-function registryAllowlist(payload) {
-  const allowedNames = new Set();
-  const allowedUrls = new Set();
-  const entries = Array.isArray(payload?.servers) ? payload.servers : Array.isArray(payload) ? payload : [];
-  for (const entry of entries) {
-    const server = entry?.server ?? entry;
-    if (!server || typeof server !== 'object') continue;
-    if (typeof server.name === 'string') allowedNames.add(server.name);
-    for (const remote of Array.isArray(server.remotes) ? server.remotes : []) {
-      if (typeof remote?.url === 'string') allowedUrls.add(normalizeRegistryUrl(remote.url));
-    }
-  }
-  return { allowedNames, allowedUrls };
-}
-
-function registryAllowsConfig(config = {}, gate = {}) {
-  if (typeof config.registryName === 'string' && gate.allowedNames?.has(config.registryName)) return true;
-  if (typeof config.url === 'string' && gate.allowedUrls?.has(normalizeRegistryUrl(config.url))) return true;
-  return false;
-}
-
-function normalizeRegistryUrl(value) {
-  try {
-    const url = new URL(value);
-    url.hash = '';
-    return url.href.replace(/\/$/, '');
-  } catch {
-    return String(value).replace(/\/$/, '');
-  }
-}