cwtools-shared 0.1.0

package/dist/host/diagnostics.d.ts

@@ -0,0 +1,41 @@
+export type DiagnosticSeverity = 'error' | 'warning' | 'information' | 'hint';
+export type DiagnosticsFreshness = 'fresh' | 'pending' | 'stale' | 'unavailable';
+export interface DiagnosticRecord {
+    file?: string;
+    line?: number;
+    column?: number;
+    endLine?: number;
+    endColumn?: number;
+    severity: DiagnosticSeverity;
+    code?: string;
+    message: string;
+    source?: string;
+}
+export interface DiagnosticsFilter {
+    file?: string;
+    severity?: DiagnosticSeverity;
+    limit?: number;
+}
+export interface DiagnosticsQueryResult {
+    ok: boolean;
+    status: DiagnosticsFreshness;
+    diagnostics: DiagnosticRecord[];
+    totalCount?: number;
+    truncated?: boolean;
+    suppressedCount?: number;
+    freshness?: {
+        value: DiagnosticsFreshness;
+        pendingKinds: string[];
+        validatedVersion?: number;
+        epoch?: number;
+        updatedAt?: number;
+    };
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+export interface DiagnosticsHost {
+    getDiagnostics(filter?: DiagnosticsFilter): Promise<DiagnosticsQueryResult>;
+}
+export declare function createUnavailableDiagnosticsHost(message?: string): DiagnosticsHost;

package/dist/host/diagnostics.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUnavailableDiagnosticsHost = createUnavailableDiagnosticsHost;
+function createUnavailableDiagnosticsHost(message = 'Diagnostics are not available without an LSP connection.') {
+    return {
+        async getDiagnostics() {
+            return {
+                ok: false,
+                status: 'unavailable',
+                diagnostics: [],
+                error: {
+                    code: 'diagnostics_unavailable',
+                    message,
+                },
+            };
+        },
+    };
+}

package/dist/host/filesystem.d.ts

@@ -0,0 +1,18 @@
+export interface ReadTextFileResult {
+    content: string;
+    hasBom: boolean;
+    exists: boolean;
+}
+export interface DirectoryEntry {
+    name: string;
+    type: 'file' | 'directory';
+    size?: number;
+}
+export interface FilesystemHost {
+    readTextFile(path: string): Promise<ReadTextFileResult>;
+    writeTextFile(path: string, content: string): Promise<void>;
+    list(path: string): Promise<DirectoryEntry[]>;
+    glob(pattern: string, options?: {
+        limit?: number;
+    }): Promise<string[]>;
+}

package/dist/host/filesystem.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/host/hostServices.d.ts

@@ -0,0 +1,49 @@
+import type { DiagnosticsHost } from './diagnostics';
+import type { FilesystemHost } from './filesystem';
+import type { IndexHost } from './indexing';
+import type { LspHost } from './lsp';
+import type { VanillaCacheStatus } from './vanillaCache';
+export type HostLogLevel = 'debug' | 'info' | 'warn' | 'error';
+export interface ProjectProfileHost {
+    readProfile(): Promise<unknown | null>;
+}
+export interface GameKnowledgeHost {
+    queryProfile?(args?: unknown): Promise<unknown>;
+    queryHints?(args?: unknown): Promise<unknown>;
+    queryDiagnosticKnowledge?(args?: unknown): Promise<unknown>;
+}
+export interface CompletionHost {
+    getCompletionContext(args: unknown): Promise<unknown>;
+}
+export interface RulesConfigHost {
+    gameId?: string;
+    configDirs?: string[];
+    readTextFile?(filePath: string): Promise<{
+        content: string;
+        hasBom?: boolean;
+        exists: boolean;
+    }>;
+    listCwtFiles?(root: string, options?: {
+        limit?: number;
+    }): Promise<string[]>;
+}
+export interface HostServices {
+    workspaceRoot: string;
+    readonlyMode: boolean;
+    writesEnabled: boolean;
+    allowedWriteTools?: ReadonlySet<string>;
+    lsp: LspHost;
+    diagnostics: DiagnosticsHost;
+    filesystem: FilesystemHost;
+    indexing?: IndexHost;
+    projectProfile?: ProjectProfileHost;
+    knowledge?: GameKnowledgeHost;
+    completion?: CompletionHost;
+    rules?: RulesConfigHost;
+    vanillaCache?: VanillaCacheStatus;
+    projectSupported?: boolean;
+    projectSupportReason?: string;
+    now(): number;
+    log(level: HostLogLevel, message: string, data?: unknown): void;
+    dispose?(): void;
+}

package/dist/host/hostServices.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/host/indexing.d.ts

@@ -0,0 +1,54 @@
+export interface WorkspaceIndexQuery {
+    name?: string;
+    kind?: string;
+    category?: string;
+    source?: 'script' | 'asset' | 'gui';
+    origin?: 'workspace' | 'vanilla' | 'both';
+    directory?: string;
+    prefix?: boolean;
+    exact?: boolean;
+    includeReferences?: boolean;
+    limit?: number;
+}
+export interface WorkspaceIndexEntry {
+    name: string;
+    kind: string;
+    file: string;
+    line: number;
+    source: 'script' | 'asset' | 'gui';
+    origin: 'workspace' | 'vanilla';
+    category?: string;
+    container?: string;
+    updatedAt?: number;
+    fileVersion?: number;
+}
+export interface LocalisationIndexQuery {
+    key?: string;
+    language?: string;
+    prefix?: boolean;
+    contains?: boolean;
+    caseSensitive?: boolean;
+    limit?: number;
+}
+export interface LocalisationIndexEntry {
+    key: string;
+    value: string;
+    file: string;
+    line: number;
+    language: string;
+}
+export interface IndexQueryResult<TEntry> {
+    status: 'ready' | 'partial' | 'indexing' | 'idle' | 'unavailable' | 'error';
+    totalCount: number;
+    entries: TEntry[];
+    indexedSymbolNames?: number;
+    indexUpdatedAt?: number;
+    error?: string;
+    _hint?: string;
+}
+export interface IndexHost {
+    ensureReady?(): Promise<void>;
+    invalidate?(filePath: string): Promise<void>;
+    queryWorkspace(query: WorkspaceIndexQuery): Promise<IndexQueryResult<WorkspaceIndexEntry>>;
+    queryLocalisation(query: LocalisationIndexQuery): Promise<IndexQueryResult<LocalisationIndexEntry>>;
+}

package/dist/host/indexing.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/host/lsp.d.ts

@@ -0,0 +1,8 @@
+export interface LspCommandOptions {
+    timeoutMs?: number;
+}
+export interface LspHost {
+    executeCommand<T = unknown>(command: string, args?: unknown[], options?: LspCommandOptions): Promise<T>;
+    request?<T = unknown>(method: string, params?: unknown, options?: LspCommandOptions): Promise<T>;
+}
+export declare function createUnavailableLspHost(message?: string): LspHost;

package/dist/host/lsp.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUnavailableLspHost = createUnavailableLspHost;
+function createUnavailableLspHost(message = 'CWTools LSP is not connected.') {
+    return {
+        async executeCommand() {
+            return {
+                ok: false,
+                status: 'unavailable',
+                error: {
+                    code: 'lsp_unavailable',
+                    message,
+                },
+            };
+        },
+        async request() {
+            return {
+                ok: false,
+                status: 'unavailable',
+                error: {
+                    code: 'lsp_unavailable',
+                    message,
+                },
+            };
+        },
+    };
+}

package/dist/host/readiness.d.ts

@@ -0,0 +1,11 @@
+import type { SharedToolResult } from '../tools/schema';
+export interface LspReadiness {
+    ready: boolean;
+    phase?: string;
+    inProgress?: boolean;
+    reason?: string;
+}
+export declare const LOAD_DEPENDENT_TOOLS: ReadonlySet<string>;
+export declare const READINESS_LOADING_WARNING = "CWTools is still loading the project (parsing vanilla + building types/rules); this result is not yet authoritative. Retry after loading completes.";
+export declare function parseReadiness(validationStatus: unknown): LspReadiness;
+export declare function annotateReadiness(toolName: string, result: SharedToolResult, readiness: LspReadiness | undefined): SharedToolResult;

package/dist/host/readiness.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.READINESS_LOADING_WARNING = exports.LOAD_DEPENDENT_TOOLS = void 0;
+exports.parseReadiness = parseReadiness;
+exports.annotateReadiness = annotateReadiness;
+// Semantic tools that need the game fully loaded to return trustworthy results.
+// get_pdx_block is excluded: it is plain in-workspace text extraction.
+exports.LOAD_DEPENDENT_TOOLS = new Set([
+    'query_types',
+    'query_rules',
+    'query_cwt_schema',
+    'search_rule_capabilities',
+    'explain_scope',
+    'parse_pdx_fragment',
+    'query_scope',
+    'get_completion_at',
+    'query_definition',
+    'query_definition_by_name',
+    'explore_pdx_project',
+    'query_references',
+    'get_diagnostics',
+    'query_scripted_effects',
+    'query_scripted_triggers',
+    'query_enums',
+    'query_static_modifiers',
+    'query_variables',
+    'get_entity_info',
+]);
+exports.READINESS_LOADING_WARNING = 'CWTools is still loading the project (parsing vanilla + building types/rules); this result is not yet authoritative. Retry after loading completes.';
+// Parse cwtools.ai.getValidationStatus into a readiness verdict. Pure; no IO.
+function parseReadiness(validationStatus) {
+    const rec = validationStatus && typeof validationStatus === 'object'
+        ? validationStatus
+        : {};
+    if (rec.ok === false || rec.status === 'unavailable') {
+        return { ready: false, reason: 'lsp_unavailable' };
+    }
+    const loading = rec.loading && typeof rec.loading === 'object'
+        ? rec.loading
+        : {};
+    const inProgress = loading.inProgress === true;
+    const phase = typeof loading.phase === 'string' ? loading.phase : undefined;
+    const everLoaded = phase !== undefined && phase !== 'not_started';
+    const ready = !inProgress && everLoaded;
+    return {
+        ready,
+        phase,
+        inProgress,
+        reason: ready ? undefined : inProgress ? `loading:${phase ?? 'unknown'}` : 'not_started',
+    };
+}
+// Mark a load-dependent result as `loading` (not a trustworthy empty answer) when
+// the game is not ready yet, so clients retry instead of trusting the result. Pure.
+function annotateReadiness(toolName, result, readiness) {
+    if (!readiness || !exports.LOAD_DEPENDENT_TOOLS.has(toolName))
+        return result;
+    if (readiness.ready) {
+        return { ...result, readiness };
+    }
+    return {
+        ...result,
+        ok: true,
+        status: 'loading',
+        readiness,
+        warnings: [...(result.warnings ?? []), exports.READINESS_LOADING_WARNING],
+        nextSteps: [
+            ...(result.nextSteps ?? []),
+            'Retry after the project finishes loading (poll get_diagnostics until freshness is fresh).',
+        ],
+    };
+}

package/dist/host/vanillaCache.d.ts

@@ -0,0 +1,12 @@
+import type { SharedToolResult } from '../tools/schema';
+export interface VanillaCacheStatus {
+    available: boolean;
+    source: 'mod_plus_vanilla' | 'mod_only';
+    cacheFile?: string;
+    gamePath?: string;
+    reason?: string;
+}
+export declare function vanillaCacheFileName(game: string | undefined): string | undefined;
+export declare const VANILLA_DEPENDENT_TOOLS: ReadonlySet<string>;
+export declare const VANILLA_UNAVAILABLE_WARNING = "Vanilla game cache is not loaded; results reflect mod files only. Vanilla IDs will not appear and mod references to vanilla definitions may be reported as undefined. Pass --cache <dir> (a built .cwb cache dir) or --game-path <dir> (a vanilla install to build from).";
+export declare function annotateVanillaCache(toolName: string, result: SharedToolResult, status: VanillaCacheStatus | undefined): SharedToolResult;

package/dist/host/vanillaCache.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VANILLA_UNAVAILABLE_WARNING = exports.VANILLA_DEPENDENT_TOOLS = void 0;
+exports.vanillaCacheFileName = vanillaCacheFileName;
+exports.annotateVanillaCache = annotateVanillaCache;
+// Game id -> `.cwb` prefix, mirroring GameLoader.fs getCachedFiles / Program.fs
+// checkOrSetGameCache. Keep in sync with the F# side.
+const GAME_CACHE_PREFIX = {
+    stellaris: 'stl',
+    hoi4: 'hoi4',
+    eu4: 'eu4',
+    eu5: 'eu5',
+    ck2: 'ck2',
+    ck3: 'ck3',
+    imperator: 'ir',
+    vic2: 'vic2',
+    vic3: 'vic3',
+};
+function vanillaCacheFileName(game) {
+    const prefix = GAME_CACHE_PREFIX[(game ?? 'stellaris').toLowerCase()];
+    return prefix ? `${prefix}.cwb` : undefined;
+}
+// Read-only tools whose results are only complete when vanilla data is loaded.
+// query_rules is excluded: it resolves from bundled CWT rules, not vanilla data.
+exports.VANILLA_DEPENDENT_TOOLS = new Set([
+    'query_types',
+    'get_completion_at',
+    'query_scope',
+    'query_definition',
+    'query_definition_by_name',
+    'explore_pdx_project',
+    'query_project_knowledge',
+    'query_references',
+    'get_diagnostics',
+    'query_scripted_effects',
+    'query_scripted_triggers',
+    'query_enums',
+    'query_static_modifiers',
+    'query_variables',
+    'get_entity_info',
+]);
+exports.VANILLA_UNAVAILABLE_WARNING = 'Vanilla game cache is not loaded; results reflect mod files only. Vanilla IDs will not appear and mod references to vanilla definitions may be reported as undefined. Pass --cache <dir> (a built .cwb cache dir) or --game-path <dir> (a vanilla install to build from).';
+// Attach vanilla-cache provenance to a vanilla-dependent tool result so external
+// agents never mistake a mod-only answer for a complete one. Pure; no IO.
+function annotateVanillaCache(toolName, result, status) {
+    if (!status || !exports.VANILLA_DEPENDENT_TOOLS.has(toolName))
+        return result;
+    const annotated = {
+        ...result,
+        vanillaCache: status,
+    };
+    if (!status.available) {
+        annotated.warnings = [...(result.warnings ?? []), exports.VANILLA_UNAVAILABLE_WARNING];
+    }
+    return annotated;
+}

package/dist/host/vsCodeHostServices.d.ts

@@ -0,0 +1,27 @@
+import type { HostServices } from './hostServices';
+export interface VsCodeHostServicesPorts {
+    workspaceRoot: string;
+    readonlyMode: boolean;
+    writesEnabled: boolean;
+    executeLspCommand<T = unknown>(command: string, args?: unknown[], timeoutMs?: number): Promise<T>;
+    getDiagnostics(args?: unknown): Promise<unknown>;
+    readTextFile(path: string): Promise<{
+        content: string;
+        hasBom: boolean;
+        exists: boolean;
+    }>;
+    writeTextFile(path: string, content: string): Promise<void>;
+    list(path: string): Promise<Array<{
+        name: string;
+        type: 'file' | 'directory';
+        size?: number;
+    }>>;
+    glob(pattern: string, options?: {
+        limit?: number;
+    }): Promise<string[]>;
+    queryWorkspaceIndex?(args: unknown): Promise<unknown>;
+    queryLocalisationIndex?(args: unknown): Promise<unknown>;
+    now?(): number;
+    log?(level: 'debug' | 'info' | 'warn' | 'error', message: string, data?: unknown): void;
+}
+export declare function createVsCodeHostServicesSkeleton(ports: VsCodeHostServicesPorts): HostServices;

package/dist/host/vsCodeHostServices.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVsCodeHostServicesSkeleton = createVsCodeHostServicesSkeleton;
+function createVsCodeHostServicesSkeleton(ports) {
+    return {
+        workspaceRoot: ports.workspaceRoot,
+        readonlyMode: ports.readonlyMode,
+        writesEnabled: ports.writesEnabled,
+        lsp: {
+            executeCommand: (command, args, options) => ports.executeLspCommand(command, args, options?.timeoutMs),
+        },
+        diagnostics: {
+            getDiagnostics: async (args) => ports.getDiagnostics(args),
+        },
+        filesystem: {
+            readTextFile: path => ports.readTextFile(path),
+            writeTextFile: (path, content) => ports.writeTextFile(path, content),
+            list: path => ports.list(path),
+            glob: (pattern, options) => ports.glob(pattern, options),
+        },
+        indexing: ports.queryWorkspaceIndex && ports.queryLocalisationIndex
+            ? {
+                queryWorkspace: async (query) => ports.queryWorkspaceIndex(query),
+                queryLocalisation: async (query) => ports.queryLocalisationIndex(query),
+            }
+            : undefined,
+        now: ports.now ?? (() => Date.now()),
+        log: ports.log ?? (() => undefined),
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+export * from './generated/mcpTools';
+export * from './host/diagnostics';
+export * from './host/filesystem';
+export * from './host/hostServices';
+export * from './host/indexing';
+export * from './host/lsp';
+export * from './host/readiness';
+export * from './host/vanillaCache';
+export * from './host/vsCodeHostServices';
+export * from './knowledge/diagnosticRouting';
+export * from './knowledge/gameKnowledge';
+export * from './knowledge/rules';
+export * from './knowledge/workflowHints';
+export * from './project/profile';
+export * from './project/knowledge';
+export * from './safety/localisation';
+export * from './safety/paths';
+export * from './safety/writes';
+export * from './tools/mcpSchema';
+export * from './tools/names';
+export * from './tools/pdxBlock';
+export * from './tools/registry';
+export * from './tools/schema';
+export * from './tools/symbols';
+export * from './tools/toolHandlers';

package/dist/index.js

@@ -0,0 +1,41 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./generated/mcpTools"), exports);
+__exportStar(require("./host/diagnostics"), exports);
+__exportStar(require("./host/filesystem"), exports);
+__exportStar(require("./host/hostServices"), exports);
+__exportStar(require("./host/indexing"), exports);
+__exportStar(require("./host/lsp"), exports);
+__exportStar(require("./host/readiness"), exports);
+__exportStar(require("./host/vanillaCache"), exports);
+__exportStar(require("./host/vsCodeHostServices"), exports);
+__exportStar(require("./knowledge/diagnosticRouting"), exports);
+__exportStar(require("./knowledge/gameKnowledge"), exports);
+__exportStar(require("./knowledge/rules"), exports);
+__exportStar(require("./knowledge/workflowHints"), exports);
+__exportStar(require("./project/profile"), exports);
+__exportStar(require("./project/knowledge"), exports);
+__exportStar(require("./safety/localisation"), exports);
+__exportStar(require("./safety/paths"), exports);
+__exportStar(require("./safety/writes"), exports);
+__exportStar(require("./tools/mcpSchema"), exports);
+__exportStar(require("./tools/names"), exports);
+__exportStar(require("./tools/pdxBlock"), exports);
+__exportStar(require("./tools/registry"), exports);
+__exportStar(require("./tools/schema"), exports);
+__exportStar(require("./tools/symbols"), exports);
+__exportStar(require("./tools/toolHandlers"), exports);

package/dist/knowledge/diagnosticRouting.d.ts

@@ -0,0 +1,13 @@
+export interface DiagnosticKnowledgeQuery {
+    code?: string;
+    message?: string;
+}
+export interface DiagnosticKnowledgeResult {
+    status: 'ready';
+    code?: string;
+    category: string;
+    explanation: string;
+    suggestedTools: string[];
+    nextSteps: string[];
+}
+export declare function analyzeDiagnosticKnowledge(query: DiagnosticKnowledgeQuery): DiagnosticKnowledgeResult;

package/dist/knowledge/diagnosticRouting.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeDiagnosticKnowledge = analyzeDiagnosticKnowledge;
+function analyzeDiagnosticKnowledge(query) {
+    const code = query.code?.trim();
+    const message = query.message?.toLowerCase() ?? '';
+    if (code?.startsWith('CW001') || message.includes('syntax')) {
+        return {
+            status: 'ready',
+            code,
+            category: 'syntax',
+            explanation: 'The diagnostic appears to be a parse or syntax error.',
+            suggestedTools: ['get_pdx_block', 'document_symbols', 'query_cwt_schema', 'query_rules'],
+            nextSteps: [
+                'Inspect the nearest complete block before editing.',
+                'Verify brace balance and rule syntax before writing.',
+            ],
+        };
+    }
+    if (message.includes('localisation') || message.includes('localization')) {
+        return {
+            status: 'ready',
+            code,
+            category: 'localisation',
+            explanation: 'The diagnostic appears related to localisation keys or YML files.',
+            suggestedTools: ['query_localisation_index', 'write_localisation', 'get_diagnostics'],
+            nextSteps: [
+                'Check whether the key already exists in the localisation index.',
+                'Use write_localisation for any YML mutation.',
+            ],
+        };
+    }
+    if (message.includes('scope')) {
+        return {
+            status: 'ready',
+            code,
+            category: 'scope',
+            explanation: 'The diagnostic appears related to an invalid or unexpected scope.',
+            suggestedTools: ['query_scope', 'query_cwt_schema', 'query_rules', 'get_completion_at'],
+            nextSteps: [
+                'Query the scope at the failing position.',
+                'Verify valid scope changes or trigger/effect syntax before editing.',
+            ],
+        };
+    }
+    return {
+        status: 'ready',
+        code,
+        category: 'general',
+        explanation: 'No specialized diagnostic route matched; use LSP and indexed evidence before editing.',
+        suggestedTools: ['get_diagnostics', 'explore_pdx_project', 'query_cwt_schema', 'query_definition_by_name', 'query_workspace_index'],
+        nextSteps: [
+            'Group similar diagnostics and inspect a representative block.',
+            'Verify identifiers through indexed tools before making changes.',
+        ],
+    };
+}

package/dist/knowledge/gameKnowledge.d.ts

@@ -0,0 +1,20 @@
+export interface GameKnowledgeCard {
+    id: string;
+    title: string;
+    facts: string[];
+}
+export interface GameKnowledgeResult {
+    status: 'ready' | 'partial';
+    source: 'stable-policy' | 'lsp-semantic-catalog';
+    game: string;
+    rulesGeneration?: number;
+    rulesContentHash?: string;
+    ruleCount?: number;
+    definitionTypeCount?: number;
+    cards: GameKnowledgeCard[];
+}
+/**
+ * Return stable routing policy plus current catalog metadata when supplied.
+ * Mutable game rules are deliberately not embedded in this package.
+ */
+export declare function queryGameKnowledge(game?: string, semanticCatalog?: unknown): GameKnowledgeResult;

package/dist/knowledge/gameKnowledge.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryGameKnowledge = queryGameKnowledge;
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+/**
+ * Return stable routing policy plus current catalog metadata when supplied.
+ * Mutable game rules are deliberately not embedded in this package.
+ */
+function queryGameKnowledge(game = 'paradox', semanticCatalog) {
+    const catalog = asRecord(semanticCatalog);
+    const rules = Array.isArray(catalog?.rules) ? catalog.rules : [];
+    const definitionTypes = Array.isArray(catalog?.definitionTypes) ? catalog.definitionTypes : [];
+    const hasCatalog = rules.length > 0 || definitionTypes.length > 0;
+    const resolvedGame = typeof catalog?.gameProfile === 'string' && catalog.gameProfile.trim()
+        ? catalog.gameProfile.toLowerCase()
+        : game.toLowerCase();
+    const cards = [
+        {
+            id: 'dynamic-evidence-routing',
+            title: 'Dynamic game evidence',
+            facts: [
+                'Obtain definition paths and identifier shapes from the active CWTools TypeDefs.',
+                'Obtain rule arguments, typed references, and scope constraints from active CWT/LSP queries.',
+                'Treat project and vanilla indexes as examples and dependency evidence; validate legality through current rules and diagnostics.',
+            ],
+        },
+    ];
+    if (hasCatalog) {
+        cards.push({
+            id: 'active-semantic-catalog',
+            title: 'Active semantic catalog',
+            facts: [
+                `${rules.length} rule aliases and ${definitionTypes.length} definition types are currently available.`,
+                'Use focused query_rules, query_types, query_cwt_schema, and query_scope calls to retrieve the exact facts needed for the current task.',
+            ],
+        });
+    }
+    return {
+        status: hasCatalog ? 'ready' : 'partial',
+        source: hasCatalog ? 'lsp-semantic-catalog' : 'stable-policy',
+        game: resolvedGame,
+        rulesGeneration: typeof catalog?.rulesGeneration === 'number' ? catalog.rulesGeneration : undefined,
+        rulesContentHash: typeof catalog?.rulesContentHash === 'string' ? catalog.rulesContentHash : undefined,
+        ruleCount: rules.length,
+        definitionTypeCount: definitionTypes.length,
+        cards,
+    };
+}