cwtools-shared 0.1.0

package/dist/generated/mcpTools.d.ts

@@ -0,0 +1,1112 @@
+export declare const GENERATED_MCP_TOOLS: readonly [{
+    readonly tool: {
+        readonly name: "query_types";
+        readonly description: "Warning: MANDATORY before using any game ID. Query defined instances of a current-game PDXScript type from mod + vanilla cache. PDXscript IDs are routinely hallucinated - always verify through this tool. Set filter to narrow results.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly typeName: {
+                    readonly type: "string";
+                    readonly description: "Exact current-game type name returned by query_cwt_schema, completion, or another typed LSP result.";
+                };
+                readonly filter: {
+                    readonly type: "string";
+                    readonly description: "Prefix or substring filter. ALWAYS use when looking up a specific vanilla ID to avoid unrelated results.";
+                };
+                readonly limit: {
+                    readonly type: "number";
+                    readonly description: "Max results to return (default 30, keep low for token efficiency)";
+                };
+                readonly vanilla: {
+                    readonly type: "boolean";
+                    readonly description: "If true, return ONLY vanilla game definitions. If false (default), return mod + vanilla combined.";
+                };
+            };
+            readonly required: readonly ["typeName"];
+        };
+    };
+    readonly registry: {
+        readonly name: "query_types";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "parallel";
+    };
+}, {
+    readonly tool: {
+        readonly name: "query_rules";
+        readonly description: "Query syntax rules for triggers, effects, scope changes, or modifiers from CWT/LSP-backed rule evidence. Returns hardFacts (legal syntax/scopes/push_scope/type filters) plus semanticHints from trigger_docs.log/scopes.cwt comments. Treat semanticHints as search guidance, not proof of legality. Fuzzy-matches if exact name not found.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly category: {
+                    readonly type: "string";
+                    readonly enum: readonly ["trigger", "effect", "scope_change", "modifier"];
+                    readonly description: "Rule category";
+                };
+                readonly name: {
+                    readonly type: "string";
+                    readonly description: "Specific rule name (optional, lists all if omitted or returns fuzzy matches if exact miss)";
+                };
+                readonly scope: {
+                    readonly type: "string";
+                    readonly description: "Filter by an exact supported scope returned by query_scope/explain_scope. Optional, but heavily recommended.";
+                };
+            };
+            readonly required: readonly ["category"];
+        };
+    };
+    readonly registry: {
+        readonly name: "query_rules";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "parallel";
+    };
+}, {
+    readonly tool: {
+        readonly name: "query_cwt_schema";
+        readonly description: "CWT-FIRST schema lookup for entity definitions and other non-trigger/effect rules. Use BEFORE writing or planning a PDXScript target. Pass the actual project file/directory plus an optional field/rule name. Returns active CWT source snippets, line numbers, and parsed type/path/subtype entity summaries. If snippets are structural only, confirm intent from verified current-version examples.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly target: {
+                    readonly type: "string";
+                    readonly description: "Actual project file/directory or a CWT-relative path returned by active schema metadata.";
+                };
+                readonly file: {
+                    readonly type: "string";
+                    readonly description: "Alias for target when you have a concrete project file path.";
+                };
+                readonly directory: {
+                    readonly type: "string";
+                    readonly description: "Alias for target when an active project/schema result supplied the entity directory.";
+                };
+                readonly name: {
+                    readonly type: "string";
+                    readonly description: "Optional field, type, alias, or rule name to locate inside matched CWT files.";
+                };
+                readonly includeContent: {
+                    readonly type: "boolean";
+                    readonly description: "If true, return a larger excerpt from matched schema files. Default false.";
+                };
+                readonly limit: {
+                    readonly type: "number";
+                    readonly description: "Maximum CWT files to return. Default 5, max 20.";
+                };
+            };
+            readonly required: readonly [];
+        };
+    };
+    readonly registry: {
+        readonly name: "query_cwt_schema";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "parallel";
+    };
+}, {
+    readonly tool: {
+        readonly name: "search_rule_capabilities";
+        readonly description: "Search CWT/LSP rule evidence by intent and scope capability instead of guessing a rule name. Use this when you know what you want to do but do not know the exact trigger/effect/scope_change name. Returns ranked candidates with hardFacts and semanticHints; validate the selected rule before writing.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly intent: {
+                    readonly type: "string";
+                    readonly description: "Natural-language intent. Exact current-game terms from CWT docs improve ranking.";
+                };
+                readonly category: {
+                    readonly type: "string";
+                    readonly enum: readonly ["trigger", "effect", "scope_change", "modifier", "all"];
+                    readonly description: "Optional CWT rule category filter.";
+                };
+                readonly currentScope: {
+                    readonly type: "string";
+                    readonly description: "Optional exact current CWT scope returned by query_scope.";
+                };
+                readonly desiredPushScope: {
+                    readonly type: "string";
+                    readonly description: "Optional exact resulting scope returned by explain_scope/schema evidence.";
+                };
+                readonly limit: {
+                    readonly type: "number";
+                    readonly description: "Maximum candidates to return. Default 10, max 50.";
+                };
+            };
+            readonly required: readonly [];
+        };
+    };
+    readonly registry: {
+        readonly name: "search_rule_capabilities";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "parallel";
+    };
+}, {
+    readonly tool: {
+        readonly name: "explain_scope";
+        readonly description: "Explain a current CWT scope from scopes.cwt, including aliases, is_subscope_of, source location, and semantic hints. Scope descriptions are hints, not legality proof.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly scope: {
+                    readonly type: "string";
+                    readonly description: "Exact scope or alias observed in current CWT/LSP output.";
+                };
+            };
+            readonly required: readonly ["scope"];
+        };
+    };
+    readonly registry: {
+        readonly name: "explain_scope";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "parallel";
+    };
+}, {
+    readonly tool: {
+        readonly name: "parse_pdx_fragment";
+        readonly description: "Parse a PDXScript fragment through the CWTools language server without writing a file. Use this for quick syntax, brace, and recovery checks after selecting rules. This is not a full semantic validation substitute; final project edits still need get_diagnostics/completions or verified examples.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly code: {
+                    readonly type: "string";
+                    readonly description: "PDXScript fragment text to parse.";
+                };
+            };
+            readonly required: readonly ["code"];
+        };
+    };
+    readonly registry: {
+        readonly name: "parse_pdx_fragment";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "parallel";
+    };
+}, {
+    readonly tool: {
+        readonly name: "query_scope";
+        readonly description: "Query the scope context at a specific position in a file. Returns current/root/prior scope chains plus provenance and inference evidence reported by CWTools. Use it to determine which active CWT rules are valid at that position.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly file: {
+                    readonly type: "string";
+                    readonly description: "Absolute file path";
+                };
+                readonly line: {
+                    readonly type: "number";
+                    readonly description: "Line number (0-based)";
+                };
+                readonly column: {
+                    readonly type: "number";
+                    readonly description: "Column number (0-based)";
+                };
+            };
+            readonly required: readonly ["file", "line", "column"];
+        };
+    };
+    readonly registry: {
+        readonly name: "query_scope";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "parallel";
+    };
+}, {
+    readonly tool: {
+        readonly name: "get_diagnostics";
+        readonly description: "Get errors, warnings, information, and hints from the VS Code Problems diagnostics snapshot, optionally filtered by file and severity. Returns totals and truncation metadata; check truncated before treating the returned list as complete.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly file: {
+                    readonly type: "string";
+                    readonly description: "Optional: restrict to a specific file path (absolute) or a path substring to match. Leave empty to get all workspace diagnostics.";
+                };
+                readonly severity: {
+                    readonly type: "string";
+                    readonly enum: readonly ["error", "warning", "info", "hint", "all"];
+                    readonly description: "Filter by severity. Default: \"all\"";
+                };
+                readonly limit: {
+                    readonly type: "number";
+                    readonly description: "Max diagnostics to return (default 500, max 2000). For full project reviews, omit this parameter to get all diagnostics. Only set a low limit when you want a quick summary.";
+                };
+            };
+            readonly required: readonly [];
+        };
+    };
+    readonly registry: {
+        readonly name: "get_diagnostics";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "lsp-limited";
+    };
+}, {
+    readonly tool: {
+        readonly name: "analyze_diagnostic_error";
+        readonly description: "Classify an existing diagnostic or tool/write failure and return routing advice. Use after a write, validation, ReadTracker, or tool-argument failure. Prefer passing diagnosticsSnapshot/toolResult from get_diagnostics or a write tool so this does not re-query diagnostics. When a concrete identifier/sprite/sound/localisation key appears, the result tells the agent to verify it against project + vanilla sources; when LSP has no feedback, it avoids blind searches.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly file: {
+                    readonly type: "string";
+                    readonly description: "Optional file where the diagnostic or failed tool operation occurred. Used only to scope a fallback get_diagnostics call if no snapshot is supplied.";
+                };
+                readonly errorCode: {
+                    readonly type: "string";
+                    readonly description: "Optional diagnostic code or compact error message.";
+                };
+                readonly message: {
+                    readonly type: "string";
+                    readonly description: "Optional raw failure message from a tool or validation step.";
+                };
+                readonly previousAttempt: {
+                    readonly type: "string";
+                    readonly description: "Optional summary of the last attempted fix. Helps detect repeated blind retries.";
+                };
+                readonly toolName: {
+                    readonly type: "string";
+                    readonly description: "Optional name of the tool that failed, e.g. edit_file, write_localisation, get_diagnostics.";
+                };
+                readonly diagnosticsSnapshot: {
+                    readonly type: "object";
+                    readonly description: "Optional raw get_diagnostics result, write-tool diagnostics payload, or compact diagnostic object to classify without querying diagnostics again.";
+                };
+                readonly toolResult: {
+                    readonly type: "object";
+                    readonly description: "Optional raw failed tool result to classify without querying diagnostics again.";
+                };
+                readonly reflection: {
+                    readonly type: "string";
+                    readonly description: "Optional legacy free-form analysis from the model. Kept for backward compatibility; the host still returns deterministic routing advice.";
+                };
+            };
+            readonly required: readonly [];
+        };
+    };
+    readonly registry: {
+        readonly name: "analyze_diagnostic_error";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "none";
+        readonly riskLevel: 2;
+        readonly concurrencyClass: "global-exclusive";
+    };
+}, {
+    readonly tool: {
+        readonly name: "query_project_profile";
+        readonly description: "Read the /init-generated Agent project profile from .cwtools/project/profile.json. Use this before broad scans to get workspace type, key directories, localisation languages/encoding, namespaces, workflow routing, validation hints, and mode-specific prompt cards.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly section: {
+                    readonly type: "string";
+                    readonly enum: readonly ["summary", "routing", "directories", "localisation", "identifiers", "validation", "promptCards", "all"];
+                    readonly description: "Targeted profile section to return. Default summary. Use all only when you need the whole profile.";
+                };
+                readonly mode: {
+                    readonly type: "string";
+                    readonly enum: readonly ["build", "plan", "explore", "general", "utility", "review", "gui_expert", "script_reviewer", "loc_translator", "loc_writer", "orchestrator", "script", "asset"];
+                    readonly description: "Optional mode card to return, e.g. build, plan, loc_writer, asset, orchestrator, script.";
+                };
+            };
+            readonly required: readonly [];
+        };
+    };
+    readonly registry: {
+        readonly name: "query_project_profile";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "parallel";
+    };
+}, {
+    readonly tool: {
+        readonly name: "query_project_knowledge";
+        readonly description: "Query the /init-generated project + vanilla SQLite knowledge graph for complex cross-subsystem work. Returns project patterns, bounded vanilla archetypes, definition stacks, dependency edges, typed relationship structure/logic, freshness, and unresolved facts with source paths. Use this before write_design_blueprint or any plan spanning multiple current-game entity families. CWT/LSP exact checks remain authoritative.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly intent: {
+                    readonly type: "string";
+                    readonly description: "Concise design or investigation intent used to rank evidence.";
+                };
+                readonly domains: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "Subsystem domains returned by the project knowledge manifest or an earlier query.";
+                };
+                readonly identifiers: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "Known or proposed IDs used as indexed graph seeds. Exact IDs and stable prefixes give the fastest, most accurate retrieval.";
+                };
+                readonly entityTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "CWTools entity types to prioritize.";
+                };
+                readonly includeProjectPatterns: {
+                    readonly type: "boolean";
+                    readonly description: "Include existing workspace examples. Default true.";
+                };
+                readonly includeVanillaArchetypes: {
+                    readonly type: "boolean";
+                    readonly description: "Include bounded vanilla examples with exact sources. Default true.";
+                };
+                readonly includeTopology: {
+                    readonly type: "boolean";
+                    readonly description: "Include project dependency/reference edges. Default true.";
+                };
+                readonly includeUnresolved: {
+                    readonly type: "boolean";
+                    readonly description: "Include ambiguous definition stacks and snapshot warnings. Default true.";
+                };
+                readonly includeEventGraph: {
+                    readonly type: "boolean";
+                    readonly description: "Include event nodes, structural call/entry edges, and state/scope logic relations. Default true.";
+                };
+                readonly limit: {
+                    readonly type: "number";
+                    readonly minimum: 1;
+                    readonly maximum: 300;
+                    readonly description: "Maximum ranked evidence records. Default 80.";
+                };
+            };
+            readonly required: readonly [];
+        };
+    };
+    readonly registry: {
+        readonly name: "query_project_knowledge";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "parallel";
+    };
+}, {
+    readonly tool: {
+        readonly name: "query_workspace_index";
+        readonly description: "Query the shared incremental workspace index for PDXScript symbols and named .gfx/.asset/.gui assets without scanning files. Use this before broad grep/search for any named project symbol. Results report indexedSymbolNames, indexUpdatedAt, fileVersion, and optional lightweight references for freshness/coverage awareness.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly name: {
+                    readonly type: "string";
+                    readonly description: "Exact, prefix, or substring symbol/asset name to search for.";
+                };
+                readonly kind: {
+                    readonly type: "string";
+                    readonly description: "Optional exact kind returned by the active index or CWT type metadata.";
+                };
+                readonly category: {
+                    readonly type: "string";
+                    readonly description: "Optional broad category returned by an earlier index result.";
+                };
+                readonly source: {
+                    readonly type: "string";
+                    readonly enum: readonly ["script", "asset", "gui"];
+                    readonly description: "Optional source filter. script=.txt, asset=.gfx/.asset, gui=.gui.";
+                };
+                readonly origin: {
+                    readonly type: "string";
+                    readonly enum: readonly ["workspace", "vanilla", "both"];
+                    readonly description: "Optional origin filter. workspace=mod files, vanilla=configured game cache, both/default=combined.";
+                };
+                readonly directory: {
+                    readonly type: "string";
+                    readonly description: "Optional project path fragment; prefer a path returned by project profile or CWT schema.";
+                };
+                readonly prefix: {
+                    readonly type: "boolean";
+                    readonly description: "If true, name is treated as a prefix. Default false.";
+                };
+                readonly exact: {
+                    readonly type: "boolean";
+                    readonly description: "If true, name must match exactly. Default false.";
+                };
+                readonly includeReferences: {
+                    readonly type: "boolean";
+                    readonly description: "If true, include lightweight cross-file reference contexts captured by the index. Default false.";
+                };
+                readonly limit: {
+                    readonly type: "number";
+                    readonly description: "Maximum entries to return. Default 50, max 200.";
+                };
+            };
+            readonly required: readonly [];
+        };
+    };
+    readonly registry: {
+        readonly name: "query_workspace_index";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "parallel";
+    };
+}, {
+    readonly tool: {
+        readonly name: "explore_pdx_project";
+        readonly description: "Primary semantic exploration entry point for large Paradox projects. Queries the live CWTools type/reference graph and returns bounded entry points, typed nodes, dependency edges, file facts, provenance, truncation, and freshness without scanning or reading whole files. Use this FIRST for questions such as how an entity is connected, what calls or references an ID, what a file depends on, or what may be affected by a change. Follow with exact query_rules/query_scope/query_types/get_pdx_block checks before writing.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly query: {
+                    readonly type: "string";
+                    readonly description: "Identifier or concise semantic search text. Exact PDX IDs give the strongest results. Optional when file or typeName is supplied.";
+                };
+                readonly file: {
+                    readonly type: "string";
+                    readonly description: "Optional workspace-relative or absolute file path used to restrict entry points.";
+                };
+                readonly typeName: {
+                    readonly type: "string";
+                    readonly description: "Optional exact CWTools type name obtained from active schema/type evidence.";
+                };
+                readonly exact: {
+                    readonly type: "boolean";
+                    readonly description: "Require query to exactly match an entity ID. Default false.";
+                };
+                readonly depth: {
+                    readonly type: "number";
+                    readonly minimum: 0;
+                    readonly maximum: 3;
+                    readonly description: "Incoming/outgoing graph traversal depth. Default 1; use 2-3 only for focused IDs.";
+                };
+                readonly maxNodes: {
+                    readonly type: "number";
+                    readonly minimum: 1;
+                    readonly maximum: 100;
+                    readonly description: "Maximum graph nodes. Default 30.";
+                };
+                readonly maxEdges: {
+                    readonly type: "number";
+                    readonly minimum: 1;
+                    readonly maximum: 300;
+                    readonly description: "Maximum graph edges and per-file semantic facts. Default 80.";
+                };
+                readonly includeMetadata: {
+                    readonly type: "boolean";
+                    readonly description: "Include documentation, variables, event targets, and block metadata. Default true.";
+                };
+            };
+            readonly required: readonly [];
+        };
+    };
+    readonly registry: {
+        readonly name: "explore_pdx_project";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "lsp-limited";
+    };
+}, {
+    readonly tool: {
+        readonly name: "query_localisation_index";
+        readonly description: "Query the shared incremental localisation index for mod YML keys without scanning files. Use this before creating or updating localisation keys, and when checking whether a key already exists.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly key: {
+                    readonly type: "string";
+                    readonly description: "Exact key, prefix, or substring to search for.";
+                };
+                readonly language: {
+                    readonly type: "string";
+                    readonly description: "Optional language tag returned by the active project/profile localisation metadata.";
+                };
+                readonly prefix: {
+                    readonly type: "boolean";
+                    readonly description: "If true, key is treated as a prefix. Default false.";
+                };
+                readonly contains: {
+                    readonly type: "boolean";
+                    readonly description: "If true, key is treated as a case-insensitive substring. Useful when you only know part of a localisation key.";
+                };
+                readonly caseSensitive: {
+                    readonly type: "boolean";
+                    readonly description: "Only applies to prefix/contains searches. Default false.";
+                };
+                readonly limit: {
+                    readonly type: "number";
+                    readonly description: "Maximum entries to return. Default 20, max 100.";
+                };
+            };
+            readonly required: readonly [];
+        };
+    };
+    readonly registry: {
+        readonly name: "query_localisation_index";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "parallel";
+    };
+}, {
+    readonly tool: {
+        readonly name: "get_pdx_block";
+        readonly description: "Extract exactly one complete AST block by symbol name. Works with .txt (events, common), .gui (containerWindowType by name), and .gfx (pdxmesh by name). Returns 1-based startLine/endLine that can be passed directly to replace_lines. If the symbol is not found, the error response includes a full list of available symbols with line ranges so you can retry with the correct name.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly file: {
+                    readonly type: "string";
+                    readonly description: "Absolute file path";
+                };
+                readonly symbol: {
+                    readonly type: "string";
+                    readonly description: "Exact symbol returned by document_symbols or another active typed lookup. If not found, the error lists available symbols and line ranges.";
+                };
+            };
+            readonly required: readonly ["file", "symbol"];
+        };
+    };
+    readonly registry: {
+        readonly name: "get_pdx_block";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "parallel";
+    };
+}, {
+    readonly tool: {
+        readonly name: "get_completion_at";
+        readonly description: "Get auto-completion suggestions and bounded context at a specific position through the active VS Code language provider. In Paradox projects, CWTools may enrich the result with game-aware scope and schema context.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly file: {
+                    readonly type: "string";
+                    readonly description: "Absolute file path (must be in the workspace)";
+                };
+                readonly line: {
+                    readonly type: "number";
+                    readonly description: "Line number (0-based)";
+                };
+                readonly column: {
+                    readonly type: "number";
+                    readonly description: "Column number (0-based)";
+                };
+                readonly limit: {
+                    readonly type: "number";
+                    readonly description: "Max completions to return (default 30). Increase if you need to see more options.";
+                };
+            };
+            readonly required: readonly ["file", "line", "column"];
+        };
+    };
+    readonly registry: {
+        readonly name: "get_completion_at";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "parallel";
+    };
+}, {
+    readonly tool: {
+        readonly name: "document_symbols";
+        readonly description: "Get symbols defined in a file as a hierarchical tree with 0-based line ranges from the active VS Code language provider. Use this first to understand file structure before choosing targeted reads.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly file: {
+                    readonly type: "string";
+                    readonly description: "Absolute file path";
+                };
+            };
+            readonly required: readonly ["file"];
+        };
+    };
+    readonly registry: {
+        readonly name: "document_symbols";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "lsp-limited";
+    };
+}, {
+    readonly tool: {
+        readonly name: "workspace_symbols";
+        readonly description: "Search symbol definitions by name through active VS Code workspace symbol providers. Use a specific query. Empty results may reflect provider coverage or indexing state and are not proof that text is absent from the repository.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly query: {
+                    readonly type: "string";
+                    readonly description: "Symbol name or partial name to search for. Be specific to avoid large result sets.";
+                };
+                readonly limit: {
+                    readonly type: "number";
+                    readonly description: "Max results (default 20; keep low for broad searches to avoid token waste).";
+                };
+            };
+            readonly required: readonly ["query"];
+        };
+    };
+    readonly registry: {
+        readonly name: "workspace_symbols";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "lsp-limited";
+    };
+}, {
+    readonly tool: {
+        readonly name: "query_definition";
+        readonly description: "GoToDefinition at a position, or FindAllRefs if no definition exists. Uses CWTools AST - faster than grep. If you know the symbol name, prefer query_definition_by_name instead.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly file: {
+                    readonly type: "string";
+                    readonly description: "Absolute file path";
+                };
+                readonly line: {
+                    readonly type: "number";
+                    readonly description: "Line number (0-based)";
+                };
+                readonly column: {
+                    readonly type: "number";
+                    readonly description: "Column number (0-based)";
+                };
+            };
+            readonly required: readonly ["file", "line", "column"];
+        };
+    };
+    readonly registry: {
+        readonly name: "query_definition";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "lsp-limited";
+    };
+}, {
+    readonly tool: {
+        readonly name: "query_definition_by_name";
+        readonly description: "Find where a named symbol is defined - no file/position needed. Returns file path and line number. Works for any top-level PDXScript key (events, triggers, effects, etc.).";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly symbolName: {
+                    readonly type: "string";
+                    readonly description: "The exact name of the symbol to find (e.g. \"kuat_has_psionic_research\", \"distar.001\")";
+                };
+            };
+            readonly required: readonly ["symbolName"];
+        };
+    };
+    readonly registry: {
+        readonly name: "query_definition_by_name";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "parallel";
+    };
+}, {
+    readonly tool: {
+        readonly name: "query_references";
+        readonly description: "Find references to an identifier through the active language provider, with a bounded workspace text-search fallback.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly identifier: {
+                    readonly type: "string";
+                    readonly description: "The identifier to search for";
+                };
+                readonly file: {
+                    readonly type: "string";
+                    readonly description: "Optional file to limit search to";
+                };
+            };
+            readonly required: readonly ["identifier"];
+        };
+    };
+    readonly registry: {
+        readonly name: "query_references";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "lsp-limited";
+    };
+}, {
+    readonly tool: {
+        readonly name: "query_scripted_effects";
+        readonly description: "Warning: MANDATORY before using any scripted_effect. Lists all scripted effects with name, scope constraints, and type. PDXscript effect names are frequently hallucinated - always verify here first.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly filter: {
+                    readonly type: "string";
+                    readonly description: "Optional substring filter on effect name. Without filter, results are limited to 50; with filter, up to 200.";
+                };
+                readonly limit: {
+                    readonly type: "number";
+                    readonly description: "Max results (default 50 without filter, 200 with filter)";
+                };
+            };
+            readonly required: readonly [];
+        };
+    };
+    readonly registry: {
+        readonly name: "query_scripted_effects";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "parallel";
+    };
+}, {
+    readonly tool: {
+        readonly name: "query_scripted_triggers";
+        readonly description: "Warning: MANDATORY before using any scripted_trigger. Lists all scripted triggers with name, scope constraints, and type. Trigger names are frequently hallucinated - always verify here first.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly filter: {
+                    readonly type: "string";
+                    readonly description: "Optional substring filter on trigger name. Without filter, results are limited to 50; with filter, up to 200.";
+                };
+                readonly limit: {
+                    readonly type: "number";
+                    readonly description: "Max results (default 50 without filter, 200 with filter)";
+                };
+            };
+            readonly required: readonly [];
+        };
+    };
+    readonly registry: {
+        readonly name: "query_scripted_triggers";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "parallel";
+    };
+}, {
+    readonly tool: {
+        readonly name: "query_enums";
+        readonly description: "Warning: MANDATORY before using any enum field. Query enum values from CWTools rules. Call with no enumName to list all enums, then query specific enum for values. Always verify - enum values are domain-specific.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly enumName: {
+                    readonly type: "string";
+                    readonly description: "Exact enum name discovered from CWT/schema evidence. Leave empty to list all enum names.";
+                };
+                readonly limit: {
+                    readonly type: "number";
+                    readonly description: "Max values to return (default 500)";
+                };
+            };
+            readonly required: readonly [];
+        };
+    };
+    readonly registry: {
+        readonly name: "query_enums";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "parallel";
+    };
+}, {
+    readonly tool: {
+        readonly name: "query_static_modifiers";
+        readonly description: "Warning: MANDATORY before using add_modifier. Lists static modifiers with categories. Modifier names are domain-specific - always verify. Dynamic/engine modifiers may not appear here - use query_rules(category=\"modifier\") as fallback.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly filter: {
+                    readonly type: "string";
+                    readonly description: "Optional substring filter on modifier tag";
+                };
+                readonly limit: {
+                    readonly type: "number";
+                    readonly description: "Max results (default 300)";
+                };
+            };
+            readonly required: readonly [];
+        };
+    };
+    readonly registry: {
+        readonly name: "query_static_modifiers";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "parallel";
+    };
+}, {
+    readonly tool: {
+        readonly name: "query_variables";
+        readonly description: "List all scripted variables (@variable_name = value) defined across the mod and vanilla. Use this to look up numeric constant values defined with @-prefix before using them in generated code.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly filter: {
+                    readonly type: "string";
+                    readonly description: "Optional substring filter on variable name";
+                };
+            };
+            readonly required: readonly [];
+        };
+    };
+    readonly registry: {
+        readonly name: "query_variables";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "parallel";
+    };
+}, {
+    readonly tool: {
+        readonly name: "get_entity_info";
+        readonly description: "Get deep structural info from the CWTools cache, including referenced types, variables, classified rule blocks, and saved scopes. Use it to understand file dependencies before modification.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly file: {
+                    readonly type: "string";
+                    readonly description: "Absolute file path (must be a parsed mod file)";
+                };
+            };
+            readonly required: readonly ["file"];
+        };
+    };
+    readonly registry: {
+        readonly name: "get_entity_info";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "parallel";
+    };
+}, {
+    readonly tool: {
+        readonly name: "query_shader_symbol";
+        readonly description: "Read-only. Query declared Paradox shader symbols (Effects, MainCode stages, constant buffers, render states) from the CWTools shader model across mod, dependencies, and vanilla. Effect entries carry a reachability classification: engine_or_unreferenced means reachability is UNKNOWN, not dead code - never treat it as safe to delete. Page with cursor when nextCursor is non-null.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly filter: {
+                    readonly type: "string";
+                    readonly description: "Optional case-insensitive substring filter on the symbol name.";
+                };
+                readonly kind: {
+                    readonly type: "string";
+                    readonly enum: readonly ["all", "effect", "maincode", "constantbuffer", "state"];
+                    readonly description: "Symbol kind filter. Default all.";
+                };
+                readonly limit: {
+                    readonly type: "number";
+                    readonly description: "Max results to return (1-500, default 100).";
+                };
+                readonly cursor: {
+                    readonly type: "number";
+                    readonly description: "Numeric offset returned as nextCursor by a previous call. Default 0.";
+                };
+            };
+            readonly required: readonly [];
+        };
+    };
+    readonly registry: {
+        readonly name: "query_shader_symbol";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "lsp-limited";
+    };
+}, {
+    readonly tool: {
+        readonly name: "query_shader_compile_unit";
+        readonly description: "Read-only. Return the compile unit for a .shader root or .fxh include: root file, include members with resolution status and origin, include problems (missing/ambiguous/cycle), and the roots that include this file. MANDATORY before editing any .fxh: symbol validity depends on the whole compile unit (root + Includes + platform conditions), so raw text search across the repo does not prove shader semantics.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly file: {
+                    readonly type: "string";
+                    readonly description: "Absolute or workspace-relative path of the .shader/.fxh file.";
+                };
+            };
+            readonly required: readonly ["file"];
+        };
+    };
+    readonly registry: {
+        readonly name: "query_shader_compile_unit";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "lsp-limited";
+    };
+}, {
+    readonly tool: {
+        readonly name: "query_shader_platform_variants";
+        readonly description: "Read-only. Compare presence conditions, macros, and active symbols for every supported Paradox shader platform profile in a compile unit. MANDATORY before changing conditional shader code or macros; validating only the current platform is insufficient.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly file: {
+                    readonly type: "string";
+                    readonly description: "Absolute or workspace-relative path of the .shader/.fxh file.";
+                };
+            };
+            readonly required: readonly ["file"];
+        };
+    };
+    readonly registry: {
+        readonly name: "query_shader_platform_variants";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "lsp-limited";
+    };
+}, {
+    readonly tool: {
+        readonly name: "query_shader_callers";
+        readonly description: "Read-only. Return evidence of what references a shader Effect: data-script assignments and effectFile selections, each with file, logicalPath, origin, enclosingBlock, interfaceSprite/rendererSubtype, direct renderer inputs and bounded static GUI use sites when known, range, and provenance (sourceKind, confidence, gameVersion). MANDATORY before renaming or deleting an Effect.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly effectName: {
+                    readonly type: "string";
+                    readonly description: "Exact shader Effect name.";
+                };
+                readonly limit: {
+                    readonly type: "number";
+                    readonly description: "Max evidence entries to return (default 100).";
+                };
+            };
+            readonly required: readonly ["effectName"];
+        };
+    };
+    readonly registry: {
+        readonly name: "query_shader_callers";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "lsp-limited";
+    };
+}, {
+    readonly tool: {
+        readonly name: "explain_shader_reachability";
+        readonly description: "Read-only. Explain why a shader Effect is reachable or why reachability is unknown: classification, declarations, evidence with provenance/confidence, and the rename policy decision. Respect renamePolicy - engine_hardcoded or unknown entry points must not be renamed. A newly declared Effect is NOT executed unless reachable via a data call, an effectFile convention, or a known engine entry. Pass effectName for one Effect, or file to page through all Effects declared in a shader file.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly effectName: {
+                    readonly type: "string";
+                    readonly description: "Exact shader Effect name. Takes precedence over file.";
+                };
+                readonly file: {
+                    readonly type: "string";
+                    readonly description: "Absolute or workspace-relative path of a .shader/.fxh file; lists its Effects with cursor pagination.";
+                };
+                readonly limit: {
+                    readonly type: "number";
+                    readonly description: "Max results for the per-file form (1-500, default 100).";
+                };
+                readonly cursor: {
+                    readonly type: "number";
+                    readonly description: "Numeric offset returned as nextCursor by a previous per-file call. Default 0.";
+                };
+            };
+            readonly required: readonly [];
+        };
+    };
+    readonly registry: {
+        readonly name: "explain_shader_reachability";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "lsp-limited";
+    };
+}, {
+    readonly tool: {
+        readonly name: "validate_shader";
+        readonly description: "Read-only. Validate a .shader/.fxh file inside its compile unit and return structured diagnostics (code, severity, message, range). Run this on every affected compile-unit root after editing shader files.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly file: {
+                    readonly type: "string";
+                    readonly description: "Absolute or workspace-relative path of the .shader/.fxh file.";
+                };
+            };
+            readonly required: readonly ["file"];
+        };
+    };
+    readonly registry: {
+        readonly name: "validate_shader";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "lsp-limited";
+    };
+}, {
+    readonly tool: {
+        readonly name: "compare_shader_with_vanilla";
+        readonly description: "Read-only. Structurally compare workspace shader declarations with vanilla: which declarations are effective and which vanilla declarations they override. Pass effectName for one Effect, or file for all Effects declared in a shader file.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly effectName: {
+                    readonly type: "string";
+                    readonly description: "Exact shader Effect name. Takes precedence over file.";
+                };
+                readonly file: {
+                    readonly type: "string";
+                    readonly description: "Absolute or workspace-relative path of a .shader/.fxh file.";
+                };
+            };
+            readonly required: readonly [];
+        };
+    };
+    readonly registry: {
+        readonly name: "compare_shader_with_vanilla";
+        readonly isWrite: false;
+        readonly isReadOnly: true;
+        readonly effect: "workspace_read";
+        readonly riskLevel: 0;
+        readonly concurrencyClass: "lsp-limited";
+    };
+}];