@sporesec/arcana 3.0.2 → 4.0.0

package/dist/compress/rules/git.js

@@ -0,0 +1,113 @@
+import { registerRule } from "../engine.js";
+registerRule({
+    name: "git-status",
+    tools: ["git"],
+    compress(lines) {
+        // Detect git status output and compact it
+        const isStatus = lines.some((l) => /^(On branch|Changes|Untracked|modified:|new file:|deleted:)/.test(l.trim()));
+        if (!isStatus)
+            return lines;
+        const result = [];
+        let branch = "";
+        const staged = [];
+        const unstaged = [];
+        const untracked = [];
+        let section = "none";
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith("On branch ")) {
+                branch = trimmed.replace("On branch ", "");
+            }
+            else if (trimmed.startsWith("Changes to be committed")) {
+                section = "staged";
+            }
+            else if (trimmed.startsWith("Changes not staged")) {
+                section = "unstaged";
+            }
+            else if (trimmed.startsWith("Untracked files")) {
+                section = "untracked";
+            }
+            else if (/^\s*(modified|new file|deleted|renamed|copied):/.test(line)) {
+                const file = trimmed.replace(/^(modified|new file|deleted|renamed|copied):\s*/, "");
+                if (section === "staged")
+                    staged.push(file);
+                else
+                    unstaged.push(file);
+            }
+            else if (section === "untracked" && trimmed && !trimmed.startsWith("(") && !trimmed.startsWith("no changes")) {
+                untracked.push(trimmed);
+            }
+        }
+        if (branch)
+            result.push(`branch: ${branch}`);
+        if (staged.length > 0)
+            result.push(`staged (${staged.length}): ${staged.slice(0, 5).join(", ")}${staged.length > 5 ? ` +${staged.length - 5}` : ""}`);
+        if (unstaged.length > 0)
+            result.push(`modified (${unstaged.length}): ${unstaged.slice(0, 5).join(", ")}${unstaged.length > 5 ? ` +${unstaged.length - 5}` : ""}`);
+        if (untracked.length > 0)
+            result.push(`untracked (${untracked.length}): ${untracked.slice(0, 3).join(", ")}${untracked.length > 3 ? ` +${untracked.length - 3}` : ""}`);
+        if (result.length === 0)
+            result.push("clean");
+        return result.length > 0 ? result : lines;
+    },
+});
+registerRule({
+    name: "git-log",
+    tools: ["git"],
+    compress(lines) {
+        // Detect git log output (lines starting with "commit ")
+        const isLog = lines.some((l) => /^commit [0-9a-f]{40}$/.test(l.trim()));
+        if (!isLog)
+            return lines;
+        const result = [];
+        let currentHash = "";
+        let currentMsg = "";
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (/^commit [0-9a-f]{40}$/.test(trimmed)) {
+                if (currentHash && currentMsg) {
+                    result.push(`${currentHash.slice(0, 7)} ${currentMsg}`);
+                }
+                currentHash = trimmed.replace("commit ", "");
+                currentMsg = "";
+            }
+            else if (trimmed &&
+                !trimmed.startsWith("Author:") &&
+                !trimmed.startsWith("Date:") &&
+                !trimmed.startsWith("Merge:")) {
+                if (!currentMsg)
+                    currentMsg = trimmed;
+            }
+        }
+        if (currentHash && currentMsg) {
+            result.push(`${currentHash.slice(0, 7)} ${currentMsg}`);
+        }
+        return result.length > 0 ? result : lines;
+    },
+});
+registerRule({
+    name: "git-diff-stat",
+    tools: ["git"],
+    compress(lines) {
+        // Compact large diffs: keep stat summary, trim hunks
+        const statLine = lines.findIndex((l) => /^\s*\d+ files? changed/.test(l));
+        if (statLine === -1)
+            return lines;
+        // Keep everything up to and including the stat summary
+        const result = lines.slice(0, statLine + 1);
+        // After stat, only keep hunk headers and first 3 lines of each hunk
+        let hunkLines = 0;
+        for (let i = statLine + 1; i < lines.length; i++) {
+            const line = lines[i];
+            if (line.startsWith("diff --git") || line.startsWith("@@")) {
+                result.push(line);
+                hunkLines = 0;
+            }
+            else if (hunkLines < 3) {
+                result.push(line);
+                hunkLines++;
+            }
+        }
+        return result;
+    },
+});

package/dist/compress/rules/npm.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/compress/rules/npm.js

@@ -0,0 +1,99 @@
+import { registerRule } from "../engine.js";
+registerRule({
+    name: "npm-install",
+    tools: ["npm", "pnpm", "yarn"],
+    compress(lines) {
+        // Compact npm/pnpm install output
+        const isInstall = lines.some((l) => /^(added|removed|up to date|Packages:|Progress:)/.test(l.trim()));
+        if (!isInstall)
+            return lines;
+        const result = [];
+        const warnings = [];
+        let summary = "";
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Keep summary lines
+            if (/^(added|removed|up to date|Done in)/.test(trimmed)) {
+                summary = trimmed;
+            }
+            // Keep dependency sections
+            else if (/^(dependencies|devDependencies|peerDependencies):/.test(trimmed)) {
+                result.push(trimmed);
+            }
+            // Keep actual package additions (+ package@version)
+            else if (trimmed.startsWith("+ ")) {
+                result.push(trimmed);
+            }
+            // Collect warnings
+            else if (/^(WARN|warn|npm warn)/.test(trimmed)) {
+                if (warnings.length < 3)
+                    warnings.push(trimmed);
+            }
+            // Skip progress bars, http lines, timing
+        }
+        if (warnings.length > 0) {
+            result.push(`warnings (${warnings.length}): ${warnings[0]}`);
+        }
+        if (summary)
+            result.push(summary);
+        return result.length > 0 ? result : lines;
+    },
+});
+registerRule({
+    name: "npm-test",
+    tools: ["npm", "pnpm"],
+    compress(lines) {
+        // Compact test runner output: keep failures and summary
+        const hasSummary = lines.some((l) => /Tests?\s+\d+/.test(l) || /\d+ (passed|failed|skipped)/.test(l));
+        if (!hasSummary)
+            return lines;
+        const result = [];
+        const failures = [];
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Keep summary lines
+            if (/Tests?\s+\d+/.test(trimmed) || /\d+ (passed|failed|skipped)/.test(trimmed)) {
+                result.push(line);
+            }
+            // Keep test file results
+            else if (/^[✓✗×]|PASS|FAIL/.test(trimmed)) {
+                if (/FAIL|✗|×/.test(trimmed)) {
+                    failures.push(line);
+                }
+                // Skip individual passing tests
+            }
+            // Keep error details
+            else if (/^(Error|AssertionError|Expected|Received|at )/.test(trimmed)) {
+                result.push(line);
+            }
+            // Keep duration
+            else if (/Duration|Time/.test(trimmed)) {
+                result.push(line);
+            }
+        }
+        // Show failures first, then summary
+        return [...failures, ...result].length > 0 ? [...failures, ...result] : lines;
+    },
+});
+registerRule({
+    name: "npm-audit",
+    tools: ["npm", "pnpm"],
+    compress(lines) {
+        const isAudit = lines.some((l) => /vulnerabilit/.test(l));
+        if (!isAudit)
+            return lines;
+        const result = [];
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Keep vulnerability summary
+            if (/\d+ vulnerabilit/.test(trimmed) || /found 0/.test(trimmed)) {
+                result.push(trimmed);
+            }
+            // Keep severity breakdown
+            else if (/^(critical|high|moderate|low)\s*\|?\s*\d+/.test(trimmed)) {
+                result.push(trimmed);
+            }
+        }
+        return result.length > 0 ? result : lines;
+    },
+});

package/dist/compress/rules/test-runner.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/compress/rules/test-runner.js

@@ -0,0 +1,103 @@
+import { registerRule } from "../engine.js";
+registerRule({
+    name: "vitest",
+    tools: ["vitest"],
+    compress(lines) {
+        const isVitest = lines.some((l) => /Test Files|Tests\s+\d+/.test(l));
+        if (!isVitest)
+            return lines;
+        const result = [];
+        const failures = [];
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Keep file-level results
+            if (/^[✓✗×].*\.test\./.test(trimmed) || /FAIL/.test(trimmed)) {
+                if (/✗|×|FAIL/.test(trimmed))
+                    failures.push(line);
+            }
+            // Keep summary
+            else if (/Test Files|Tests\s+\d+|Duration|Start at/.test(trimmed)) {
+                result.push(line);
+            }
+            // Keep assertion errors
+            else if (/^(AssertionError|Error|Expected|Received|expect\()/.test(trimmed)) {
+                result.push(line);
+            }
+        }
+        return [...failures, ...result].length > 0 ? [...failures, ...result] : lines;
+    },
+});
+registerRule({
+    name: "jest",
+    tools: ["jest"],
+    compress(lines) {
+        const isJest = lines.some((l) => /Test Suites:|Tests:/.test(l));
+        if (!isJest)
+            return lines;
+        const result = [];
+        const failures = [];
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (/^(FAIL|PASS)/.test(trimmed)) {
+                if (trimmed.startsWith("FAIL"))
+                    failures.push(line);
+            }
+            else if (/Test Suites:|Tests:|Snapshots:|Time:/.test(trimmed)) {
+                result.push(line);
+            }
+            else if (/●/.test(line)) {
+                // Jest failure markers
+                failures.push(line);
+            }
+        }
+        return [...failures, ...result].length > 0 ? [...failures, ...result] : lines;
+    },
+});
+registerRule({
+    name: "pytest",
+    tools: ["pytest", "python"],
+    compress(lines) {
+        const isPytest = lines.some((l) => /passed|failed|error/.test(l) && /=+/.test(l));
+        if (!isPytest)
+            return lines;
+        const result = [];
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Keep summary line
+            if (/^=+.*=+$/.test(trimmed) && /(passed|failed|error|warning)/.test(trimmed)) {
+                result.push(line);
+            }
+            // Keep FAILED markers
+            else if (/^FAILED/.test(trimmed)) {
+                result.push(line);
+            }
+            // Keep short test results section
+            else if (/^(ERRORS|FAILURES|SHORT TEST SUMMARY)/.test(trimmed)) {
+                result.push(line);
+            }
+        }
+        return result.length > 0 ? result : lines;
+    },
+});
+registerRule({
+    name: "go-test",
+    tools: ["go"],
+    compress(lines) {
+        const isGoTest = lines.some((l) => /^(ok|FAIL|---)\s/.test(l.trim()));
+        if (!isGoTest)
+            return lines;
+        const result = [];
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Keep package results
+            if (/^(ok|FAIL)\s/.test(trimmed)) {
+                result.push(line);
+            }
+            // Keep individual test failures
+            else if (/^--- FAIL/.test(trimmed)) {
+                result.push(line);
+            }
+        }
+        return result.length > 0 ? result : lines;
+    },
+});

package/dist/compress/rules/tsc.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/compress/rules/tsc.js

@@ -0,0 +1,39 @@
+import { registerRule } from "../engine.js";
+registerRule({
+    name: "tsc-errors",
+    tools: ["tsc", "typescript"],
+    compress(lines) {
+        // Compact TypeScript compiler errors: group by file, show first error per file
+        const isTs = lines.some((l) => /\.tsx?:\d+:\d+/.test(l) || /error TS\d+/.test(l));
+        if (!isTs)
+            return lines;
+        const byFile = new Map();
+        let summary = "";
+        for (const line of lines) {
+            const match = line.match(/^(.+\.tsx?)[:(\s]+(\d+)/);
+            if (match) {
+                const file = match[1];
+                if (!byFile.has(file))
+                    byFile.set(file, []);
+                byFile.get(file).push(line.trim());
+            }
+            if (/Found \d+ error/.test(line)) {
+                summary = line.trim();
+            }
+        }
+        const result = [];
+        for (const [file, errors] of byFile) {
+            result.push(`${file} (${errors.length} error${errors.length > 1 ? "s" : ""}):`);
+            // Show first 2 errors per file
+            for (const err of errors.slice(0, 2)) {
+                result.push(`  ${err}`);
+            }
+            if (errors.length > 2) {
+                result.push(`  ...+${errors.length - 2} more`);
+            }
+        }
+        if (summary)
+            result.push(summary);
+        return result.length > 0 ? result : lines;
+    },
+});

package/dist/compress/tracker.d.ts

@@ -0,0 +1,16 @@
+interface ToolStats {
+    calls: number;
+    savedTokens: number;
+}
+interface CompressionStats {
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalSaved: number;
+    byTool: Record<string, ToolStats>;
+}
+export declare function recordCompression(tool: string, inputTokens: number, outputTokens: number): void;
+export declare function getCompressionStats(): CompressionStats & {
+    savingsPct: number;
+};
+export declare function resetCompressionStats(): void;
+export {};

package/dist/compress/tracker.js

@@ -0,0 +1,45 @@
+import { existsSync, readFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { atomicWriteSync } from "../utils/atomic.js";
+function statsPath() {
+    return join(homedir(), ".arcana", "compression-stats.json");
+}
+function readStats() {
+    const p = statsPath();
+    if (!existsSync(p)) {
+        return { totalInputTokens: 0, totalOutputTokens: 0, totalSaved: 0, byTool: {} };
+    }
+    try {
+        return JSON.parse(readFileSync(p, "utf-8"));
+    }
+    catch {
+        return { totalInputTokens: 0, totalOutputTokens: 0, totalSaved: 0, byTool: {} };
+    }
+}
+function writeStats(stats) {
+    const dir = join(homedir(), ".arcana");
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    atomicWriteSync(statsPath(), JSON.stringify(stats, null, 2));
+}
+export function recordCompression(tool, inputTokens, outputTokens) {
+    const stats = readStats();
+    stats.totalInputTokens += inputTokens;
+    stats.totalOutputTokens += outputTokens;
+    stats.totalSaved += inputTokens - outputTokens;
+    if (!stats.byTool[tool]) {
+        stats.byTool[tool] = { calls: 0, savedTokens: 0 };
+    }
+    stats.byTool[tool].calls++;
+    stats.byTool[tool].savedTokens += inputTokens - outputTokens;
+    writeStats(stats);
+}
+export function getCompressionStats() {
+    const stats = readStats();
+    const savingsPct = stats.totalInputTokens > 0 ? Math.round((stats.totalSaved / stats.totalInputTokens) * 100) : 0;
+    return { ...stats, savingsPct };
+}
+export function resetCompressionStats() {
+    writeStats({ totalInputTokens: 0, totalOutputTokens: 0, totalSaved: 0, byTool: {} });
+}

package/dist/constants.d.ts

@@ -7,4 +7,16 @@ export declare const PRUNE_KEEP_NEWEST = 3;
 export declare const LARGE_SKILL_KB_THRESHOLD = 50;
 export declare const TOKENS_PER_KB = 256;
 export declare const CONTEXT_WINDOW_TOKENS = 200000;
+export declare const INDEX_FILENAME = "_index.md";
+export declare const LOADED_FILENAME = "_loaded.md";
+export declare const ACTIVE_FILENAME = "_active.md";
+export declare const CONTEXT_BUDGET_PCT = 30;
+export declare const MODEL_CONTEXTS: Record<string, number>;
+export declare const SKILL_NAME_REGEX: RegExp;
+export declare const SKILL_MAX_LINES = 300;
+export declare const JACCARD_THRESHOLD = 0.5;
+export declare const CACHE_MAX_AGE_MS: number;
+export declare const MEMORY_MAX_LINES = 200;
+export declare const AGENT_BLOAT_PERCENT = 70;
+export declare const DISK_WARN_BYTES: number;
 export declare const DESCRIPTION_TRUNCATION = 50;

package/dist/constants.js

@@ -9,5 +9,34 @@ export const PRUNE_KEEP_NEWEST = 3;
 export const LARGE_SKILL_KB_THRESHOLD = 50;
 export const TOKENS_PER_KB = 256;
 export const CONTEXT_WINDOW_TOKENS = 200_000;
+// Progressive disclosure
+export const INDEX_FILENAME = "_index.md";
+export const LOADED_FILENAME = "_loaded.md";
+export const ACTIVE_FILENAME = "_active.md";
+// Context curation budget
+export const CONTEXT_BUDGET_PCT = 30; // Max % of model context for skills
+export const MODEL_CONTEXTS = {
+    // Claude (March 2026): 200K standard, 1M beta for Opus/Sonnet
+    "claude-opus-4.6": 200_000,
+    "claude-sonnet-4.6": 200_000,
+    "claude-haiku-4.5": 200_000,
+    // OpenAI (March 2026)
+    "gpt-5.4": 1_000_000,
+    // Google Gemini (March 2026)
+    "gemini-3.1-pro": 1_000_000,
+    "gemini-3.1-flash": 1_000_000,
+    "gemini-3.1-thinking": 1_000_000,
+    default: 200_000,
+};
+// Validation
+export const SKILL_NAME_REGEX = /^[a-z0-9][a-z0-9-]{0,63}$/;
+export const SKILL_MAX_LINES = 300;
+export const JACCARD_THRESHOLD = 0.5;
+// Cache
+export const CACHE_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24 hours
+// Diagnostics thresholds
+export const MEMORY_MAX_LINES = 200;
+export const AGENT_BLOAT_PERCENT = 70;
+export const DISK_WARN_BYTES = 1 * 1024 * 1024 * 1024; // 1 GB
 // Display
 export const DESCRIPTION_TRUNCATION = 50;

package/dist/interactive/helpers.js

@@ -85,6 +85,7 @@ export function buildMenuOptions(installedCount, _availableCount) {
     if (!isNew) {
         options.push({ value: "setup", label: "Get Started", hint: "detect project, add more skills" });
     }
+    options.push({ value: "curate", label: "Curate context", hint: "auto-select skills for token budget" });
     options.push({ value: "health", label: "Health check" });
     options.push({ value: "optimize", label: "Token budget" });
     options.push({ value: "ref", label: "CLI reference" });

package/dist/interactive/menu.js

@@ -3,7 +3,7 @@ import chalk from "chalk";
 import { renderBanner } from "../utils/help.js";
 import { loadConfig } from "../utils/config.js";
 import { getProviders, clearProviderCache } from "../registry.js";
-import { getCliReference } from "../command-registry.js";
+import { getCliReference } from "../command-defs.js";
 import { AMBER, countInstalled, buildMenuOptions } from "./helpers.js";
 import { SKILL_CATEGORIES } from "./categories.js";
 import { browseByCategory } from "./browse.js";
@@ -97,6 +97,11 @@ export async function showInteractiveMenu(version) {
                 case "optimize":
                     await optimizeInteractive();
                     break;
+                case "curate": {
+                    const { curateCommand } = await import("../commands/curate.js");
+                    await curateCommand({});
+                    break;
+                }
                 case "ref":
                     p.note(getCliReference(), "CLI Reference");
                     break;

package/dist/interactive/optimize-flow.js

@@ -24,13 +24,13 @@ export async function optimizeInteractive() {
     const action = await p.select({
         message: "What next?",
         options: [
-            { value: "full", label: "Run full optimization report" },
+            { value: "doctor", label: "Run doctor report" },
             { value: "__back", label: "Back" },
         ],
     });
     handleCancel(action);
-    if (action === "full") {
-        const { optimizeCommand } = await import("../commands/optimize.js");
-        await optimizeCommand({ json: false });
+    if (action === "doctor") {
+        const { doctorCommand } = await import("../commands/doctor.js");
+        await doctorCommand({ json: false });
     }
 }

package/dist/mcp/install.d.ts

@@ -0,0 +1,10 @@
+/** Install an MCP server into the appropriate tool config. */
+export declare function installMcpServer(name: string, tool: "claude" | "cursor", cwd: string): {
+    installed: boolean;
+    path: string;
+    error?: string;
+};
+/** List MCP servers configured in a tool's config. */
+export declare function listConfiguredServers(tool: "claude" | "cursor", cwd: string): string[];
+/** Remove an MCP server from tool config. */
+export declare function removeMcpServer(name: string, tool: "claude" | "cursor", cwd: string): boolean;

package/dist/mcp/install.js

@@ -0,0 +1,109 @@
+import { existsSync, readFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { atomicWriteSync } from "../utils/atomic.js";
+import { getServerDef } from "./registry.js";
+/** Get the path to Claude Code's MCP config file. */
+function getClaudeMcpPath() {
+    return join(homedir(), ".claude.json");
+}
+/** Get the path to Cursor's MCP config file. */
+function getCursorMcpPath(cwd) {
+    return join(cwd, ".cursor", "mcp.json");
+}
+/** Read existing MCP config from a JSON file. */
+function readMcpConfig(filePath) {
+    if (!existsSync(filePath))
+        return { mcpServers: {} };
+    try {
+        const data = JSON.parse(readFileSync(filePath, "utf-8"));
+        return {
+            mcpServers: data.mcpServers ?? {},
+        };
+    }
+    catch {
+        return { mcpServers: {} };
+    }
+}
+/** Write MCP server config to a tool's config file. */
+function writeMcpServer(filePath, name, def) {
+    // Read existing config, preserving all other keys
+    let fullConfig = {};
+    if (existsSync(filePath)) {
+        try {
+            fullConfig = JSON.parse(readFileSync(filePath, "utf-8"));
+        }
+        catch {
+            fullConfig = {};
+        }
+    }
+    if (!fullConfig.mcpServers)
+        fullConfig.mcpServers = {};
+    const servers = fullConfig.mcpServers;
+    const entry = {
+        command: def.command,
+        args: def.args,
+    };
+    // Add env placeholders for keys that need configuration
+    if (def.envKeys && def.envKeys.length > 0) {
+        const env = {};
+        for (const key of def.envKeys) {
+            env[key] = process.env[key] ?? `<your-${key.toLowerCase().replace(/_/g, "-")}>`;
+        }
+        entry.env = env;
+    }
+    servers[name] = entry;
+    const dir = join(filePath, "..");
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    atomicWriteSync(filePath, JSON.stringify(fullConfig, null, 2));
+}
+/** Install an MCP server into the appropriate tool config. */
+export function installMcpServer(name, tool, cwd) {
+    const def = getServerDef(name);
+    if (!def) {
+        return {
+            installed: false,
+            path: "",
+            error: `Unknown MCP server: ${name}. Use 'arcana mcp list' to see available servers.`,
+        };
+    }
+    const filePath = tool === "claude" ? getClaudeMcpPath() : getCursorMcpPath(cwd);
+    // Check if already installed
+    const existing = readMcpConfig(filePath);
+    if (existing.mcpServers[name]) {
+        return { installed: true, path: filePath, error: `${name} already configured in ${filePath}` };
+    }
+    try {
+        writeMcpServer(filePath, name, def);
+        return { installed: true, path: filePath };
+    }
+    catch (err) {
+        return { installed: false, path: filePath, error: err instanceof Error ? err.message : "Write failed" };
+    }
+}
+/** List MCP servers configured in a tool's config. */
+export function listConfiguredServers(tool, cwd) {
+    const filePath = tool === "claude" ? getClaudeMcpPath() : getCursorMcpPath(cwd);
+    const config = readMcpConfig(filePath);
+    return Object.keys(config.mcpServers);
+}
+/** Remove an MCP server from tool config. */
+export function removeMcpServer(name, tool, cwd) {
+    const filePath = tool === "claude" ? getClaudeMcpPath() : getCursorMcpPath(cwd);
+    if (!existsSync(filePath))
+        return false;
+    let fullConfig;
+    try {
+        fullConfig = JSON.parse(readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        return false;
+    }
+    const servers = fullConfig.mcpServers;
+    if (!servers || !servers[name])
+        return false;
+    delete servers[name];
+    atomicWriteSync(filePath, JSON.stringify(fullConfig, null, 2));
+    return true;
+}

package/dist/mcp/registry.d.ts

@@ -0,0 +1,11 @@
+/** Built-in registry of recommended MCP servers. */
+export interface McpServerDef {
+    name: string;
+    description: string;
+    command: string;
+    args: string[];
+    envKeys?: string[];
+}
+export declare const MCP_REGISTRY: McpServerDef[];
+export declare function getServerDef(name: string): McpServerDef | undefined;
+export declare function listRegistry(): McpServerDef[];