ast-mcp-server 0.11.2 → 0.13.0

package/dist/tools/catalog.js

@@ -0,0 +1,83 @@
+import { toolDescriptor as applyOperation } from "./apply_operation.js";
+import { toolDescriptor as explore } from "./explore.js";
+import { toolDescriptor as findReferences } from "./find_references.js";
+import { toolDescriptor as findTestCandidates } from "./find_test_candidates.js";
+import { toolDescriptor as getDiagnostics } from "./get_diagnostics.js";
+import { toolDescriptor as getFile } from "./get_file.js";
+import { toolDescriptor as getImpact } from "./get_impact.js";
+import { toolDescriptor as getOperationPreview } from "./get_operation_preview.js";
+import { toolDescriptor as getOutline } from "./get_outline.js";
+import { toolDescriptor as getProjectStatus } from "./get_project_status.js";
+import { toolDescriptor as getSymbolSource } from "./get_symbol_source.js";
+import { toolDescriptor as listFiles } from "./list_files.js";
+import { toolDescriptor as renameSymbol } from "./rename_symbol.js";
+import { toolDescriptor as replaceSymbolBody } from "./replace_symbol_body.js";
+import { toolDescriptor as scaffoldClass } from "./scaffold_class.js";
+import { toolDescriptor as searchSymbols } from "./search_symbols.js";
+function validateDescriptor(descriptor) {
+    const formats = descriptor.directOutputFormats.join(",");
+    const valid = (descriptor.effect === "read" &&
+        (descriptor.batch === "none" || descriptor.batch === "read") &&
+        (formats === "json" || formats === "json,toon")) ||
+        (descriptor.effect === "prepare" && descriptor.batch === "prepare" && formats === "json") ||
+        (descriptor.effect === "apply" && descriptor.batch === "none" && formats === "json");
+    if (!valid)
+        throw new Error(`Contradictory capability descriptor: ${descriptor.name}`);
+}
+export function defineToolCatalog(input) {
+    const seen = new Set();
+    for (const descriptor of input) {
+        if (seen.has(descriptor.name))
+            throw new Error(`Duplicate tool name: ${descriptor.name}`);
+        seen.add(descriptor.name);
+        validateDescriptor(descriptor);
+    }
+    const descriptors = Object.freeze(input.map((descriptor) => Object.freeze({
+        ...descriptor,
+        directOutputFormats: Object.freeze([...descriptor.directOutputFormats]),
+    })));
+    const names = (predicate) => Object.freeze(descriptors.filter(predicate).map(({ name }) => name));
+    return Object.freeze({
+        descriptors,
+        batch: Object.freeze({
+            read: names((item) => item.batch === "read"),
+            prepare: names((item) => item.batch === "prepare"),
+            excluded: names((item) => item.batch === "none"),
+        }),
+        compatibility: Object.freeze({
+            required: names((item) => item.compatibility === "required"),
+            optional: names((item) => item.compatibility === "optional"),
+        }),
+        byEffect: Object.freeze({
+            read: names((item) => item.effect === "read"),
+            prepare: names((item) => item.effect === "prepare"),
+            apply: names((item) => item.effect === "apply"),
+        }),
+        directToon: names((item) => item.directOutputFormats.length === 2),
+        registerAll(server, options = {}) {
+            for (const descriptor of descriptors) {
+                if (options.denyApply === true && descriptor.effect === "apply")
+                    continue;
+                descriptor.register(server);
+            }
+        },
+    });
+}
+export const toolCatalog = defineToolCatalog([
+    listFiles,
+    getProjectStatus,
+    explore,
+    getOutline,
+    getSymbolSource,
+    searchSymbols,
+    findReferences,
+    getImpact,
+    findTestCandidates,
+    getDiagnostics,
+    getFile,
+    renameSymbol,
+    replaceSymbolBody,
+    scaffoldClass,
+    getOperationPreview,
+    applyOperation,
+]);

package/dist/tools/explore.js

@@ -8,6 +8,7 @@ import { createRequestContext } from "../services/request-context.js";
 import { FRESHNESS_CAUSES, SNAPSHOT_STATES, TRUNCATION_REASONS, } from "../services/read-contracts.js";
 import { createToolErrorContext, errorResult, structuredResult } from "./result.js";
 import { RelationshipEndpointSchema } from "./relationship-schema.js";
+const TOOL_NAME = "ast_explore";
 const ExploreDetailSchema = z.enum(["selectors", "summary", "context", "full"]).default("summary");
 const ReferenceDetailSchema = z.enum(["locations", "context"]).default("locations");
 const CallSpinesInputSchema = z.object({
@@ -200,7 +201,7 @@ const ExploreOutputSchema = z.object({
     }),
 });
 export function registerExplore(server) {
-    server.registerTool("ast_explore", {
+    server.registerTool(TOOL_NAME, {
         title: "Explore project context",
         description: "Composes bounded structural search, exact selectors, source evidence and compiler references without weakening the primitive AST tools. Returns bounded session freshness metadata for fresh, pending, stale, rebuilding or degraded state.",
         inputSchema: ExploreInputSchema,
@@ -241,7 +242,9 @@ export function registerExplore(server) {
             return structuredResult(ExploreOutputSchema.parse(output));
         }
         catch (error) {
-            return errorResult(error, createToolErrorContext("ast_explore", project_root));
+            return errorResult(error, createToolErrorContext(TOOL_NAME, project_root));
         }
     });
 }
+// prettier-ignore
+export const toolDescriptor = Object.freeze({ name: TOOL_NAME, register: registerExplore, compatibility: "optional", effect: "read", batch: "read", directOutputFormats: Object.freeze(["json"]) });

package/dist/tools/find_references.js

@@ -4,6 +4,7 @@ import { findDeclarationByName, getSourceFileOrThrow, withProject } from "../ser
 import { collectSymbolReferences } from "../services/references.js";
 import { createRequestContext } from "../services/request-context.js";
 import { createToolErrorContext, errorResult, formattedResult, ToolOutputFormatInputSchema, } from "./result.js";
+const TOOL_NAME = "ast_find_references";
 const ReferenceDetailSchema = z.enum(["locations", "context"]).default("locations");
 const AstFindReferencesInputSchema = z.object({
     project_root: z
@@ -44,7 +45,7 @@ const ReferenceOutputSchemas = {
     }),
 };
 export function registerFindReferences(server) {
-    server.registerTool("ast_find_references", {
+    server.registerTool(TOOL_NAME, {
         title: "Find semantic symbol references",
         description: "Finds type-resolved references and returns bounded project-relative locations, including declaration impact by default.",
         inputSchema: AstFindReferencesInputSchema,
@@ -76,7 +77,9 @@ export function registerFindReferences(server) {
             return formattedResult(outputSchema, structuredContent, output_format);
         }
         catch (error) {
-            return errorResult(error, createToolErrorContext("ast_find_references", project_root));
+            return errorResult(error, createToolErrorContext(TOOL_NAME, project_root));
         }
     });
 }
+// prettier-ignore
+export const toolDescriptor = Object.freeze({ name: TOOL_NAME, register: registerFindReferences, compatibility: "required", effect: "read", batch: "read", directOutputFormats: Object.freeze(["json", "toon"]) });

package/dist/tools/find_test_candidates.js

@@ -7,6 +7,7 @@ import { createRequestContext } from "../services/request-context.js";
 import { findTestCandidates, MAX_TEST_CANDIDATE_CONVENTION_ITEMS, MAX_TEST_CANDIDATE_CONVENTION_LENGTH, TEST_CANDIDATE_CONFIDENCES, TEST_CANDIDATE_REASONS, } from "../services/test-candidates.js";
 import { FreshnessSchema, RelationshipEdgeSchema, RelationshipEndpointSchema, } from "./relationship-schema.js";
 import { createToolErrorContext, errorResult, structuredResult } from "./result.js";
+const TOOL_NAME = "ast_find_test_candidates";
 const ConventionSchema = z
     .array(z.string().min(1).max(MAX_TEST_CANDIDATE_CONVENTION_LENGTH))
     .max(MAX_TEST_CANDIDATE_CONVENTION_ITEMS)
@@ -59,7 +60,7 @@ const FindTestCandidatesOutputSchema = z.object({
     }),
 });
 export function registerFindTestCandidates(server) {
-    server.registerTool("ast_find_test_candidates", {
+    server.registerTool(TOOL_NAME, {
         title: "Find compiler-backed affected test candidates",
         description: "Finds deterministic affected test candidates from fresh, complete incoming compiler relationships. Returns bounded whole-candidate proofs and never executes tests or prepares mutations.",
         inputSchema: AstFindTestCandidatesInputSchema,
@@ -118,7 +119,9 @@ export function registerFindTestCandidates(server) {
             return structuredResult(FindTestCandidatesOutputSchema.parse(result));
         }
         catch (error) {
-            return errorResult(error, createToolErrorContext("ast_find_test_candidates", project_root));
+            return errorResult(error, createToolErrorContext(TOOL_NAME, project_root));
         }
     });
 }
+// prettier-ignore
+export const toolDescriptor = Object.freeze({ name: TOOL_NAME, register: registerFindTestCandidates, compatibility: "required", effect: "read", batch: "read", directOutputFormats: Object.freeze(["json"]) });

package/dist/tools/get_diagnostics.js

@@ -1,9 +1,10 @@
 import { z } from "zod";
-import { normalizeDiagnostic } from "../services/diagnostics.js";
+import { buildDiagnosticAggregates, DIAGNOSTIC_AGGREGATE_GROUP_LIMIT, normalizeDiagnostic, } from "../services/diagnostics.js";
 import { PaginationInputSchema, PaginationOutputSchema, paginate } from "../services/pagination.js";
 import { getSourceFileOrThrow, withProject } from "../services/project.js";
 import { createRequestContext } from "../services/request-context.js";
 import { createToolErrorContext, errorResult, formattedResult, ToolOutputFormatInputSchema, } from "./result.js";
+const TOOL_NAME = "ast_get_diagnostics";
 const DiagnosticSchema = z.object({
     code: z.number().int(),
     category: z.string(),
@@ -12,6 +13,29 @@ const DiagnosticSchema = z.object({
     column: z.number().int().positive().nullable(),
     message: z.string(),
 });
+const AggregateMetadataSchema = {
+    total_group_count: z.number().int().safe().min(0),
+    omitted_group_count: z.number().int().safe().min(0),
+    covered_diagnostic_count: z.number().int().safe().min(0),
+    omitted_diagnostic_count: z.number().int().safe().min(0),
+    truncated: z.boolean(),
+};
+const DiagnosticAggregatesSchema = z.object({
+    group_limit: z.literal(DIAGNOSTIC_AGGREGATE_GROUP_LIMIT),
+    codes: z.object({
+        groups: z
+            .array(z.object({ code: z.number().int().safe(), count: z.number().int().safe().positive() }))
+            .max(DIAGNOSTIC_AGGREGATE_GROUP_LIMIT),
+        ...AggregateMetadataSchema,
+    }),
+    files: z.object({
+        groups: z
+            .array(z.object({ file: z.string(), count: z.number().int().safe().positive() }))
+            .max(DIAGNOSTIC_AGGREGATE_GROUP_LIMIT),
+        ...AggregateMetadataSchema,
+        unfiled_diagnostic_count: z.number().int().safe().min(0),
+    }),
+});
 const AstGetDiagnosticsInputSchema = z.object({
     project_root: z
         .string()
@@ -20,6 +44,7 @@ const AstGetDiagnosticsInputSchema = z.object({
         .string()
         .optional()
         .describe("Optional project-relative or absolute file path. Omit for project diagnostics."),
+    include_aggregates: z.boolean().optional().default(false),
     ...ToolOutputFormatInputSchema,
     ...PaginationInputSchema,
 });
@@ -28,10 +53,11 @@ const AstGetDiagnosticsOutputSchema = z.object({
     error_count: z.number().int().min(0),
     warning_count: z.number().int().min(0),
     duration_ms: z.number().min(0),
+    aggregates: DiagnosticAggregatesSchema.optional(),
     ...PaginationOutputSchema,
 });
 export function registerGetDiagnostics(server) {
-    server.registerTool("ast_get_diagnostics", {
+    server.registerTool(TOOL_NAME, {
         title: "Get TypeScript diagnostics",
         description: "Returns bounded normalized TypeScript diagnostics for a project or one source file. Existing errors are preserved as evidence for write-operation delta checks.",
         inputSchema: AstGetDiagnosticsInputSchema,
@@ -41,7 +67,7 @@ export function registerGetDiagnostics(server) {
             idempotentHint: true,
             openWorldHint: false,
         },
-    }, async ({ project_root, file_path, output_format, offset, limit }, extra) => {
+    }, async ({ project_root, file_path, include_aggregates, output_format, offset, limit }, extra) => {
         const requestContext = createRequestContext(extra.signal);
         try {
             const structuredContent = await withProject(project_root, ({ project, projectRoot }, operationContext) => {
@@ -52,6 +78,9 @@ export function registerGetDiagnostics(server) {
                 const normalized = diagnostics
                     .map((diagnostic) => normalizeDiagnostic(diagnostic, projectRoot, operationContext))
                     .sort((left, right) => `${left.file ?? ""}:${left.line ?? 0}:${left.column ?? 0}:${left.code}`.localeCompare(`${right.file ?? ""}:${right.line ?? 0}:${right.column ?? 0}:${right.code}`));
+                const aggregates = include_aggregates
+                    ? buildDiagnosticAggregates(normalized, operationContext)
+                    : undefined;
                 const page = paginate(normalized, offset, limit);
                 const { items, ...metadata } = page;
                 return {
@@ -61,13 +90,16 @@ export function registerGetDiagnostics(server) {
                     warning_count: normalized.filter((diagnostic) => diagnostic.category === "Warning")
                         .length,
                     duration_ms: performance.now() - startedAt,
+                    ...(aggregates ? { aggregates } : {}),
                     ...metadata,
                 };
             }, requestContext);
             return formattedResult(AstGetDiagnosticsOutputSchema, structuredContent, output_format);
         }
         catch (error) {
-            return errorResult(error, createToolErrorContext("ast_get_diagnostics", project_root));
+            return errorResult(error, createToolErrorContext(TOOL_NAME, project_root));
         }
     });
 }
+// prettier-ignore
+export const toolDescriptor = Object.freeze({ name: TOOL_NAME, register: registerGetDiagnostics, compatibility: "required", effect: "read", batch: "read", directOutputFormats: Object.freeze(["json", "toon"]) });

package/dist/tools/get_file.js

@@ -5,6 +5,7 @@ import { getSourceFileOrThrow, withProject } from "../services/project.js";
 import { createRequestContext } from "../services/request-context.js";
 import { FRESHNESS_CAUSES, SNAPSHOT_STATES } from "../services/read-contracts.js";
 import { createToolErrorContext, errorResult, structuredResult } from "./result.js";
+const TOOL_NAME = "ast_get_file";
 const AstGetFileInputSchema = z.object({
     project_root: z
         .string()
@@ -60,7 +61,7 @@ const AstGetFileOutputSchema = z.object({
     symbols: z.array(OutlineSymbolSchema).optional(),
 });
 export function registerGetFile(server) {
-    server.registerTool("ast_get_file", {
+    server.registerTool(TOOL_NAME, {
         title: "Get bounded source file",
         description: "Returns exact bounded source lines for one TypeScript/JavaScript file, or body-free symbols when symbols_only is true. Read-only; file snapshot freshness and project freshness are reported separately from compiler diagnostics.",
         inputSchema: AstGetFileInputSchema,
@@ -101,7 +102,9 @@ export function registerGetFile(server) {
             return structuredResult(structuredContent);
         }
         catch (error) {
-            return errorResult(error, createToolErrorContext("ast_get_file", project_root));
+            return errorResult(error, createToolErrorContext(TOOL_NAME, project_root));
         }
     });
 }
+// prettier-ignore
+export const toolDescriptor = Object.freeze({ name: TOOL_NAME, register: registerGetFile, compatibility: "optional", effect: "read", batch: "none", directOutputFormats: Object.freeze(["json"]) });

package/dist/tools/get_impact.js

@@ -6,6 +6,7 @@ import { createRequestContext } from "../services/request-context.js";
 import { RELATIONSHIP_EDGE_KINDS } from "../services/relationships.js";
 import { FreshnessSchema, RelationshipEdgeSchema, RelationshipEndpointSchema, } from "./relationship-schema.js";
 import { createToolErrorContext, errorResult, formattedResult, ToolOutputFormatInputSchema, } from "./result.js";
+const TOOL_NAME = "ast_get_impact";
 const AstGetImpactInputSchema = z.object({
     project_root: z
         .string()
@@ -68,7 +69,7 @@ const ImpactOutputSchema = z.object({
     freshness: FreshnessSchema,
 });
 export function registerGetImpact(server) {
-    server.registerTool("ast_get_impact", {
+    server.registerTool(TOOL_NAME, {
         title: "Get bounded compiler-backed impact",
         description: "Traverses exact compiler-backed relationships around a symbol with explicit direction, depth, node and edge budgets. Returns bounded session freshness metadata and fails closed when exact relationships are not fresh. Read-only evidence only; it never prepares or applies mutations.",
         inputSchema: AstGetImpactInputSchema,
@@ -101,7 +102,9 @@ export function registerGetImpact(server) {
             return formattedResult(ImpactOutputSchema, structuredContent, output_format);
         }
         catch (error) {
-            return errorResult(error, createToolErrorContext("ast_get_impact", project_root));
+            return errorResult(error, createToolErrorContext(TOOL_NAME, project_root));
         }
     });
 }
+// prettier-ignore
+export const toolDescriptor = Object.freeze({ name: TOOL_NAME, register: registerGetImpact, compatibility: "optional", effect: "read", batch: "none", directOutputFormats: Object.freeze(["json", "toon"]) });

package/dist/tools/get_operation_preview.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { getOperationPreview } from "../services/operations.js";
 import { createRequestContext } from "../services/request-context.js";
 import { createToolErrorContext, errorResult, structuredResult } from "./result.js";
+const TOOL_NAME = "ast_get_operation_preview";
 const AstGetOperationPreviewInputSchema = z.object({
     operation_id: z.string().uuid(),
     file: z.string().optional().describe("Optional affected file path to retrieve only its diff."),
@@ -12,7 +13,7 @@ const AstGetOperationPreviewOutputSchema = z.object({
     files: z.array(z.object({ file: z.string(), diff: z.string() })),
 });
 export function registerGetOperationPreview(server) {
-    server.registerTool("ast_get_operation_preview", {
+    server.registerTool(TOOL_NAME, {
         title: "Get complete prepared-operation diff",
         description: "Retrieves exact unified diffs retained for a prepared operation, optionally one affected file at a time.",
         inputSchema: AstGetOperationPreviewInputSchema,
@@ -30,7 +31,9 @@ export function registerGetOperationPreview(server) {
             return structuredResult(output);
         }
         catch (error) {
-            return errorResult(error, createToolErrorContext("ast_get_operation_preview"));
+            return errorResult(error, createToolErrorContext(TOOL_NAME));
         }
     });
 }
+// prettier-ignore
+export const toolDescriptor = Object.freeze({ name: TOOL_NAME, register: registerGetOperationPreview, compatibility: "required", effect: "read", batch: "none", directOutputFormats: Object.freeze(["json"]) });

package/dist/tools/get_outline.js

@@ -4,6 +4,7 @@ import { buildFileOutline } from "../services/outline.js";
 import { getSourceFileOrThrow, withProject } from "../services/project.js";
 import { createRequestContext } from "../services/request-context.js";
 import { createToolErrorContext, errorResult, structuredResult } from "./result.js";
+const TOOL_NAME = "ast_get_outline";
 const AstGetOutlineInputSchema = z.object({
     project_root: z
         .string()
@@ -28,7 +29,7 @@ const AstGetOutlineOutputSchema = z.object({
     symbols: z.array(OutlineSymbolSchema).optional(),
 });
 export function registerGetOutline(server) {
-    server.registerTool("ast_get_outline", {
+    server.registerTool(TOOL_NAME, {
         title: "Get compact file outline",
         description: "Returns body-free declaration signatures for one TypeScript/JavaScript file. Detailed symbol metadata is opt-in because it duplicates signature text.",
         inputSchema: AstGetOutlineInputSchema,
@@ -54,7 +55,9 @@ export function registerGetOutline(server) {
             return structuredResult(structuredContent);
         }
         catch (error) {
-            return errorResult(error, createToolErrorContext("ast_get_outline", project_root));
+            return errorResult(error, createToolErrorContext(TOOL_NAME, project_root));
         }
     });
 }
+// prettier-ignore
+export const toolDescriptor = Object.freeze({ name: TOOL_NAME, register: registerGetOutline, compatibility: "required", effect: "read", batch: "read", directOutputFormats: Object.freeze(["json"]) });

package/dist/tools/get_project_status.js

@@ -3,6 +3,7 @@ import { FRESHNESS_CAUSES, SNAPSHOT_STATES, TRUNCATION_REASONS, } from "../servi
 import { getProjectStatus } from "../services/project.js";
 import { createRequestContext } from "../services/request-context.js";
 import { createToolErrorContext, errorResult, structuredResult } from "./result.js";
+const TOOL_NAME = "ast_get_project_status";
 const AstGetProjectStatusInputSchema = z.object({
     project_root: z
         .string()
@@ -113,7 +114,7 @@ const ProjectStatusOutputSchema = z.object({
     index_observability: IndexObservabilitySchema,
 });
 export function registerGetProjectStatus(server) {
-    server.registerTool("ast_get_project_status", {
+    server.registerTool(TOOL_NAME, {
         title: "Get project freshness status",
         description: "Returns bounded, read-only compiler freshness and project status without exposing filesystem identities or credentials.",
         inputSchema: AstGetProjectStatusInputSchema,
@@ -131,7 +132,9 @@ export function registerGetProjectStatus(server) {
             return structuredResult({ ...output });
         }
         catch (error) {
-            return errorResult(error, createToolErrorContext("ast_get_project_status", project_root));
+            return errorResult(error, createToolErrorContext(TOOL_NAME, project_root));
         }
     });
 }
+// prettier-ignore
+export const toolDescriptor = Object.freeze({ name: TOOL_NAME, register: registerGetProjectStatus, compatibility: "optional", effect: "read", batch: "none", directOutputFormats: Object.freeze(["json"]) });

package/dist/tools/get_symbol_source.js

@@ -3,6 +3,7 @@ import { nodeSourceWithLocation } from "../services/outline.js";
 import { findDeclarationByName, getSourceFileOrThrow, withProject } from "../services/project.js";
 import { createRequestContext } from "../services/request-context.js";
 import { createToolErrorContext, errorResult, structuredResult } from "./result.js";
+const TOOL_NAME = "ast_get_symbol_source";
 const AstGetSymbolSourceInputSchema = z.object({
     project_root: z
         .string()
@@ -17,7 +18,7 @@ const AstGetSymbolSourceOutputSchema = z.object({
     text: z.string(),
 });
 export function registerGetSymbolSource(server) {
-    server.registerTool("ast_get_symbol_source", {
+    server.registerTool(TOOL_NAME, {
         title: "Get one symbol implementation",
         description: "Returns exactly one declaration or implementation with its project-relative location, not the complete file.",
         inputSchema: AstGetSymbolSourceInputSchema,
@@ -39,7 +40,9 @@ export function registerGetSymbolSource(server) {
             return structuredResult(structuredContent);
         }
         catch (error) {
-            return errorResult(error, createToolErrorContext("ast_get_symbol_source", project_root));
+            return errorResult(error, createToolErrorContext(TOOL_NAME, project_root));
         }
     });
 }
+// prettier-ignore
+export const toolDescriptor = Object.freeze({ name: TOOL_NAME, register: registerGetSymbolSource, compatibility: "required", effect: "read", batch: "read", directOutputFormats: Object.freeze(["json"]) });

package/dist/tools/list_files.js

@@ -4,6 +4,7 @@ import { PaginationInputSchema, PaginationOutputSchema, paginate } from "../serv
 import { withProject } from "../services/project.js";
 import { createRequestContext } from "../services/request-context.js";
 import { createToolErrorContext, errorResult, structuredResult } from "./result.js";
+const TOOL_NAME = "ast_list_files";
 const AstListFilesInputSchema = z.object({
     project_root: z
         .string()
@@ -19,7 +20,7 @@ const AstListFilesOutputSchema = z.object({
     ...PaginationOutputSchema,
 });
 export function registerListFiles(server) {
-    server.registerTool("ast_list_files", {
+    server.registerTool(TOOL_NAME, {
         title: "List TypeScript/JavaScript project files",
         description: "Lists source files included by the project's tsconfig in deterministic, project-relative, paginated form.",
         inputSchema: AstListFilesInputSchema,
@@ -50,7 +51,9 @@ export function registerListFiles(server) {
             return structuredResult(output);
         }
         catch (error) {
-            return errorResult(error, createToolErrorContext("ast_list_files", project_root));
+            return errorResult(error, createToolErrorContext(TOOL_NAME, project_root));
         }
     });
 }
+// prettier-ignore
+export const toolDescriptor = Object.freeze({ name: TOOL_NAME, register: registerListFiles, compatibility: "required", effect: "read", batch: "read", directOutputFormats: Object.freeze(["json"]) });

package/dist/tools/rename_symbol.js

@@ -3,6 +3,7 @@ import { prepareRename } from "../services/operations.js";
 import { createRequestContext } from "../services/request-context.js";
 import { PreparedOperationOutputSchema, serializePreparedOperation } from "./operation-schema.js";
 import { createToolErrorContext, errorResult, structuredResult } from "./result.js";
+const TOOL_NAME = "ast_rename_symbol";
 const AstRenameSymbolInputSchema = z.object({
     project_root: z.string(),
     file_path: z.string(),
@@ -18,7 +19,7 @@ const AstRenameSymbolInputSchema = z.object({
         .describe("Permit a plan with new TypeScript errors after explicit review."),
 });
 export function registerRenameSymbol(server) {
-    server.registerTool("ast_rename_symbol", {
+    server.registerTool(TOOL_NAME, {
         title: "Prepare a project-wide structural rename",
         description: "Prepares an exact hash-bound rename plan without writing. Review the preview and apply its operation_id with ast_apply_operation.",
         inputSchema: AstRenameSymbolInputSchema,
@@ -45,7 +46,9 @@ export function registerRenameSymbol(server) {
             return structuredResult(serializePreparedOperation(operation));
         }
         catch (error) {
-            return errorResult(error, createToolErrorContext("ast_rename_symbol", project_root));
+            return errorResult(error, createToolErrorContext(TOOL_NAME, project_root));
         }
     });
 }
+// prettier-ignore
+export const toolDescriptor = Object.freeze({ name: TOOL_NAME, register: registerRenameSymbol, compatibility: "required", effect: "prepare", batch: "prepare", directOutputFormats: Object.freeze(["json"]) });

package/dist/tools/replace_symbol_body.js

@@ -3,6 +3,7 @@ import { prepareReplaceBody } from "../services/operations.js";
 import { createRequestContext } from "../services/request-context.js";
 import { PreparedOperationOutputSchema, serializePreparedOperation } from "./operation-schema.js";
 import { createToolErrorContext, errorResult, structuredResult } from "./result.js";
+const TOOL_NAME = "ast_replace_symbol_body";
 const AstReplaceSymbolBodyInputSchema = z.object({
     project_root: z.string(),
     file_path: z.string(),
@@ -18,7 +19,7 @@ const AstReplaceSymbolBodyInputSchema = z.object({
         .describe("Permit a plan with new TypeScript errors after explicit review."),
 });
 export function registerReplaceSymbolBody(server) {
-    server.registerTool("ast_replace_symbol_body", {
+    server.registerTool(TOOL_NAME, {
         title: "Prepare an exact function-body replacement",
         description: "Prepares a hash-bound body replacement while preserving the signature. Supports declarations, methods, accessors and function-valued variables/properties.",
         inputSchema: AstReplaceSymbolBodyInputSchema,
@@ -45,7 +46,9 @@ export function registerReplaceSymbolBody(server) {
             return structuredResult(serializePreparedOperation(operation));
         }
         catch (error) {
-            return errorResult(error, createToolErrorContext("ast_replace_symbol_body", project_root));
+            return errorResult(error, createToolErrorContext(TOOL_NAME, project_root));
         }
     });
 }
+// prettier-ignore
+export const toolDescriptor = Object.freeze({ name: TOOL_NAME, register: registerReplaceSymbolBody, compatibility: "required", effect: "prepare", batch: "prepare", directOutputFormats: Object.freeze(["json"]) });

package/dist/tools/scaffold_class.js

@@ -3,6 +3,7 @@ import { prepareScaffoldClass } from "../services/operations.js";
 import { createRequestContext } from "../services/request-context.js";
 import { createToolErrorContext, errorResult, structuredResult } from "./result.js";
 import { PreparedOperationOutputSchema, serializePreparedOperation } from "./operation-schema.js";
+const TOOL_NAME = "ast_scaffold_class";
 const IdentifierSchema = z.string().min(1).max(200);
 const TypeTextSchema = z.string().min(1).max(10_000);
 const AccessSchema = z.enum(["public", "protected", "private"]);
@@ -111,7 +112,7 @@ export function registerScaffoldClass(server) {
     // The SDK compatibility overload exceeds TypeScript's instantiation depth for this schema.
     // Keep the complete runtime schema and isolate only the registrar type.
     const registerTool = server.registerTool.bind(server);
-    registerTool("ast_scaffold_class", {
+    registerTool(TOOL_NAME, {
         title: "Prepare Class Scaffold",
         description: "Prepares a hash-bound new TypeScript class file without writing it. Each method body throws an explicit not-implemented error. Review the diff, then apply the returned operation_id and plan_hash with ast_apply_operation.",
         inputSchema: ScaffoldClassInputSchema,
@@ -141,7 +142,9 @@ export function registerScaffoldClass(server) {
             return structuredResult(structuredContent);
         }
         catch (error) {
-            return errorResult(error, createToolErrorContext("ast_scaffold_class", args.project_root));
+            return errorResult(error, createToolErrorContext(TOOL_NAME, args.project_root));
         }
     });
 }
+// prettier-ignore
+export const toolDescriptor = Object.freeze({ name: TOOL_NAME, register: registerScaffoldClass, compatibility: "required", effect: "prepare", batch: "prepare", directOutputFormats: Object.freeze(["json"]) });

package/dist/tools/search_symbols.js

@@ -4,6 +4,7 @@ import { withProject, reportSymbolIndexFailure } from "../services/project.js";
 import { createRequestContext } from "../services/request-context.js";
 import { searchProjectSymbolsPage, searchProjectSymbolsPageWithIndex, } from "../services/symbols.js";
 import { createToolErrorContext, errorResult, formattedResult, ToolOutputFormatInputSchema, } from "./result.js";
+const TOOL_NAME = "ast_search_symbols";
 const SEARCH_DEFAULT_LIMIT = 20;
 const SearchDetailSchema = z.enum(["selectors", "summary", "full"]).default("summary");
 const AstSearchSymbolsInputSchema = z.object({
@@ -77,7 +78,7 @@ function projectSymbols(detail, symbols) {
     return symbols.map(({ file, selector, kind }) => ({ file, selector, kind }));
 }
 export function registerSearchSymbols(server) {
-    server.registerTool("ast_search_symbols", {
+    server.registerTool(TOOL_NAME, {
         title: "Search project symbols",
         description: "Ranks structural declarations and returns exact file/symbol selectors for downstream AST tools.",
         inputSchema: AstSearchSymbolsInputSchema,
@@ -108,7 +109,9 @@ export function registerSearchSymbols(server) {
             return formattedResult(outputSchema, structuredContent, output_format);
         }
         catch (error) {
-            return errorResult(error, createToolErrorContext("ast_search_symbols", project_root));
+            return errorResult(error, createToolErrorContext(TOOL_NAME, project_root));
         }
     });
 }
+// prettier-ignore
+export const toolDescriptor = Object.freeze({ name: TOOL_NAME, register: registerSearchSymbols, compatibility: "required", effect: "read", batch: "read", directOutputFormats: Object.freeze(["json", "toon"]) });

package/dist/worker-runtime.js

@@ -14,11 +14,11 @@ export async function runStdioServer(options = {}) {
     prepareProjectRuntimeForStartup();
     const runtimeActivity = options.runtimeActivity ?? new RuntimeActivityTracker();
     runtimeActivity.prepareForStartup();
-    const server = options.server ?? createServer({ runtimeActivity });
+    const runtimePolicy = options.runtimePolicy ?? readRuntimePolicy();
+    const server = options.server ?? createServer({ runtimeActivity, denyApply: runtimePolicy.denyApply });
     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;