ast-mcp-server 0.11.1 → 0.12.0

package/CHANGELOG.md

@@ -6,7 +6,40 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
-## [0.11.1] — local recovery candidate, pending release (2026-08-23)
+## [0.12.0] — local release candidate, pending release (2026-08-27)
+
+### Added
+
+- Diagnostic pagination can now include opt-in bounded aggregates computed from the complete normalized snapshot, with code and file dimensions capped at 20 entries and explicit coverage metadata.
+- Added an immutable tool capability catalog with MCP, batch, and agent projections derived from one source of truth, plus independent inventory, integration, canary, package, and documentation oracles.
+
+### Fixed
+
+- Canary validation continues to enforce the established public runtime gate payload while capability metadata is checked independently, preventing an internal catalog change from widening the public canary schema.
+
+### Release status
+
+- Version `0.12.0` remains pending its exact-tree two-runtime matrix, CI, and separately authorized delivery sequence. It has not been published, assigned to an npm dist-tag, tagged in Git, or released on GitHub.
+
+## [0.11.2] — published to `latest` and `next`, registry verified (2026-08-25)
+
+### Added
+
+- Added an explicit per-connection supervised compiler-worker mode that can recycle an idle compiler child while the local stdio parent remains connected; `in_process` remains the default and rollback, and TTL `0` disables recycling.
+- Added scoped Linux evidence on exact Node.js 22.13.0 and Node.js 24 for PSS reclamation, stable compiler fingerprints, SQLite reuse, bounded redaction, and parent-death cleanup without orphans.
+
+### Fixed
+
+- Compiler-worker startup now waits for `ready` before replaying initialization, preventing cross-channel settlement ordering from rejecting the first forwarded request as stale.
+- CLI project-discovery fixtures now create the external project directory before concurrent configuration writes, eliminating a nondeterministic `ENOENT` setup race.
+- Public-registry verification now copies the isolated runner's complete local runtime dependency closure, including the shared managed-skill validator, before launching it outside the source tree.
+- A deterministic copied-runner regression executes the isolated entry point and rejects any local import omitted by its production bootstrap.
+
+### Release status
+
+- npm published these immutable bytes under `next` with provenance and the expected Git commit. Public-registry consumer and release-preflight verification passed, `latest` and `next` both resolve to `0.11.2`, and the annotated `v0.11.2` tag plus GitHub Release resolve to the same release commit. This release supersedes immutable versions `0.11.0` and `0.11.1`, whose separate public-registry verification defects prevented promotion.
+
+## [0.11.1] — published to `next`, verification failed, not promoted (2026-08-23)
 
 ### Fixed
 
@@ -15,7 +48,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ### Release status
 
-- This local recovery candidate succeeds the immutable npm `0.11.0` publication, whose public-registry verification failed because two consumer validators still required skill bundle `4.4.0` while the published package correctly contained `4.5.0`. Version `0.11.0` remains under `next` only and must not be promoted, tagged, or released. Version `0.11.1` remains pending its exact-tree matrix, CI, and separately authorized delivery sequence; it has not been published or assigned to any dist-tag.
+- npm published these immutable bytes under `next` with provenance and the expected Git commit. Public-registry verification then failed because the isolated registry runner omitted its newly imported managed-skill validator module; `0.11.1` was never promoted to `latest`, tagged in Git, or released on GitHub.
 
 ## [0.11.0] — published to `next`, verification failed, not promoted (2026-08-23)
 

package/README.md

@@ -84,11 +84,23 @@ The included batch benchmark records a 50% reduction in model round-trips and a
 
 ## Supported environment and trust boundary
 
-The local `0.11.1` recovery candidate requires Node.js `>=22.13.0`; its evidence matrix targets exact Node.js 22.13.0 and the current Node.js 24 line. Published v0.10.0 retains its immutable historical Node.js 22.13.0/24 evidence. Managed setup-file publication additionally requires GNU coreutils 9.7 `mv` supporting `--update=none-fail`, `--exchange`, `--no-copy`, and `--no-target-directory`, GNU coreutils `ln -L -T`, procfs descriptor paths at `/proc/self/fd`, and `O_DIRECTORY`/`O_NOFOLLOW`. Other Linux architectures or systems without those filesystem primitives, macOS, and Windows remain unverified.
+The local `0.12.0` release candidate requires Node.js `>=22.13.0`; its evidence matrix targets exact Node.js 22.13.0 and the current Node.js 24 line. Published v0.11.2 retains its immutable historical Node.js 22.13.0/24 evidence. Managed setup-file publication additionally requires GNU coreutils 9.7 `mv` supporting `--update=none-fail`, `--exchange`, `--no-copy`, and `--no-target-directory`, GNU coreutils `ln -L -T`, procfs descriptor paths at `/proc/self/fd`, and `O_DIRECTORY`/`O_NOFOLLOW`. Other Linux architectures or systems without those filesystem primitives, macOS, and Windows remain unverified.
 
 This is a local stdio server. It runs with the invoking user's filesystem permissions, and clients may request any `project_root` that user can access. It does not provide HTTP authentication, sandboxing, tenant isolation, or a remote-service security boundary. Remote, untrusted, and multi-tenant operation is unsupported.
 
-In published v0.10.0 and the local `0.11.1` recovery candidate, an absent `AST_SYMBOL_INDEX_PERSISTENCE` or explicit `enabled` selects the private SQLite symbol-index cache. `disabled` is the immediate memory-only rollback. `canary` requires an explicit absolute normalized `AST_SYMBOL_INDEX_CACHE_ROOT`. Invalid policy or storage fails closed to compiler-authoritative memory reads with bounded path-free status.
+### Optional supervised compiler worker
+
+The compiler runs in process by default. Linux operators may explicitly keep the stdio parent connected while allowing an idle compiler child to exit and lazily respawn:
+
+```bash
+AST_COMPILER_WORKER_MODE=supervised ast-mcp-server
+```
+
+The parent waits for child readiness before replaying bounded initialization state. Requests and cancellation remain generation-affine; mutation history, live operation leases, and completion-critical apply work prevent unsafe recycling. Set `AST_COMPILER_WORKER_MODE=in_process` for the full rollback, or set `AST_COMPILER_WORKER_IDLE_TTL_MS=0` to retain the relay while disabling idle recycling.
+
+The scoped Linux canary passed on exact Node.js 22.13.0 and Node.js 24 with repeatable PSS reclamation, stable compiler fingerprints, unchanged SQLite reuse, bounded redacted diagnostics, and no orphan after parent death. This is one child per connection, not a shared daemon, pool, or new default. See [ADR 0014](docs/adr/0014-supervised-compiler-worker.md).
+
+In published v0.11.2 and the local `0.12.0` release candidate, an absent `AST_SYMBOL_INDEX_PERSISTENCE` or explicit `enabled` selects the private SQLite symbol-index cache. `disabled` is the immediate memory-only rollback. `canary` requires an explicit absolute normalized `AST_SYMBOL_INDEX_CACHE_ROOT`. Invalid policy or storage fails closed to compiler-authoritative memory reads with bounded path-free status.
 
 The default cache root is selected from `AST_SYMBOL_INDEX_CACHE_ROOT`, then `XDG_CACHE_HOME`, then `HOME`. Inspect or clear only derived cache artifacts through the bounded CLI:
 
@@ -333,6 +345,12 @@ Project-scoped tools accept `project_root`, either the project directory or an e
 
 Read results use project-relative paths, deterministic ordering, structured MCP output, and pagination where result sets can grow with the project.
 
+### Diagnostic aggregates
+
+Set `include_aggregates: true` on `ast_get_diagnostics` to summarize the complete normalized diagnostic snapshot independently of the selected raw page. The option defaults to `false`; disabled responses omit `aggregates` and keep the existing shape.
+
+Each code and file dimension returns at most 20 ranked groups. `groups.length + omitted_group_count = total_group_count`, and `sum(groups[*].count) = covered_diagnostic_count`. Code coverage plus `omitted_diagnostic_count` equals the diagnostic total; file coverage also adds `unfiled_diagnostic_count`. File groups contain normalized project-relative paths only, but may disclose a path that is absent from the selected raw page.
+
 `ast_explore` supports query, exact file, and exact symbol routes. Its default `summary` profile returns bounded reusable selectors; `context` adds selected source and `full` adds compiler references. Whole symbol clusters are admitted under the caller's `max_bytes` ceiling, so source, reference records, and call paths are never sliced. `omissions` classifies withheld components as `budget`, `incomplete`, or `untrusted`, and any requested omission keeps completeness false.
 
 Exact `file_path` plus `symbol_path` requests may opt into bounded static `call_spines`. Only fresh, exact, compiler-resolved invocation sites qualify; generic references, dynamic dispatch, and runtime behavior are not inferred. Absence of `call_spines` performs no call traversal. Every response still reports freshness, completeness, truncation, unresolved selectors, record limits, and canonical serialized-byte accounting. Use the primitive tools when a single exact operation is clearer or when preparing a mutation. See [ADR 0013](docs/adr/0013-ast-explore-presentation.md).
@@ -474,7 +492,19 @@ The server does **not** claim a filesystem-wide transaction:
 
 ## Development gates
 
+### Add or change an MCP tool
+
+Keep schemas, metadata, annotations, handlers, errors, and serialization in the tool module. Export
+one frozen descriptor, add it to the intentional order in `src/tools/catalog.ts`, and declare only
+static effect, batch, compatibility, and direct-format facts. Do not add request state, dynamic
+discovery, invocation-by-name, or a generic executor to the catalog.
+
+Update the independent `tools/list` inventories only after reviewing the complete wire metadata;
+they must not import or derive expectations from the catalog. Then run the focused catalog and MCP
+integration tests plus the runtime, package, and managed-skill gates below.
+
 ```bash
+yarn vitest run test/tool-catalog.test.ts test/mcp.integration.test.ts
 yarn format:check
 yarn lint
 yarn typecheck

package/SECURITY.md

@@ -11,7 +11,7 @@ Security fixes are provided for the exact version currently identified by the np
 | Earlier npm versions                        | No        |
 | Unpublished release candidates              | No        |
 
-This project supports trusted single-user local stdio use; the supported operating-system and architecture boundary remains Linux x64 only. The local `0.11.1` recovery candidate requires Node.js `>=22.13.0`, with evidence targeted at exact Node.js 22.13.0 and the governed Node.js 24 major. Published v0.10.0 retains its immutable Node.js 22.13.0/24 release matrix. Managed setup mutation requires GNU coreutils 9.7 `mv --update=none-fail --exchange --no-copy --no-target-directory`, GNU coreutils `ln -L -T`, and procfs descriptor-relative paths at `/proc/self/fd` with `O_DIRECTORY`/`O_NOFOLLOW`. The candidate's default SQLite cache also relies on Linux ownership, mode, no-follow, link-count and inode-identity checks; it does not defend against a malicious same-UID process. Other Linux architectures and systems without those primitives are unverified, as are macOS and Windows. Remote, untrusted, and multi-tenant use is outside the supported security boundary.
+This project supports trusted single-user local stdio use; the supported operating-system and architecture boundary remains Linux x64 only. The local `0.12.0` release candidate requires Node.js `>=22.13.0`, with evidence targeted at exact Node.js 22.13.0 and the governed Node.js 24 major. Published v0.11.2 retains its immutable Node.js 22.13.0/24 release matrix. Managed setup mutation requires GNU coreutils 9.7 `mv --update=none-fail --exchange --no-copy --no-target-directory`, GNU coreutils `ln -L -T`, and procfs descriptor-relative paths at `/proc/self/fd` with `O_DIRECTORY`/`O_NOFOLLOW`. The candidate's default SQLite cache also relies on Linux ownership, mode, no-follow, link-count and inode-identity checks; it does not defend against a malicious same-UID process. Other Linux architectures and systems without those primitives are unverified, as are macOS and Windows. Remote, untrusted, and multi-tenant use is outside the supported security boundary.
 
 ## Reporting a vulnerability
 

package/dist/batch/schema.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { toolCatalog } from "../tools/catalog.js";
 export const BATCH_SCHEMA_VERSION = 1;
 export const MAX_BATCH_STEPS = 50;
 export const MAX_BATCH_INVOCATIONS = 500;
@@ -8,22 +9,12 @@ export const MAX_BATCH_CONCURRENCY = 16;
 export const MAX_BATCH_INPUT_BYTES = 1024 * 1024;
 export const MAX_BATCH_OUTPUT_BYTES = 10 * 1024 * 1024;
 export const MAX_BATCH_CONTEXT_BYTES = 50 * 1024 * 1024;
-export const READ_BATCH_TOOLS = [
-    "ast_list_files",
-    "ast_get_outline",
-    "ast_get_symbol_source",
-    "ast_search_symbols",
-    "ast_find_references",
-    "ast_find_test_candidates",
-    "ast_explore",
-    "ast_get_diagnostics",
-];
-export const PREPARE_BATCH_TOOLS = [
-    "ast_rename_symbol",
-    "ast_replace_symbol_body",
-    "ast_scaffold_class",
-];
-export const BATCH_TOOLS = [...READ_BATCH_TOOLS, ...PREPARE_BATCH_TOOLS];
+export const READ_BATCH_TOOLS = toolCatalog.batch.read;
+export const PREPARE_BATCH_TOOLS = toolCatalog.batch.prepare;
+export const BATCH_TOOLS = Object.freeze([
+    ...READ_BATCH_TOOLS,
+    ...PREPARE_BATCH_TOOLS,
+]);
 const BatchToolSchema = z.enum(BATCH_TOOLS);
 const BatchStepSchema = z
     .object({

package/dist/compiler-worker-entry.js

@@ -0,0 +1,51 @@
+import fs from "node:fs";
+import { createInterface } from "node:readline";
+import { PassThrough } from "node:stream";
+import { fileURLToPath } from "node:url";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { decodeCompilerWorkerEnvelope } from "./services/compiler-worker-protocol.js";
+async function runDefaultCompilerRuntime(input = process.stdin) {
+    return (await import("./worker-runtime.js")).runStdioServer({
+        transport: new StdioServerTransport(input, process.stdout),
+    });
+}
+export function runCompilerWorkerChild(runRuntime = runDefaultCompilerRuntime) {
+    return runRuntime();
+}
+// prettier-ignore
+export function installPrivateControl(runtime, input) {
+    let sequence = 0, generation = 0, writeSequence = 0;
+    const send = (generation, type, payload) => process.send?.({ v: 1, generation, sequence: ++sequence, type, payload });
+    const arm = (handle) => { const force = () => { if (handle.snapshot?.().completion_critical_operations > 0)
+        setTimeout(force, 50).unref();
+    else
+        process.exit(1); }; setTimeout(force, (handle.shutdownGraceMs ?? 10_000) + 2_000).unref(); };
+    const shutdown = (handle, trigger) => { if (trigger === "parent_exit")
+        arm(handle); void handle.shutdown(trigger).finally(() => process.disconnect()); };
+    process.on("message", (message) => { const decoded = decodeCompilerWorkerEnvelope(JSON.stringify(message)); if (!decoded.ok)
+        return; if (decoded.value.type === "handshake") {
+        generation = decoded.value.generation;
+        void runtime.then(() => send(generation, "ready", {}));
+    } if (decoded.value.type === "snapshot")
+        void runtime.then((handle) => send(generation, "snapshot", (handle.snapshot?.() ?? {}))); if (decoded.value.type === "shutdown") {
+        const trigger = decoded.value.payload.trigger === "parent_exit" ? "parent_exit" : "requested";
+        void runtime.then((handle) => shutdown(handle, trigger));
+    } });
+    if (input) {
+        const lines = createInterface({ input: process.stdin });
+        lines.on("line", (line) => input.write(`${line}\n`, () => send(generation, "settled", { write_sequence: ++writeSequence })));
+        lines.once("close", () => input.end());
+    }
+    process.once("disconnect", () => void runtime.then((handle) => { arm(handle); void handle.shutdown("parent_exit").then(() => process.exit(0), () => process.exit(1)); }));
+}
+const entry = process.argv[1];
+if (entry && fs.realpathSync(entry) === fs.realpathSync(fileURLToPath(import.meta.url))) {
+    const input = process.send ? new PassThrough() : undefined;
+    const runtime = input ? runDefaultCompilerRuntime(input) : runCompilerWorkerChild();
+    if (process.send)
+        installPrivateControl(runtime, input);
+    runtime.catch(() => {
+        process.stderr.write("Fatal compiler worker startup error.\n");
+        process.exit(1);
+    });
+}

package/dist/index.js

@@ -1,131 +1,31 @@
 #!/usr/bin/env node
 import fs from "node:fs";
-import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { createServer } from "./server.js";
-import { beginProjectShutdown, closeDrainedProjectSessions, getProjectRuntimeShutdownSnapshot, prepareProjectRuntimeForStartup, waitForProjectCompletionCriticalOperationsToDrain, waitForProjectOperationsToDrain, } from "./services/project.js";
-import { RuntimeActivityTracker } from "./services/runtime-activity.js";
 import { readRuntimePolicy } from "./services/runtime-policy.js";
-import { emitIncompleteShutdownEvent, ShutdownCoordinator, } from "./services/shutdown.js";
-function emitShutdownFailureEvent() {
-    process.stderr.write(`${JSON.stringify({ event: "shutdown_failed", version: 1 })}\n`);
+export async function loadRuntimeModule(policy, loaders) {
+    return {
+        mode: policy.compilerWorkerMode,
+        module: await (policy.compilerWorkerMode === "supervised"
+            ? loaders.supervised()
+            : loaders.inProcess()),
+    };
 }
 export async function runStdioServer(options = {}) {
-    if (options.server && !options.runtimeActivity) {
-        throw new Error("An injected MCP server requires its runtime activity tracker.");
-    }
-    prepareProjectRuntimeForStartup();
-    const runtimeActivity = options.runtimeActivity ?? new RuntimeActivityTracker();
-    runtimeActivity.prepareForStartup();
-    const server = options.server ?? createServer({ runtimeActivity });
-    const transport = options.transport ?? new StdioServerTransport();
-    const send = transport.send.bind(transport);
-    transport.send = (message, sendOptions) => runtimeActivity.trackSend(() => send(message, sendOptions));
-    const runtimePolicy = options.runtimePolicy ?? readRuntimePolicy();
-    const installProcessHandlers = options.installProcessHandlers ?? true;
-    const exit = options.exit ?? ((code) => process.exit(code));
-    const protocol = server.server;
-    const previousTransportClose = protocol.onclose;
-    let listenersInstalled = false;
-    let terminalHandlerInstalled = false;
-    const onSigint = () => requestFromRuntime("sigint");
-    const onSigterm = () => requestFromRuntime("sigterm");
-    const onStdinEnd = () => requestFromRuntime("stdin_eof");
-    const onStdinClose = () => requestFromRuntime("stdin_eof");
-    const onTransportClose = () => {
-        previousTransportClose?.();
-        requestFromRuntime("transport_closed");
-    };
-    const removeLifecycleListeners = () => {
-        if (listenersInstalled) {
-            process.off("SIGINT", onSigint);
-            process.off("SIGTERM", onSigterm);
-            process.stdin.off("end", onStdinEnd);
-            process.stdin.off("close", onStdinClose);
-            listenersInstalled = false;
-        }
-        if (protocol.onclose === onTransportClose)
-            protocol.onclose = previousTransportClose;
-    };
-    const coordinator = new ShutdownCoordinator({
-        drainTimeoutMs: runtimePolicy.shutdownDrainTimeoutMs,
-        stopAdmissionAndCancel: () => {
-            runtimeActivity.beginShutdown();
-            return beginProjectShutdown();
-        },
-        getDrainSnapshot: getProjectRuntimeShutdownSnapshot,
-        waitForDrain: async () => {
-            await Promise.all([waitForProjectOperationsToDrain(), runtimeActivity.waitForIdle()]);
-        },
-        waitForCompletionCriticalOperationsToDrain: waitForProjectCompletionCriticalOperationsToDrain,
-        closeMcp: async () => {
-            await server.close();
-        },
-        closeProjects: closeDrainedProjectSessions,
-        emitIncompleteShutdown: emitIncompleteShutdownEvent,
-        onCompletionCriticalWait: options.onCompletionCriticalWait,
-    });
-    let lifecycleCompletion;
-    function requestShutdown(trigger) {
-        lifecycleCompletion ??= coordinator.shutdown(trigger).finally(removeLifecycleListeners);
-        return lifecycleCompletion;
-    }
-    function requestFromRuntime(trigger) {
-        try {
-            options.onRuntimeTrigger?.(trigger);
-        }
-        catch {
-            // Runtime observation is non-authoritative and must never interrupt shutdown.
-        }
-        const completion = requestShutdown(trigger);
-        if (terminalHandlerInstalled)
-            return;
-        terminalHandlerInstalled = true;
-        void completion
-            .then((result) => {
-            if (result.state === "forced_noncritical")
-                exit(1);
-        })
-            .catch(() => {
-            emitShutdownFailureEvent();
-            exit(1);
-        });
-    }
-    protocol.onclose = onTransportClose;
-    if (installProcessHandlers) {
-        process.on("SIGINT", onSigint);
-        process.on("SIGTERM", onSigterm);
-        process.stdin.once("end", onStdinEnd);
-        process.stdin.once("close", onStdinClose);
-        listenersInstalled = true;
-    }
-    try {
-        await server.connect(transport);
-    }
-    catch (error) {
-        await requestShutdown("requested").catch(() => undefined);
-        throw error;
-    }
-    if (options.logStartup ?? true)
-        process.stderr.write("ast-mcp-server running over stdio.\n");
-    return Object.freeze({
-        shutdown: (trigger = "requested") => requestShutdown(trigger),
-    });
+    return (await import("./worker-runtime.js")).runStdioServer(options);
 }
-function isMainModule() {
-    const entry = process.argv[1];
-    if (!entry)
-        return false;
-    try {
-        return fs.realpathSync(entry) === fs.realpathSync(fileURLToPath(import.meta.url));
-    }
-    catch {
-        return path.resolve(entry) === path.resolve(fileURLToPath(import.meta.url));
-    }
+async function runConfiguredStdioServer() {
+    const policy = readRuntimePolicy();
+    const selected = await loadRuntimeModule(policy, {
+        inProcess: async () => ({ run: () => runStdioServer({ runtimePolicy: policy }) }),
+        supervised: async () => ({
+            run: () => import("./services/compiler-worker-host.js").then((host) => host.runSupervisedStdioServer()),
+        }),
+    });
+    await selected.module.run();
 }
-if (isMainModule()) {
-    runStdioServer().catch(() => {
+const entry = process.argv[1];
+if (entry && fs.realpathSync(entry) === fs.realpathSync(fileURLToPath(import.meta.url))) {
+    runConfiguredStdioServer().catch(() => {
         process.stderr.write("Fatal ast-mcp-server startup error.\n");
         process.exit(1);
     });

package/dist/server.js

@@ -1,22 +1,7 @@
 import { createRequire } from "node:module";
 import { McpServer, } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { PublicOperationalError } from "./services/public-errors.js";
-import { registerApplyOperation } from "./tools/apply_operation.js";
-import { registerFindReferences } from "./tools/find_references.js";
-import { registerFindTestCandidates } from "./tools/find_test_candidates.js";
-import { registerGetDiagnostics } from "./tools/get_diagnostics.js";
-import { registerGetFile } from "./tools/get_file.js";
-import { registerGetImpact } from "./tools/get_impact.js";
-import { registerGetOperationPreview } from "./tools/get_operation_preview.js";
-import { registerGetOutline } from "./tools/get_outline.js";
-import { registerGetProjectStatus } from "./tools/get_project_status.js";
-import { registerGetSymbolSource } from "./tools/get_symbol_source.js";
-import { registerListFiles } from "./tools/list_files.js";
-import { registerRenameSymbol } from "./tools/rename_symbol.js";
-import { registerReplaceSymbolBody } from "./tools/replace_symbol_body.js";
-import { registerScaffoldClass } from "./tools/scaffold_class.js";
-import { registerSearchSymbols } from "./tools/search_symbols.js";
-import { registerExplore } from "./tools/explore.js";
+import { toolCatalog } from "./tools/catalog.js";
 import { createToolErrorContext, errorResult } from "./tools/result.js";
 const packageMetadata = createRequire(import.meta.url)("../package.json");
 export const PACKAGE_VERSION = packageMetadata.version;
@@ -40,21 +25,6 @@ export function createServer(options = {}) {
     });
     if (options.runtimeActivity)
         installRuntimeActivityTracking(server, options.runtimeActivity);
-    registerListFiles(server);
-    registerGetProjectStatus(server);
-    registerExplore(server);
-    registerGetOutline(server);
-    registerGetSymbolSource(server);
-    registerSearchSymbols(server);
-    registerFindReferences(server);
-    registerGetImpact(server);
-    registerFindTestCandidates(server);
-    registerGetDiagnostics(server);
-    registerGetFile(server);
-    registerRenameSymbol(server);
-    registerReplaceSymbolBody(server);
-    registerScaffoldClass(server);
-    registerGetOperationPreview(server);
-    registerApplyOperation(server);
+    toolCatalog.registerAll(server);
     return server;
 }

package/dist/services/agent-targets.js

@@ -1,18 +1,6 @@
+import { toolCatalog } from "../tools/catalog.js";
 export const MCP_SERVER_NAME = "ast";
-const EXPECTED_TOOLS = [
-    "ast_list_files",
-    "ast_get_outline",
-    "ast_get_symbol_source",
-    "ast_search_symbols",
-    "ast_find_references",
-    "ast_find_test_candidates",
-    "ast_get_diagnostics",
-    "ast_rename_symbol",
-    "ast_replace_symbol_body",
-    "ast_scaffold_class",
-    "ast_get_operation_preview",
-    "ast_apply_operation",
-];
+const EXPECTED_TOOLS = toolCatalog.compatibility.required;
 function semver(value) {
     const match = value.match(/(?:^|\s|v)(\d+)\.(\d+)\.(\d+)(?=\s|$|[-+()]|\.(?:\s|$))/);
     return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : undefined;