sdl-mcp 0.7.0 → 0.7.2

package/README.md

@@ -6,7 +6,12 @@
 
 # SDL-MCP
 
-[![npm version](https://img.shields.io/npm/v/sdl-mcp.svg)](https://www.npmjs.com/package/sdl-mcp) [![npm downloads](https://img.shields.io/npm/dm/sdl-mcp.svg)](https://www.npmjs.com/package/sdl-mcp) 
+![npm version](https://img.shields.io/npm/v/sdl-mcp.svg) ![npm downloads](https://img.shields.io/npm/dm/sdl-mcp.svg) ![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/GlitterKill/sdl-mcp/ci.yml?label=CI%20Builds)
+ ![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/GlitterKill/sdl-mcp/publish-native.yml?label=Rust%20Indexer%20Builds) ![GitHub commit activity](https://img.shields.io/github/commit-activity/w/GlitterKill/sdl-mcp) 
+
+
+
+
 
 <div align="right">
 <details>
@@ -42,20 +47,122 @@ Instead of opening large files first, SDL-MCP indexes repositories into symbol c
 - Faster iteration through incremental indexing and refresh workflows
 - Works across TypeScript, JavaScript, Python, Go, Java, C#, C, C++, PHP, Rust, Kotlin, and Shell
 
-## ChatGPT-5.3-Codex XHigh Overview
+## Claude Opus 4.6 High Overview
+
+Question: "Review the code for SDL-MCP and explain to potential new users what this MCP server does and the benefits of
+  using it."
+
+Response: "# What is SDL-MCP?
+
+  **SDL-MCP** (Symbol Delta Ledger - Model Context Protocol) is an MCP server that fundamentally changes how AI coding
+  assistants interact with your codebase. Instead of dumping entire files into the AI's context window, SDL-MCP provides
+   a structured, token-efficient way to give AI agents exactly the code context they need — and nothing more.
+
+  ---
+
+  ## The Problem It Solves
+
+  When AI assistants like Claude work with code, they typically read entire files — sometimes many files — to understand
+   enough context to help you. This is wasteful:
+
+  - **Context windows fill up fast.** A modest codebase can easily exceed token limits.
+  - **Irrelevant code dilutes focus.** The AI spends tokens processing code unrelated to your task.
+  - **No awareness of what changed.** Every interaction starts from scratch with no incremental understanding.
+
+  SDL-MCP addresses all three by maintaining a **persistent, indexed understanding** of your codebase and serving
+  context through a 4-rung escalation ladder.
+
+  ---
+
+  ## How It Works
+
+  ### 1. Symbol Indexing
+
+  SDL-MCP parses your TypeScript/JavaScript codebase using tree-sitter (or an optional Rust native indexer) and extracts
+   every function, class, interface, type, and variable into **Symbol Cards** — compact metadata records containing the
+  symbol's signature, a brief summary, dependency edges, and metrics like fan-in/out.
+
+  The stats speak for themselves: this repository has **11,475 symbols** across **1,553 files** with **261,813
+  dependency edges** tracked. A full card dump would cost ~2.3M tokens. The overview costs **825 tokens** — a **2,782x
+  compression ratio**.
+
+  ### 2. The Context Ladder (4 Rungs)
+
+  Instead of "here's the whole file," SDL-MCP provides context in escalating detail:
+
+  | Rung | What You Get | Token Cost | When Used |
+  |------|-------------|------------|-----------|
+  | **Symbol Cards** | Name, signature, summary, dependencies | ~50 tokens | Always start here |
+  | **Skeleton IR** | Signatures + control flow, bodies elided | ~200 tokens | Understanding structure |
+  | **Hot-Path Excerpt** | Only lines matching specific identifiers | ~500 tokens | Finding specific logic |
+  | **Full Code Window** | Complete source (gated, requires justification) | ~2,000 tokens | Last resort |
+
+  Most questions can be answered at rungs 1-2 without ever reading raw code.
+
+  ### 3. Graph Slices
+
+  When an AI needs to understand context around a task, SDL-MCP builds a **task-scoped subgraph** — a slice of related
+  symbols connected by call, import, and config edges, scored by relevance and bounded by a token budget. This means the
+   AI gets the 20-30 most relevant symbols for a task, not an arbitrary directory listing.
+
+  ### 4. Delta Packs
+
+  When code changes, SDL-MCP computes **diffs at the symbol level** — not line-level diffs, but semantic changes to
+  signatures, invariants, and side effects. It also computes a **blast radius**: which other symbols are affected by the
+   change, ranked by proximity and importance.
+
+  ### 5. Proof-of-Need Gating
+
+  Raw code access requires justification. The AI must specify *why* it needs the code, *what identifiers* it expects to
+  find, and *how many lines* it needs. Requests are audited. This prevents lazy "just read the whole file" patterns and
+  keeps token usage disciplined.
+
+  ---
+
+  ## Key Benefits
+
+  **For AI-assisted development:**
+
+  - **10-50x fewer tokens** per coding task compared to reading raw files
+  - **More relevant context** — graph-based slicing finds related code that directory-based approaches miss
+  - **Incremental understanding** — delta packs mean the AI doesn't re-read unchanged code
+  - **Audit trail** — every raw code access is logged with justification
+
+  **For large codebases:**
+
+  - Scales to thousands of files without blowing context windows
+  - Symbol-level tracking survives whitespace changes and trivial refactors
+  - SQLite-backed persistence means indexing happens once, not every session
+
+  **For teams:**
+
+  - Consistent context governance via configurable policies
+  - Blast radius analysis shows the ripple effects of changes before they land
+  - Works as a standard MCP server — compatible with any MCP-capable client
+
+  ---
 
-Question: "Review code and explain what this MCP server does and the benefits of using it."
+  ## Practical Setup
 
-Response: "SDL‑MCP is a Model Context Protocol (MCP) server that turns your codebase into a queryable, versioned knowledge system for AI agents. Instead of “reading files,” agents interact with a set of structured tools that can register repositories, index them, and retrieve precise, high-signal context about what matters for a task.
+  SDL-MCP runs as a CLI with 5 commands:
 
-At its core, SDL‑MCP builds and maintains a SQLite-backed symbol ledger: it indexes files, extracts symbols (names, kinds, locations, signatures, summaries), and records dependency relationships like imports and call edges. That foundation enables fast, repeatable navigation from a question (“where is this used?”) to the exact set of relevant code elements, without the noise and cost of full-file context.
+  ```bash
+  sdl-mcp init      # Create config + database
+  sdl-mcp index     # Index your repositories
+  sdl-mcp serve     # Start the MCP server (stdio or HTTP)
+  sdl-mcp doctor    # Health check
+  sdl-mcp version   # Version info
 
-On top of the ledger, SDL‑MCP provides practical developer workflows as tools: search for symbols, fetch a detailed “symbol card,” and automatically build focused graph slices that capture the most relevant surrounding code for a given task. It also supports deltas and blast-radius analysis between versions, plus PR risk analysis to help
-prioritize what to review and what to test.
+  Once running, any MCP client (Claude Code, Claude Desktop, etc.) connects to it and gains access to 13 tools for
+  navigating your codebase efficiently.
 
-SDL‑MCP is built for responsible code access. When raw code is necessary, it offers graduated options—skeleton views (structure without full bodies), hot-path excerpts (only matching identifiers with context), and a policy-gated “need window” request for full code. Policies enforce limits and require intent signals (like identifiers), reducing overexposure while still enabling effective debugging when it’s justified.
+  ---
+  In Summary
 
-The result is faster, cheaper, and safer agent assistance: less token burn, more relevant context, clearer change impact, and better governance through auditing of tool calls and policy decisions. It’s a code-intelligence layer that makes AI collaboration feel less like “chatting with a repo” and more like using a purpose-built engineering assistant."
+  SDL-MCP is a code context server that treats your codebase like a searchable knowledge graph rather than a pile of
+  text files. It gives AI assistants surgical access to exactly what they need, dramatically reducing token waste while
+  improving the quality of code understanding. Think of it as giving your AI a proper IDE-level understanding of your
+  code, rather than having it grep through files."
 
 ## Quick Start
 

package/config/sdlmcp.config.example.json

@@ -1,4 +1,6 @@
 {
+  "$schema": "./sdlmcp.config.schema.json",
+
   "repos": [
     {
       "repoId": "my-repo",
@@ -12,118 +14,43 @@
         "**/coverage/**"
       ],
       "languages": [
-        "ts",
-        "tsx",
-        "js",
-        "jsx",
-        "py",
-        "go",
-        "java",
-        "cs",
-        "c",
-        "cpp",
-        "php",
-        "rs",
-        "kt",
-        "sh"
+        "ts", "tsx", "js", "jsx",
+        "py", "go", "java", "cs",
+        "c", "cpp", "php", "rs",
+        "kt", "sh"
       ],
       "maxFileBytes": 2000000,
-      "includeNodeModulesTypes": true
-    },
-    {
-      "repoId": "zod-oss",
-      "rootPath": ".tmp/external-benchmarks/zod-oss",
-      "ignore": [
-        "**/node_modules/**",
-        "**/dist/**",
-        "**/lib/**",
-        "**/coverage/**",
-        "**/*.test.ts",
-        "**/*.spec.ts"
-      ],
-      "languages": [
-        "ts",
-        "tsx",
-        "js"
-      ]
-    },
-    {
-      "repoId": "preact-oss",
-      "rootPath": ".tmp/external-benchmarks/preact-oss",
-      "ignore": [
-        "**/node_modules/**",
-        "**/dist/**",
-        "**/build/**",
-        "**/coverage/**",
-        "**/*.test.ts",
-        "**/*.spec.ts",
-        "**/*.test.tsx",
-        "**/*.spec.tsx"
-      ],
-      "languages": [
-        "ts",
-        "tsx",
-        "js",
-        "jsx"
-      ]
-    },
-    {
-      "repoId": "flask-oss",
-      "rootPath": ".tmp/external-benchmarks/flask-oss",
-      "ignore": [
-        "**/.venv/**",
-        "**/venv/**",
-        "**/__pycache__/**",
-        "**/.pytest_cache/**",
-        "**/build/**",
-        "**/dist/**",
-        "**/*.pyc",
-        "**/tests/**"
-      ],
-      "languages": [
-        "py"
-      ]
-    },
-    {
-      "repoId": "ansible-lint-oss",
-      "rootPath": ".tmp/external-benchmarks/ansible-lint-oss",
-      "ignore": [
-        "**/.venv/**",
-        "**/venv/**",
-        "**/__pycache__/**",
-        "**/.pytest_cache/**",
-        "**/build/**",
-        "**/dist/**",
-        "**/*.pyc",
-        "**/test/**",
-        "**/tests/**",
-        "**/.tox/**"
-      ],
-      "languages": [
-        "py",
-        "sh"
-      ]
+      "includeNodeModulesTypes": true,
+      "packageJsonPath": null,
+      "tsconfigPath": null,
+      "workspaceGlobs": null
     }
   ],
+
   "dbPath": "./data/sdlmcp.sqlite",
+
   "policy": {
     "maxWindowLines": 180,
     "maxWindowTokens": 1400,
     "requireIdentifiers": true,
     "allowBreakGlass": true
   },
+
   "redaction": {
     "enabled": true,
     "includeDefaults": true,
     "patterns": []
   },
+
   "indexing": {
-    "concurrency": 4,
+    "concurrency": 8,
     "enableFileWatching": true,
     "maxWatchedFiles": 25000,
+    "workerPoolSize": null,
     "engine": "typescript",
     "watchDebounceMs": 300
   },
+
   "slice": {
     "defaultMaxCards": 60,
     "defaultMaxTokens": 12000,
@@ -133,6 +60,15 @@
       "config": 0.8
     }
   },
+
+  "diagnostics": {
+    "enabled": true,
+    "mode": "tsLS",
+    "maxErrors": 50,
+    "timeoutMs": 2000,
+    "scope": "changedFiles"
+  },
+
   "cache": {
     "enabled": true,
     "symbolCardMaxEntries": 2000,
@@ -140,8 +76,15 @@
     "graphSliceMaxEntries": 1000,
     "graphSliceMaxSizeBytes": 52428800
   },
+
+  "plugins": {
+    "paths": [],
+    "enabled": true,
+    "strictVersioning": true
+  },
+
   "semantic": {
-    "enabled": false,
+    "enabled": true,
     "alpha": 0.6,
     "provider": "mock",
     "model": "all-MiniLM-L6-v2",
@@ -150,11 +93,33 @@
     "summaryApiKey": null,
     "summaryApiBaseUrl": null,
     "summaryMaxConcurrency": 5,
-    "summaryBatchSize": 20
+    "summaryBatchSize": 20,
+    "ann": {
+      "enabled": false,
+      "m": 16,
+      "efConstruction": 200,
+      "efSearch": 50,
+      "maxElements": 200000
+    }
   },
+
   "prefetch": {
     "enabled": true,
     "maxBudgetPercent": 20,
     "warmTopN": 50
+  },
+
+  "tracing": {
+    "enabled": false,
+    "serviceName": "sdl-mcp",
+    "exporterType": "console",
+    "otlpEndpoint": null,
+    "sampleRate": 1.0
+  },
+
+  "parallelScorer": {
+    "enabled": false,
+    "poolSize": null,
+    "minBatchSize": null
   }
 }

package/config/sdlmcp.config.schema.json

@@ -410,7 +410,8 @@
       "properties": {
         "enabled": {
           "type": "boolean",
-          "default": false
+          "description": "Enable semantic reranking in symbol search",
+          "default": true
         },
         "alpha": {
           "type": "number",
@@ -506,7 +507,7 @@
         }
       },
       "default": {
-        "enabled": false,
+        "enabled": true,
         "alpha": 0.6,
         "provider": "mock",
         "model": "all-MiniLM-L6-v2",

package/dist/config/types.d.ts

@@ -7,9 +7,9 @@ export declare const RepoConfigSchema: z.ZodObject<{
     languages: z.ZodDefault<z.ZodArray<z.ZodEnum<["ts", "tsx", "js", "jsx", "py", "go", "java", "cs", "c", "cpp", "php", "rs", "kt", "sh"]>, "many">>;
     maxFileBytes: z.ZodDefault<z.ZodNumber>;
     includeNodeModulesTypes: z.ZodDefault<z.ZodBoolean>;
-    packageJsonPath: z.ZodOptional<z.ZodString>;
-    tsconfigPath: z.ZodOptional<z.ZodString>;
-    workspaceGlobs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    packageJsonPath: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    tsconfigPath: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    workspaceGlobs: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
 }, "strip", z.ZodTypeAny, {
     repoId: string;
     rootPath: string;
@@ -17,9 +17,9 @@ export declare const RepoConfigSchema: z.ZodObject<{
     languages: ("ts" | "tsx" | "js" | "jsx" | "py" | "go" | "java" | "cs" | "c" | "cpp" | "php" | "rs" | "kt" | "sh")[];
     maxFileBytes: number;
     includeNodeModulesTypes: boolean;
-    packageJsonPath?: string | undefined;
-    tsconfigPath?: string | undefined;
-    workspaceGlobs?: string[] | undefined;
+    packageJsonPath?: string | null | undefined;
+    tsconfigPath?: string | null | undefined;
+    workspaceGlobs?: string[] | null | undefined;
 }, {
     repoId: string;
     rootPath: string;
@@ -27,9 +27,9 @@ export declare const RepoConfigSchema: z.ZodObject<{
     languages?: ("ts" | "tsx" | "js" | "jsx" | "py" | "go" | "java" | "cs" | "c" | "cpp" | "php" | "rs" | "kt" | "sh")[] | undefined;
     maxFileBytes?: number | undefined;
     includeNodeModulesTypes?: boolean | undefined;
-    packageJsonPath?: string | undefined;
-    tsconfigPath?: string | undefined;
-    workspaceGlobs?: string[] | undefined;
+    packageJsonPath?: string | null | undefined;
+    tsconfigPath?: string | null | undefined;
+    workspaceGlobs?: string[] | null | undefined;
 }>;
 export type RepoConfig = z.infer<typeof RepoConfigSchema>;
 export declare const PolicyConfigSchema: z.ZodObject<{
@@ -100,7 +100,7 @@ export declare const IndexingConfigSchema: z.ZodObject<{
     concurrency: z.ZodDefault<z.ZodNumber>;
     enableFileWatching: z.ZodDefault<z.ZodBoolean>;
     maxWatchedFiles: z.ZodDefault<z.ZodNumber>;
-    workerPoolSize: z.ZodOptional<z.ZodNumber>;
+    workerPoolSize: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     engine: z.ZodDefault<z.ZodEnum<["typescript", "rust"]>>;
     watchDebounceMs: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
@@ -109,12 +109,12 @@ export declare const IndexingConfigSchema: z.ZodObject<{
     maxWatchedFiles: number;
     engine: "typescript" | "rust";
     watchDebounceMs: number;
-    workerPoolSize?: number | undefined;
+    workerPoolSize?: number | null | undefined;
 }, {
     concurrency?: number | undefined;
     enableFileWatching?: boolean | undefined;
     maxWatchedFiles?: number | undefined;
-    workerPoolSize?: number | undefined;
+    workerPoolSize?: number | null | undefined;
     engine?: "typescript" | "rust" | undefined;
     watchDebounceMs?: number | undefined;
 }>;
@@ -326,34 +326,34 @@ export declare const TracingConfigSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
     serviceName: z.ZodDefault<z.ZodString>;
     exporterType: z.ZodDefault<z.ZodEnum<["console", "otlp", "memory"]>>;
-    otlpEndpoint: z.ZodOptional<z.ZodString>;
+    otlpEndpoint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     sampleRate: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     enabled: boolean;
     serviceName: string;
     exporterType: "console" | "otlp" | "memory";
     sampleRate: number;
-    otlpEndpoint?: string | undefined;
+    otlpEndpoint?: string | null | undefined;
 }, {
     enabled?: boolean | undefined;
     serviceName?: string | undefined;
     exporterType?: "console" | "otlp" | "memory" | undefined;
-    otlpEndpoint?: string | undefined;
+    otlpEndpoint?: string | null | undefined;
     sampleRate?: number | undefined;
 }>;
 export type TracingConfig = z.infer<typeof TracingConfigSchema>;
 export declare const ParallelScorerConfigSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
-    poolSize: z.ZodOptional<z.ZodNumber>;
-    minBatchSize: z.ZodOptional<z.ZodNumber>;
+    poolSize: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    minBatchSize: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
 }, "strip", z.ZodTypeAny, {
     enabled: boolean;
-    poolSize?: number | undefined;
-    minBatchSize?: number | undefined;
+    poolSize?: number | null | undefined;
+    minBatchSize?: number | null | undefined;
 }, {
     enabled?: boolean | undefined;
-    poolSize?: number | undefined;
-    minBatchSize?: number | undefined;
+    poolSize?: number | null | undefined;
+    minBatchSize?: number | null | undefined;
 }>;
 export type ParallelScorerConfig = z.infer<typeof ParallelScorerConfigSchema>;
 export declare const AppConfigSchema: z.ZodObject<{
@@ -364,9 +364,9 @@ export declare const AppConfigSchema: z.ZodObject<{
         languages: z.ZodDefault<z.ZodArray<z.ZodEnum<["ts", "tsx", "js", "jsx", "py", "go", "java", "cs", "c", "cpp", "php", "rs", "kt", "sh"]>, "many">>;
         maxFileBytes: z.ZodDefault<z.ZodNumber>;
         includeNodeModulesTypes: z.ZodDefault<z.ZodBoolean>;
-        packageJsonPath: z.ZodOptional<z.ZodString>;
-        tsconfigPath: z.ZodOptional<z.ZodString>;
-        workspaceGlobs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        packageJsonPath: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        tsconfigPath: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        workspaceGlobs: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
     }, "strip", z.ZodTypeAny, {
         repoId: string;
         rootPath: string;
@@ -374,9 +374,9 @@ export declare const AppConfigSchema: z.ZodObject<{
         languages: ("ts" | "tsx" | "js" | "jsx" | "py" | "go" | "java" | "cs" | "c" | "cpp" | "php" | "rs" | "kt" | "sh")[];
         maxFileBytes: number;
         includeNodeModulesTypes: boolean;
-        packageJsonPath?: string | undefined;
-        tsconfigPath?: string | undefined;
-        workspaceGlobs?: string[] | undefined;
+        packageJsonPath?: string | null | undefined;
+        tsconfigPath?: string | null | undefined;
+        workspaceGlobs?: string[] | null | undefined;
     }, {
         repoId: string;
         rootPath: string;
@@ -384,9 +384,9 @@ export declare const AppConfigSchema: z.ZodObject<{
         languages?: ("ts" | "tsx" | "js" | "jsx" | "py" | "go" | "java" | "cs" | "c" | "cpp" | "php" | "rs" | "kt" | "sh")[] | undefined;
         maxFileBytes?: number | undefined;
         includeNodeModulesTypes?: boolean | undefined;
-        packageJsonPath?: string | undefined;
-        tsconfigPath?: string | undefined;
-        workspaceGlobs?: string[] | undefined;
+        packageJsonPath?: string | null | undefined;
+        tsconfigPath?: string | null | undefined;
+        workspaceGlobs?: string[] | null | undefined;
     }>, "many">;
     dbPath: z.ZodString;
     policy: z.ZodObject<{
@@ -442,7 +442,7 @@ export declare const AppConfigSchema: z.ZodObject<{
         concurrency: z.ZodDefault<z.ZodNumber>;
         enableFileWatching: z.ZodDefault<z.ZodBoolean>;
         maxWatchedFiles: z.ZodDefault<z.ZodNumber>;
-        workerPoolSize: z.ZodOptional<z.ZodNumber>;
+        workerPoolSize: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
         engine: z.ZodDefault<z.ZodEnum<["typescript", "rust"]>>;
         watchDebounceMs: z.ZodDefault<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
@@ -451,12 +451,12 @@ export declare const AppConfigSchema: z.ZodObject<{
         maxWatchedFiles: number;
         engine: "typescript" | "rust";
         watchDebounceMs: number;
-        workerPoolSize?: number | undefined;
+        workerPoolSize?: number | null | undefined;
     }, {
         concurrency?: number | undefined;
         enableFileWatching?: boolean | undefined;
         maxWatchedFiles?: number | undefined;
-        workerPoolSize?: number | undefined;
+        workerPoolSize?: number | null | undefined;
         engine?: "typescript" | "rust" | undefined;
         watchDebounceMs?: number | undefined;
     }>>;
@@ -628,33 +628,33 @@ export declare const AppConfigSchema: z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         serviceName: z.ZodDefault<z.ZodString>;
         exporterType: z.ZodDefault<z.ZodEnum<["console", "otlp", "memory"]>>;
-        otlpEndpoint: z.ZodOptional<z.ZodString>;
+        otlpEndpoint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         sampleRate: z.ZodDefault<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         enabled: boolean;
         serviceName: string;
         exporterType: "console" | "otlp" | "memory";
         sampleRate: number;
-        otlpEndpoint?: string | undefined;
+        otlpEndpoint?: string | null | undefined;
     }, {
         enabled?: boolean | undefined;
         serviceName?: string | undefined;
         exporterType?: "console" | "otlp" | "memory" | undefined;
-        otlpEndpoint?: string | undefined;
+        otlpEndpoint?: string | null | undefined;
         sampleRate?: number | undefined;
     }>>;
     parallelScorer: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
-        poolSize: z.ZodOptional<z.ZodNumber>;
-        minBatchSize: z.ZodOptional<z.ZodNumber>;
+        poolSize: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        minBatchSize: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     }, "strip", z.ZodTypeAny, {
         enabled: boolean;
-        poolSize?: number | undefined;
-        minBatchSize?: number | undefined;
+        poolSize?: number | null | undefined;
+        minBatchSize?: number | null | undefined;
     }, {
         enabled?: boolean | undefined;
-        poolSize?: number | undefined;
-        minBatchSize?: number | undefined;
+        poolSize?: number | null | undefined;
+        minBatchSize?: number | null | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
     repos: {
@@ -664,9 +664,9 @@ export declare const AppConfigSchema: z.ZodObject<{
         languages: ("ts" | "tsx" | "js" | "jsx" | "py" | "go" | "java" | "cs" | "c" | "cpp" | "php" | "rs" | "kt" | "sh")[];
         maxFileBytes: number;
         includeNodeModulesTypes: boolean;
-        packageJsonPath?: string | undefined;
-        tsconfigPath?: string | undefined;
-        workspaceGlobs?: string[] | undefined;
+        packageJsonPath?: string | null | undefined;
+        tsconfigPath?: string | null | undefined;
+        workspaceGlobs?: string[] | null | undefined;
     }[];
     dbPath: string;
     policy: {
@@ -699,7 +699,7 @@ export declare const AppConfigSchema: z.ZodObject<{
         maxWatchedFiles: number;
         engine: "typescript" | "rust";
         watchDebounceMs: number;
-        workerPoolSize?: number | undefined;
+        workerPoolSize?: number | null | undefined;
     } | undefined;
     diagnostics?: {
         enabled: boolean;
@@ -749,12 +749,12 @@ export declare const AppConfigSchema: z.ZodObject<{
         serviceName: string;
         exporterType: "console" | "otlp" | "memory";
         sampleRate: number;
-        otlpEndpoint?: string | undefined;
+        otlpEndpoint?: string | null | undefined;
     } | undefined;
     parallelScorer?: {
         enabled: boolean;
-        poolSize?: number | undefined;
-        minBatchSize?: number | undefined;
+        poolSize?: number | null | undefined;
+        minBatchSize?: number | null | undefined;
     } | undefined;
 }, {
     repos: {
@@ -764,9 +764,9 @@ export declare const AppConfigSchema: z.ZodObject<{
         languages?: ("ts" | "tsx" | "js" | "jsx" | "py" | "go" | "java" | "cs" | "c" | "cpp" | "php" | "rs" | "kt" | "sh")[] | undefined;
         maxFileBytes?: number | undefined;
         includeNodeModulesTypes?: boolean | undefined;
-        packageJsonPath?: string | undefined;
-        tsconfigPath?: string | undefined;
-        workspaceGlobs?: string[] | undefined;
+        packageJsonPath?: string | null | undefined;
+        tsconfigPath?: string | null | undefined;
+        workspaceGlobs?: string[] | null | undefined;
     }[];
     dbPath: string;
     policy: {
@@ -797,7 +797,7 @@ export declare const AppConfigSchema: z.ZodObject<{
         concurrency?: number | undefined;
         enableFileWatching?: boolean | undefined;
         maxWatchedFiles?: number | undefined;
-        workerPoolSize?: number | undefined;
+        workerPoolSize?: number | null | undefined;
         engine?: "typescript" | "rust" | undefined;
         watchDebounceMs?: number | undefined;
     } | undefined;
@@ -848,13 +848,13 @@ export declare const AppConfigSchema: z.ZodObject<{
         enabled?: boolean | undefined;
         serviceName?: string | undefined;
         exporterType?: "console" | "otlp" | "memory" | undefined;
-        otlpEndpoint?: string | undefined;
+        otlpEndpoint?: string | null | undefined;
         sampleRate?: number | undefined;
     } | undefined;
     parallelScorer?: {
         enabled?: boolean | undefined;
-        poolSize?: number | undefined;
-        minBatchSize?: number | undefined;
+        poolSize?: number | null | undefined;
+        minBatchSize?: number | null | undefined;
     } | undefined;
 }>;
 export type AppConfig = z.infer<typeof AppConfigSchema>;