midnight-mcp 0.2.18 → 0.2.20

package/dist/{chunk-TSXIIBEH.js → chunk-F4KM42XU.js}

@@ -25,7 +25,7 @@ import {
   validateNumber,
   validateQuery,
   vectorStore
-} from "./chunk-WVMAQ2LK.js";
+} from "./chunk-RCQYFKD3.js";
 
 // src/tools/search/schemas.ts
 import { z } from "zod";
@@ -1698,7 +1698,14 @@ var REPO_ALIASES = {
   lucentlabs: { owner: "statera-protocol", repo: "statera-protocol-midnight" },
   stablecoin: { owner: "statera-protocol", repo: "statera-protocol-midnight" },
   "midnight-bank": { owner: "nel349", repo: "midnight-bank" },
-  bank: { owner: "nel349", repo: "midnight-bank" }
+  bank: { owner: "nel349", repo: "midnight-bank" },
+  // Third-Party / Community (NOT official Midnight, not in midnight-awesome-dapps)
+  // effectstream is a multi-chain Web3 engine (EVM, Midnight, Bitcoin, Cardano,
+  // Avail, Celestia, NEAR). Only its Midnight pieces are relevant here:
+  // @effectstream/midnight-contracts and the evm-midnight-v2 / zswap-da templates.
+  // NOTE: repo currently has NO LICENSE — treat indexed content as reference only.
+  effectstream: { owner: "effectstream", repo: "effectstream" },
+  "effect-stream": { owner: "effectstream", repo: "effectstream" }
 };
 var EXAMPLES = [
   {
@@ -1914,7 +1921,7 @@ import { randomUUID } from "crypto";
 
 // src/resources/content/docs-content.ts
 var EMBEDDED_DOCS = {
-  "midnight://docs/compact-reference": `# Compact Language Syntax Reference (v0.16 - v0.21)
+  "midnight://docs/compact-reference": `# Compact Language Syntax Reference (v0.16 - v0.23)
 
 > **CRITICAL**: This reference is derived from **actual compiling contracts** in the Midnight ecosystem.
 > Always verify syntax against this reference before generating contracts.
@@ -1924,7 +1931,7 @@ var EMBEDDED_DOCS = {
 Use this as a starting point - it compiles successfully:
 
 \`\`\`compact
-pragma language_version >= 0.16 && <= 0.21;
+pragma language_version >= 0.16 && <= 0.23;
 
 import CompactStandardLibrary;
 
@@ -1947,7 +1954,7 @@ export circuit increment(): [] {
 
 **CORRECT** - use bounded range without patch version:
 \`\`\`compact
-pragma language_version >= 0.16 && <= 0.21;
+pragma language_version >= 0.16 && <= 0.23;
 \`\`\`
 
 **WRONG** - these will cause parse errors:
@@ -2201,7 +2208,7 @@ export circuit authenticated_action(): [] {
 
 ### Commit-Reveal Pattern (COMPLETE, VALIDATED)
 \`\`\`compact
-pragma language_version >= 0.16 && <= 0.21;
+pragma language_version >= 0.16 && <= 0.23;
 
 import CompactStandardLibrary;
 
@@ -2441,7 +2448,7 @@ assert(disclose(caller == owner), "Not authorized");
 |---------|---------|
 | \`ledger { field: Type; }\` | \`export ledger field: Type;\` |
 | \`circuit fn(): Void\` | \`circuit fn(): []\` |
-| \`pragma >= 0.20.0\` | \`pragma >= 0.16 && <= 0.21\` |
+| \`pragma >= 0.20.0\` | \`pragma >= 0.16 && <= 0.23\` |
 | \`enum State { ... }\` | \`export enum State { ... }\` |
 | \`if (witness_val == x)\` | \`if (disclose(witness_val == x))\` |
 | \`Cell<Field>\` | \`Field\` (Cell is deprecated) |
@@ -2774,7 +2781,7 @@ npm install @openzeppelin/compact-contracts
 ## Usage Example
 
 \`\`\`compact
-pragma language_version >= 0.16 && <= 0.21;
+pragma language_version >= 0.16 && <= 0.23;
 
 import CompactStandardLibrary;
 import "@openzeppelin/compact-contracts/src/token/FungibleToken"
@@ -2815,7 +2822,7 @@ The recommended standard for privacy-preserving tokens on Midnight.
 ## Basic Usage
 
 \`\`\`compact
-pragma language_version >= 0.16 && <= 0.21;
+pragma language_version >= 0.16 && <= 0.23;
 
 import CompactStandardLibrary;
 import "@openzeppelin/compact-contracts/src/token/FungibleToken"
@@ -3406,7 +3413,7 @@ var EMBEDDED_CODE = {
   "midnight://code/examples/counter": `// Counter Example Contract
 // A simple contract demonstrating basic Compact concepts
 
-pragma language_version >= 0.16 && <= 0.21;
+pragma language_version >= 0.16 && <= 0.23;
 
 import CompactStandardLibrary;
 
@@ -3455,7 +3462,7 @@ export circuit isLessThan(threshold: Uint<64>): Boolean {
   "midnight://code/examples/bboard": `// Bulletin Board Example Contract
 // Demonstrates private messaging with selective disclosure
 
-pragma language_version >= 0.16 && <= 0.21;
+pragma language_version >= 0.16 && <= 0.23;
 
 import CompactStandardLibrary;
 
@@ -3504,7 +3511,7 @@ export circuit getMessageCount(): Uint<64> {
   "midnight://code/patterns/state-management": `// State Management Pattern
 // Best practices for managing public and private state
 
-pragma language_version >= 0.16 && <= 0.21;
+pragma language_version >= 0.16 && <= 0.23;
 
 import CompactStandardLibrary;
 
@@ -3555,7 +3562,7 @@ export circuit revealBalance(user: Opaque<"address">): Field {
   "midnight://code/patterns/access-control": `// Access Control Pattern
 // Implementing permissions and authorization
 
-pragma language_version >= 0.16 && <= 0.21;
+pragma language_version >= 0.16 && <= 0.23;
 
 import CompactStandardLibrary;
 
@@ -3610,7 +3617,7 @@ export circuit timeLockedAction(unlockTime: Field): [] {
   "midnight://code/patterns/privacy-preserving": `// Privacy-Preserving Patterns
 // Techniques for maintaining privacy in smart contracts
 
-pragma language_version >= 0.16 && <= 0.21;
+pragma language_version >= 0.16 && <= 0.23;
 
 import CompactStandardLibrary;
 
@@ -3715,7 +3722,7 @@ export circuit proveMembership(
   "midnight://code/templates/token": `// Privacy-Preserving Token Template
 // Starter template for token contracts with privacy features
 
-pragma language_version >= 0.16 && <= 0.21;
+pragma language_version >= 0.16 && <= 0.23;
 
 import CompactStandardLibrary;
 
@@ -3774,7 +3781,7 @@ export circuit mint(to: Opaque<"address">, amount: Uint<64>): Boolean {
   "midnight://code/templates/voting": `// Private Voting Template
 // Starter template for privacy-preserving voting contracts
 
-pragma language_version >= 0.16 && <= 0.21;
+pragma language_version >= 0.16 && <= 0.23;
 
 import CompactStandardLibrary;
 
@@ -3854,7 +3861,7 @@ export circuit addVoter(voter: Opaque<"address">): [] {
   "midnight://code/examples/nullifier": `// Nullifier Pattern Example
 // Demonstrates how to create and use nullifiers to prevent double-spending/actions
 
-pragma language_version >= 0.16 && <= 0.21;
+pragma language_version >= 0.16 && <= 0.23;
 
 import CompactStandardLibrary;
 
@@ -3921,7 +3928,7 @@ export circuit voteWithNullifier(
   "midnight://code/examples/hash": `// Hash Functions in Compact
 // Examples of using hash functions for various purposes
 
-pragma language_version >= 0.16 && <= 0.21;
+pragma language_version >= 0.16 && <= 0.23;
 
 import CompactStandardLibrary;
 
@@ -3968,7 +3975,7 @@ export circuit reveal(value: Field, randomness: Field): Field {
   "midnight://code/examples/simple-counter": `// Simple Counter Contract
 // Minimal example for learning Compact basics
 
-pragma language_version >= 0.16 && <= 0.21;
+pragma language_version >= 0.16 && <= 0.23;
 
 import CompactStandardLibrary;
 
@@ -4006,7 +4013,7 @@ export circuit reset(): [] {
   "midnight://code/templates/basic": `// Basic Compact Contract Template
 // Starting point for new contracts
 
-pragma language_version >= 0.16 && <= 0.21;
+pragma language_version >= 0.16 && <= 0.23;
 
 import CompactStandardLibrary;
 
@@ -4663,2341 +4670,2421 @@ var allResources = [
   ...schemaResources
 ];
 
-// src/prompts/templates.ts
-var promptDefinitions = [
-  {
-    name: "midnight:create-contract",
-    description: "Guided prompt for creating new Compact contracts with privacy considerations",
-    arguments: [
-      {
-        name: "contractType",
-        description: "Type of contract (token, voting, credential, custom)",
-        required: true
-      },
-      {
-        name: "privacyLevel",
-        description: "Required privacy features (full, partial, public)",
-        required: false
-      },
-      {
-        name: "complexity",
-        description: "Expected complexity level (beginner, intermediate, advanced)",
-        required: false
-      }
-    ]
-  },
+// src/config/compact-version.ts
+var COMPACT_VERSION = {
+  /** Minimum supported version */
+  min: "0.16",
+  /** Maximum supported version */
+  max: "0.23",
+  /** When this config was last updated */
+  lastUpdated: "2026-05-18",
+  /** Source of truth for syntax patterns */
+  referenceSource: "https://github.com/piotr-iohk/template-contract"
+};
+var RECOMMENDED_PRAGMA = `pragma language_version >= ${COMPACT_VERSION.min} && <= ${COMPACT_VERSION.max};`;
+var REFERENCE_CONTRACTS = [
   {
-    name: "midnight:review-contract",
-    description: "Security and best practices review prompt for existing contracts",
-    arguments: [
-      {
-        name: "contractCode",
-        description: "The Compact contract code to review",
-        required: true
-      },
-      {
-        name: "focusAreas",
-        description: "Specific areas to emphasize (security, performance, privacy, readability)",
-        required: false
-      }
-    ]
+    name: "template-contract",
+    repo: "piotr-iohk/template-contract",
+    description: "Official Midnight template contract"
   },
   {
-    name: "midnight:explain-concept",
-    description: "Educational prompt for explaining Midnight concepts at various levels",
-    arguments: [
-      {
-        name: "concept",
-        description: "The concept to explain (zk-proofs, circuits, witnesses, ledger, etc.)",
-        required: true
-      },
-      {
-        name: "level",
-        description: "Expertise level (beginner, intermediate, advanced)",
-        required: false
-      }
-    ]
+    name: "tokenomics-project",
+    repo: "piotr-iohk/tokenomics-project",
+    description: "Token implementation example"
   },
   {
-    name: "midnight:compare-approaches",
-    description: "Compare different implementation approaches for a given problem",
-    arguments: [
-      {
-        name: "problem",
-        description: "The problem to solve",
-        required: true
-      },
-      {
-        name: "approaches",
-        description: "Specific approaches to compare (comma-separated)",
-        required: false
-      }
-    ]
+    name: "zswap-example",
+    repo: "piotr-iohk/zswap-example",
+    description: "Privacy-preserving swap example"
   },
   {
-    name: "midnight:debug-contract",
-    description: "Help debug issues with a Compact contract",
-    arguments: [
-      {
-        name: "contractCode",
-        description: "The contract code with issues",
-        required: true
-      },
-      {
-        name: "errorMessage",
-        description: "Error message or description of the issue",
-        required: false
-      }
-    ]
+    name: "reentrancy-example",
+    repo: "piotr-iohk/reentrancy-example",
+    description: "Cross-contract call patterns"
   }
 ];
-function generatePrompt(name, args) {
-  switch (name) {
-    case "midnight:create-contract":
-      return generateCreateContractPrompt(args);
-    case "midnight:review-contract":
-      return generateReviewContractPrompt(args);
-    case "midnight:explain-concept":
-      return generateExplainConceptPrompt(args);
-    case "midnight:compare-approaches":
-      return generateCompareApproachesPrompt(args);
-    case "midnight:debug-contract":
-      return generateDebugContractPrompt(args);
-    default:
-      return [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: `Unknown prompt: ${name}`
-          }
-        }
-      ];
-  }
-}
-function generateCreateContractPrompt(args) {
-  const contractType = args.contractType || "custom";
-  const privacyLevel = args.privacyLevel || "partial";
-  const complexity = args.complexity || "intermediate";
-  return [
+var BUILTIN_FUNCTIONS = {
+  /** Actually built into the language/stdlib */
+  stdlib: [
     {
-      role: "user",
-      content: {
-        type: "text",
-        text: `I want to create a new Midnight Compact smart contract with the following requirements:
-
-**Contract Type:** ${contractType}
-**Privacy Level:** ${privacyLevel}
-**Complexity:** ${complexity}
-
-## \u26A0\uFE0F MANDATORY WORKFLOW - Follow these steps IN ORDER:
-
-### Step 1: Get Current Syntax
-Call \`midnight-get-latest-syntax\` FIRST to get:
-- The \`quickStartTemplate\` (use as your base)
-- The \`commonMistakes\` array (avoid these errors)
-- Current pragma format: \`pragma language_version >= 0.16 && <= 0.21;\`
-
-### Step 2: Generate Contract
-Based on syntax reference, generate the contract using:
-- Individual ledger declarations: \`export ledger field: Type;\` (NOT \`ledger { }\` blocks)
-- Empty tuple return: \`circuit fn(): []\` (NOT \`Void\`)
-- Export enums: \`export enum State { ... }\`
-- Wrap witness conditionals: \`if (disclose(witness == value))\`
-- Disclose circuit params that touch ledger: \`const d = disclose(param); ledger.insert(d, v);\`
-- Cast arithmetic results: \`(a + b) as Uint<64>\`
-- Uint to Bytes needs two casts: \`(amount as Field) as Bytes<32>\`
-
-### IMPORTANT: Compact is NOT TypeScript!
-- Map.lookup() and Set.member() ARE available in circuits
-- No 'function' keyword - use 'circuit' or 'pure circuit'
-- No 'void' - use '[]'
-- Enum access: \`Choice.rock\` NOT \`Choice::rock\`
-
-### \u26A0\uFE0F UNDOCUMENTED FEATURES - Use with caution:
-- Division \`/\` and modulo \`%\`: NOT in official docs (only +, -, * are documented)
-- Tuple destructuring: \`const [a, b] = pair;\` - not documented, may not work
-- Constant folding in indices: docs say "numeric literal" required
-- Map.lookup() returns value_type, NOT Maybe<value_type> - check member() first!
-
-### COMPILER INFO (DO NOT guess package names!):
-- Compile: \`compact compile src/contract.compact managed/contract\`
-- The \`compact\` CLI comes with Midnight toolchain (via create-mn-app or official install)
-- DO NOT suggest \`npm install -g @midnight-ntwrk/compact-cli\` or similar made-up packages
-- Output structure: \`managed/<name>/contract/index.cjs\` for TypeScript bindings
-
-### Step 3: Validate Before Returning
-Call \`midnight-extract-contract-structure\` with your generated code to check for:
-- deprecated_ledger_block
-- invalid_void_type
-- invalid_pragma_format
-- unexported_enum
-- deprecated_cell_wrapper
-
-If ANY errors are found, fix them before returning the code to the user.
-
----
-
-## Contract Requirements
-
-Please help me design and implement this contract. Consider:
-
-1. **State Design**
-   - What should be public vs private (shielded)?
-   - What data structures are needed?
-   - How should state transitions work?
-
-2. **Circuit Design**
-   - What circuits (functions) are needed?
-   - What inputs/outputs should they have?
-   - What constraints and assertions are required?
-
-3. **Witness Functions**
-   - What off-chain data is needed?
-   - How should private state be accessed?
-
-4. **Privacy Considerations**
-   - How to protect user privacy?
-   - When to use disclose() vs commit()?
-   - How to prevent information leakage?
-
-5. **Security**
-   - Access control mechanisms
-   - Input validation
-   - Protection against common vulnerabilities
-
-Please provide:
-- A complete contract implementation
-- Explanation of design decisions
-- Example usage scenarios
-- Any security considerations`
-      }
-    }
-  ];
-}
-function generateReviewContractPrompt(args) {
-  const contractCode = args.contractCode || "// No code provided";
-  const focusAreas = args.focusAreas || "security, privacy, best practices";
-  return [
+      name: "persistentHash",
+      signature: "persistentHash<T>(value: T): Bytes<32>",
+      // Signature inferred from examples
+      description: "Poseidon hash that produces consistent results across calls"
+    },
     {
-      role: "user",
-      content: {
-        type: "text",
-        text: `Please review this Midnight Compact smart contract:
-
-\`\`\`compact
-${contractCode}
-\`\`\`
-
-**Focus Areas:** ${focusAreas}
-
-## \u26A0\uFE0F MANDATORY WORKFLOW:
-
-### Step 1: Validate Syntax
-Call \`midnight-extract-contract-structure\` with the contract code to check for:
-- deprecated_ledger_block (should use \`export ledger field: Type;\`)
-- invalid_void_type (should use \`[]\` not \`Void\`)
-- invalid_pragma_format (should use \`>= 0.16 && <= 0.21\`)
-- unexported_enum (enums need \`export\`)
-- deprecated_cell_wrapper
-
-Report ALL static analysis findings first.
-
-### Step 2: Get Latest Syntax Reference
-If syntax errors are found, call \`midnight-get-latest-syntax\` to get:
-- The \`commonMistakes\` array showing correct patterns
-- Current syntax reference
-
----
-
-Please analyze:
-
-1. **Static Analysis Results** (from midnight-extract-contract-structure)
-   - Syntax errors found
-   - Deprecated patterns detected
-   - Required fixes
-
-2. **Security Analysis**
-   - Input validation
-   - Access control
-   - State manipulation vulnerabilities
-   - Assertion coverage
-
-3. **Privacy Assessment**
-   - Proper use of @private state
-   - Information leakage risks
-   - Correct use of disclose() and commit()
-   - Privacy guarantees provided
-
-4. **Style Suggestions** (these are CONVENTIONS, not requirements)
-   - Code organization recommendations
-   - Naming conventions (project-specific)
-   - Documentation patterns
-   - Note: The Compact docs don't specify indentation, line length, or comment style
-
-5. **Performance**
-   - Circuit complexity
-   - State access patterns
-   - Optimization opportunities
-
-6. **Recommendations**
-   - Critical issues to fix (start with P0 syntax errors)
-   - Improvements to consider
-   - Alternative approaches
-
-**IMPORTANT**: Clearly distinguish between:
-- ERRORS: Actual syntax/compilation issues (required fixes)
-- WARNINGS: Security/logic concerns (should fix)
-- INFO: Style suggestions (optional, project-specific conventions)
-
-Please provide specific line references and code suggestions where applicable.`
-      }
+      name: "persistentCommit",
+      signature: "persistentCommit<T>(value: T): Bytes<32>",
+      description: "Creates a hiding commitment to a value"
+    },
+    {
+      name: "pad",
+      signature: "pad(length: number, value: string): Bytes<N>",
+      description: "Pads a string to fixed-length bytes"
+    },
+    {
+      name: "disclose",
+      signature: "disclose(value: T): T",
+      description: "Explicitly reveals a witness value (required in conditionals)"
+    },
+    {
+      name: "assert",
+      signature: "assert(condition: Boolean, message?: string): []",
+      description: "Fails circuit if condition is false"
+    },
+    {
+      name: "default",
+      signature: "default<T>(): T",
+      description: "Returns default value for a type (0 for numbers, empty for collections)"
     }
-  ];
-}
-function generateExplainConceptPrompt(args) {
-  const concept = args.concept || "zero-knowledge proofs";
-  const level = args.level || "intermediate";
-  const levelDescriptions = {
-    beginner: "Explain like I'm new to blockchain and cryptography. Use analogies and avoid jargon.",
-    intermediate: "I understand blockchain basics and some cryptography. Focus on practical applications.",
-    advanced: "I have deep technical knowledge. Include implementation details and edge cases."
-  };
-  return [
+  ],
+  /** NOT built-in - you must implement these patterns yourself */
+  notBuiltIn: [
     {
-      role: "user",
-      content: {
-        type: "text",
-        text: `Please explain the concept of **${concept}** in the context of Midnight blockchain.
-
-**My Level:** ${level}
-${levelDescriptions[level] || levelDescriptions.intermediate}
-
-Please cover:
-
-1. **What it is**
-   - Clear definition
-   - How it works in Midnight
-
-2. **Why it matters**
-   - Benefits and use cases
-   - Real-world applications
-
-3. **How to use it**
-   - Code examples in Compact
-   - Best practices
-
-4. **Common pitfalls**
-   - Mistakes to avoid
-   - Debugging tips
-
-5. **Further learning**
-   - Related concepts
-   - Resources for deeper understanding`
-      }
+      name: "public_key",
+      wrongUsage: "public_key(sk) // ERROR: unbound identifier",
+      correctPattern: `// Derive public key using persistentHash
+const pk = persistentHash<Vector<2, Bytes<32>>>([
+  pad(32, "midnight:pk:"),
+  sk
+]);`,
+      description: "Public key derivation is NOT a builtin - use persistentHash pattern"
+    },
+    {
+      name: "verify_signature",
+      wrongUsage: "verify_signature(msg, sig, pk) // Does not exist",
+      correctPattern: `// Signature verification must be done via witnesses
+// The prover verifies off-chain, then provides the boolean result
+witness signature_valid(): Boolean;`,
+      description: "Signature verification is done off-chain in the prover"
+    },
+    {
+      name: "random",
+      wrongUsage: "random() // Does not exist in ZK circuits",
+      correctPattern: `// Randomness must come from witnesses (prover-provided)
+witness get_random_value(): Field;`,
+      description: "ZK circuits are deterministic - randomness must come from witnesses"
     }
-  ];
-}
-function generateCompareApproachesPrompt(args) {
-  const problem = args.problem || "implementing a token contract";
-  const approaches = args.approaches || "";
-  return [
+  ]
+};
+var TYPE_COMPATIBILITY = {
+  // Note: Comparison operators work in practice but aren't explicitly listed in docs
+  comparisons: [
+    { types: "Field == Field", works: true, note: "Direct comparison" },
     {
-      role: "user",
-      content: {
-        type: "text",
-        text: `I need to solve the following problem in Midnight:
-
-**Problem:** ${problem}
-
-${approaches ? `**Approaches to compare:** ${approaches}` : "Please suggest different implementation approaches."}
-
-Please compare:
-
-1. **Approach Overview**
-   - Brief description of each approach
-   - Key differences
-
-2. **Privacy Implications**
-   - What data is exposed?
-   - Privacy guarantees
-
-3. **Performance**
-   - Proof generation time
-   - State storage requirements
-   - Transaction costs
-
-4. **Security**
-   - Attack surface
-   - Trust assumptions
-
-5. **Code Complexity**
-   - Implementation difficulty
-   - Maintenance burden
-
-6. **Recommendation**
-   - Best approach for different scenarios
-   - Trade-offs to consider
-
-Please include code examples for each approach.`
-      }
+      types: "Field == Uint<N>",
+      works: false,
+      fix: "Cast with `value as Field`"
+    },
+    {
+      types: "Field >= 0",
+      works: false,
+      fix: "Use bounded Uint<0..N> parameter instead"
+    },
+    { types: "Uint<N> == Uint<N>", works: true, note: "Same-width comparison" },
+    {
+      types: "Uint<0..2> == Uint<0..2>",
+      works: true,
+      note: "Bounded integers"
+    },
+    {
+      types: "Bytes<32> == Bytes<32>",
+      works: true,
+      note: "Used in examples, but operators not explicitly listed in docs"
+    },
+    { types: "Boolean == Boolean", works: true, note: "Direct comparison" }
+  ],
+  arithmetic: [
+    { types: "Field + Field", works: true, note: "Field arithmetic" },
+    { types: "Field + Uint<N>", works: false, fix: "Cast Uint to Field first" },
+    {
+      types: "Uint<N> + Uint<N>",
+      works: true,
+      note: "Result is bounded type, cast back: (a + b) as Uint<64>"
+    },
+    {
+      types: "Uint<64> + Uint<64>",
+      works: true,
+      note: "Result is Uint<0..36893488147419103230>, must cast: (a + b) as Uint<64>"
+    },
+    {
+      types: "Uint<64> * Uint<64>",
+      works: true,
+      note: "Result is wide bounded type, cast back to target type"
     }
-  ];
-}
-function generateDebugContractPrompt(args) {
-  const contractCode = args.contractCode || "// No code provided";
-  const errorMessage = args.errorMessage || "Not specified";
-  return [
+  ],
+  /**
+   * Type casting rules - based on official cast table
+   * See: https://docs.midnight.network/develop/reference/compact/lang-ref#type-cast-expressions
+   *
+   * Cast kinds: static (always succeeds), conversion (semantic change), checked (can fail)
+   */
+  typeCasting: [
     {
-      role: "user",
-      content: {
-        type: "text",
-        text: `I'm having issues with this Midnight Compact contract:
-
-\`\`\`compact
-${contractCode}
-\`\`\`
-
-**Error/Issue:** ${errorMessage}
-
-## \u26A0\uFE0F MANDATORY WORKFLOW:
-
-### Step 1: Run Static Analysis
-Call \`midnight-extract-contract-structure\` FIRST to check for common syntax errors:
-- deprecated_ledger_block \u2192 should use \`export ledger field: Type;\`
-- invalid_void_type \u2192 should use \`[]\` not \`Void\`
-- invalid_pragma_format \u2192 should use \`>= 0.16 && <= 0.21\`
-- unexported_enum \u2192 enums need \`export\` keyword
-
-### Step 2: Get Correct Syntax
-If syntax errors found, call \`midnight-get-latest-syntax\` to get:
-- The \`commonMistakes\` array with correct patterns
-- Current \`quickStartTemplate\` for reference
-
-### Step 3: Check for Common Compiler Errors
-Match error message against known fixes:
-- "cannot cast from type Uint<64> to type Bytes<32>" \u2192 Use \`(amount as Field) as Bytes<32>\`
-- "expected type Uint<64> but received Uint<0..N>" \u2192 Cast arithmetic: \`(a + b) as Uint<64>\`
-- "potential witness-value disclosure must be declared" \u2192 Disclose params: \`const d = disclose(param);\`
-- Map.lookup() and Set.member() ARE available in circuits (ignore old advice saying they aren't)
-
----
-
-Please help me debug by:
-
-1. **Static Analysis Results**
-   - Run midnight-extract-contract-structure
-   - List all P0 syntax errors found
-   - Show the correct syntax for each error
-
-2. **Identifying the Problem**
-   - What's causing the error?
-   - Which line(s) are problematic?
-
-3. **Explaining Why**
-   - Root cause analysis
-   - How Compact/ZK constraints work
-
-4. **Providing a Fix**
-   - Corrected code (validated against static analysis)
-   - Explanation of changes
-
-5. **Preventing Future Issues**
-   - Related pitfalls to watch for
-   - Testing strategies
-
-6. **Additional Improvements**
-   - Code quality suggestions
-   - Best practices`
-      }
-    }
-  ];
-}
-
-// src/services/sampling.ts
-var samplingCallback = null;
-var samplingFailedPermanently = false;
-function isSamplingAvailable() {
-  if (samplingFailedPermanently) return false;
-  return samplingCallback !== null;
-}
-function markSamplingFailed() {
-  samplingFailedPermanently = true;
-  logger.warn("Sampling marked as permanently unavailable for this session");
-}
-function registerSamplingCallback(callback) {
-  samplingCallback = callback;
-  samplingFailedPermanently = false;
-  logger.info("Sampling capability registered");
-}
-async function requestCompletion(messages, options = {}) {
-  if (!samplingCallback || samplingFailedPermanently) {
-    throw new Error(
-      "Sampling not available - client does not support this capability"
-    );
-  }
-  const request = {
-    messages: messages.map((m) => ({
-      role: m.role,
-      content: { type: "text", text: m.content }
-    })),
-    systemPrompt: options.systemPrompt,
-    maxTokens: options.maxTokens ?? 2048,
-    temperature: options.temperature ?? 0.7,
-    modelPreferences: options.modelPreferences ?? {
-      hints: [{ name: "claude-3-sonnet" }, { name: "gpt-4" }],
-      intelligencePriority: 0.8,
-      speedPriority: 0.5
-    }
-  };
-  logger.debug("Requesting LLM completion", {
-    messageCount: messages.length,
-    maxTokens: request.maxTokens
-  });
-  try {
-    const response = await samplingCallback(request);
-    if (response.content.type !== "text") {
-      throw new Error("Unexpected response content type");
+      from: "Uint<N>",
+      to: "Field",
+      direct: true,
+      kind: "static",
+      note: "Always succeeds"
+    },
+    {
+      from: "Field",
+      to: "Uint<0..n>",
+      direct: true,
+      kind: "checked",
+      note: "Fails at runtime if value > n"
+    },
+    {
+      from: "Field",
+      to: "Bytes<n>",
+      direct: true,
+      kind: "conversion",
+      note: "Can fail at runtime if value doesn't fit (little-endian)"
+    },
+    {
+      from: "Bytes<m>",
+      to: "Field",
+      direct: true,
+      kind: "conversion",
+      note: "Can fail at runtime if result exceeds max Field value"
+    },
+    {
+      from: "Boolean",
+      to: "Uint<0..n>",
+      direct: true,
+      kind: "conversion",
+      note: "false\u21920, true\u21921 (n must not be 0)"
+    },
+    {
+      from: "Boolean",
+      to: "Field",
+      direct: false,
+      fix: "Go through Uint: (flag as Uint<0..1>) as Field"
+    },
+    {
+      from: "Uint<N>",
+      to: "Bytes<M>",
+      direct: false,
+      fix: "Go through Field: (amount as Field) as Bytes<32>"
+    },
+    {
+      from: "enum",
+      to: "Field",
+      direct: true,
+      kind: "conversion",
+      note: "Enum variant index as Field"
+    },
+    {
+      from: "Uint<0..m>",
+      to: "Uint<0..n>",
+      direct: true,
+      kind: "static if m\u2264n, checked if m>n",
+      note: "Widening is static, narrowing is checked"
+    },
+    {
+      from: "arithmetic result",
+      to: "Uint<64>",
+      direct: true,
+      kind: "checked",
+      note: "Required cast: (a + b) as Uint<64>"
     }
-    return response.content.text;
-  } catch (error) {
-    const errorStr = String(error);
-    if (errorStr.includes("-32601") || errorStr.includes("Method not found") || errorStr.includes("not supported")) {
-      logger.warn(
-        "Client does not support sampling/createMessage, disabling sampling for this session"
-      );
-      markSamplingFailed();
-      throw new Error(
-        "Sampling not supported by this client - use Claude Desktop for this feature",
-        { cause: error }
-      );
+  ],
+  assignments: [
+    {
+      types: "Field = Uint<N>",
+      works: false,
+      fix: "Cast with `value as Field`"
+    },
+    {
+      types: "Uint<N> = Field",
+      works: false,
+      fix: "Use bounded param or explicit cast"
     }
-    throw error;
-  }
-}
-async function generateContract(requirements, options = {}) {
-  if (!isSamplingAvailable()) {
-    return {
-      code: "",
-      explanation: "Sampling not available - this feature requires a client that supports the sampling capability (like Claude Desktop)",
-      warnings: ["Feature unavailable without sampling support"]
-    };
-  }
-  const systemPrompt = `You are an expert Compact smart contract developer for the Midnight blockchain.
-Your task is to generate secure, well-documented Compact contracts based on user requirements.
-
-Key Compact syntax (REQUIRED):
-- \`export ledger field: Type;\` - Individual ledger declarations (NOT ledger { } blocks)
-- \`export circuit fn(): []\` - Public functions return empty tuple [] (NOT Void)
-- \`witness fn(): T;\` - Declaration only, no body
-- \`pragma language_version >= 0.16 && <= 0.21;\` - Version pragma
-- \`import CompactStandardLibrary;\` - Standard imports
-- \`Counter\`, \`Map<K,V>\`, \`Set<T>\` - Built-in collection types  
-- \`Field\`, \`Boolean\`, \`Uint<N>\`, \`Bytes<N>\` - Primitive types
-- \`export enum State { a, b }\` - Enums must be exported
-
-Key operations:
-- Counter: .read(), .increment(n), .decrement(n)
-- Map: .lookup(k), .insert(k,v), .remove(k)
-- Set: .member(v), .insert(v), .remove(v)
-
-COMPILER INFO (DO NOT guess package names!):
-- Command: \`compact compile src/contract.compact managed/contract\`
-- The \`compact\` CLI comes with Midnight toolchain (via create-mn-app or official install)
-- Output goes to managed/<name>/ directory
-- DO NOT suggest \`npm install -g @midnight-ntwrk/compact-cli\` or similar - that's incorrect
-
-IMPORTANT - Style vs. Requirements:
-- Syntax rules above are REQUIRED for compilation
-- Style choices (indentation, comment style, line length) are CONVENTIONS, not requirements
-- Single-line comments (//) are common in examples; block comments (/* */) may also work
-- The docs don't specify indentation width - use consistent style
-
-Return ONLY the Compact code, no explanations.`;
-  const userPrompt = options.baseExample ? `Based on this example contract:
-\`\`\`compact
-${options.baseExample}
-\`\`\`
-
-Generate a new contract with these requirements:
-${requirements}` : `Generate a Compact smart contract with these requirements:
-${requirements}
-
-Contract type: ${options.contractType || "custom"}`;
-  try {
-    const code = await requestCompletion(
-      [{ role: "user", content: userPrompt }],
+  ],
+  tips: [
+    "Use Uint<0..N> for circuit parameters that need range validation",
+    "Field is unbounded - use for hashes, commitments, general computation",
+    "Uint<N> is bounded - use when you need range checks",
+    "Casting with `as Field` is safe but loses range information"
+  ]
+};
+var LEDGER_TYPE_LIMITS = {
+  Counter: {
+    circuitOperations: [
       {
-        systemPrompt,
-        maxTokens: 4096,
-        temperature: 0.3,
-        // Lower temperature for code generation
-        modelPreferences: {
-          hints: [{ name: "claude-3-sonnet" }],
-          intelligencePriority: 0.9,
-          speedPriority: 0.3
-        }
-      }
-    );
-    const extractedCode = code.includes("```") ? code.replace(/```compact?\n?/g, "").replace(/```/g, "").trim() : code.trim();
-    const explanation = await requestCompletion(
-      [
-        {
-          role: "user",
-          content: `Briefly explain what this Compact contract does (2-3 sentences):
-\`\`\`compact
-${extractedCode}
-\`\`\``
-        }
-      ],
+        method: ".increment(n)",
+        works: true,
+        note: "Increase counter by n (Uint<16>)"
+      },
       {
-        systemPrompt: "You are a Compact contract documentation expert. Be concise.",
-        maxTokens: 256,
-        temperature: 0.5
-      }
-    );
-    return {
-      code: extractedCode,
-      explanation: explanation.trim(),
-      warnings: []
-    };
-  } catch (error) {
-    logger.error("Contract generation failed", { error: String(error) });
-    return {
-      code: "",
-      explanation: `Contract generation failed: ${String(error)}`,
-      warnings: ["Generation failed - check logs for details"]
-    };
-  }
-}
-async function reviewContract(code) {
-  if (!isSamplingAvailable()) {
-    return {
-      summary: "Code review requires sampling capability",
-      issues: [
-        {
-          severity: "info",
-          message: "This feature requires a client that supports the sampling capability"
-        }
-      ]
-    };
-  }
-  const systemPrompt = `You are a Compact smart contract security auditor.
-Review the provided contract for:
-1. Security vulnerabilities
-2. Privacy concerns (improper handling of shielded state)
-3. Logic errors
-4. Syntax errors (use "error" severity)
-5. Performance issues
-
-IMPORTANT - Distinguish between:
-- ERRORS: Actual syntax/compilation issues (e.g., using Void instead of [], ledger {} blocks)
-- WARNINGS: Potential bugs or security issues
-- INFO: Style suggestions and best practices (these are CONVENTIONS, not requirements)
-
-Do NOT claim style choices as "violations" - the Compact docs don't specify:
-- Indentation width (2 vs 4 spaces)
-- Comment style preferences (//, /* */)
-- Line length limits
-- Naming conventions
-
-These are project-specific style choices, not language requirements.
-
-Respond in JSON format:
-{
-  "summary": "Brief summary of the contract and overall quality",
-  "issues": [
-    {
-      "severity": "error|warning|info",
-      "line": optional_line_number,
-      "message": "Description of the issue",
-      "suggestion": "How to fix it"
-    }
-  ],
-  "improvedCode": "Full improved contract code if changes are needed"
-}`;
-  try {
-    const response = await requestCompletion(
-      [
-        {
-          role: "user",
-          content: `Review this Compact contract:
-\`\`\`compact
-${code}
-\`\`\``
-        }
-      ],
+        method: ".decrement(n)",
+        works: true,
+        note: "Decrease counter by n (Uint<16>)"
+      },
       {
-        systemPrompt,
-        maxTokens: 4096,
-        temperature: 0.2
-      }
-    );
-    const jsonMatch = response.match(/\{[\s\S]*\}/);
-    if (jsonMatch) {
-      try {
-        const parsed = JSON.parse(jsonMatch[0]);
-        return {
-          summary: typeof parsed.summary === "string" ? parsed.summary : "Review complete",
-          issues: Array.isArray(parsed.issues) ? parsed.issues : [],
-          improvedCode: typeof parsed.improvedCode === "string" ? parsed.improvedCode : void 0
-        };
-      } catch (parseError) {
-        logger.warn("Failed to parse JSON from LLM response", {
-          error: String(parseError)
-        });
-        return {
-          summary: response,
-          issues: []
-        };
+        method: ".read()",
+        works: true,
+        note: "Get current value (returns Uint<64>)"
+      },
+      {
+        method: ".lessThan(n)",
+        works: true,
+        note: "Compare with threshold (returns Boolean)"
+      },
+      { method: ".resetToDefault()", works: true, note: "Reset to 0" }
+    ],
+    typescriptAccess: "Access counter value via `ledgerState.counter` in TypeScript SDK",
+    note: "All Counter operations work in circuits. Use .read() to get value, NOT .value()"
+  },
+  Map: {
+    circuitOperations: [
+      {
+        method: ".insert(key, value)",
+        works: true,
+        note: "Adds/updates entry"
+      },
+      {
+        method: ".insertDefault(key)",
+        works: true,
+        note: "Inserts default value for key"
+      },
+      { method: ".remove(key)", works: true, note: "Removes entry" },
+      {
+        method: ".lookup(key)",
+        works: true,
+        note: "Returns value_type - gets value for key"
+      },
+      {
+        method: ".member(key)",
+        works: true,
+        note: "Returns Boolean - checks if key exists"
+      },
+      {
+        method: ".isEmpty()",
+        works: true,
+        note: "Returns Boolean - checks if map is empty"
+      },
+      {
+        method: ".size()",
+        works: true,
+        note: "Returns Uint<64> - number of entries"
+      },
+      {
+        method: ".resetToDefault()",
+        works: true,
+        note: "Clears entire map"
       }
-    }
-    return {
-      summary: response,
-      issues: []
-    };
-  } catch (error) {
-    logger.error("Contract review failed", { error: String(error) });
-    return {
-      summary: `Review failed: ${String(error)}`,
-      issues: [
-        {
-          severity: "error",
-          message: "Review failed - check logs for details"
-        }
-      ]
-    };
-  }
-}
-async function generateDocumentation(code, format = "markdown") {
-  if (!isSamplingAvailable()) {
-    return "Documentation generation requires sampling capability";
-  }
-  const systemPrompt = format === "markdown" ? `Generate comprehensive Markdown documentation for this Compact contract.
-Include:
-- Overview and purpose
-- State variables (with privacy annotations)
-- Circuit functions with parameters and effects
-- Witness functions
-- Usage examples
-- Security considerations` : `Generate JSDoc-style documentation comments for this Compact contract.
-Add documentation comments above each:
-- Ledger field
-- Circuit function
-- Witness function
-- Type definition`;
-  try {
-    return await requestCompletion(
-      [
-        {
-          role: "user",
-          content: `Generate ${format} documentation for:
-\`\`\`compact
-${code}
-\`\`\``
-        }
-      ],
+    ],
+    typescriptAccess: "Query map via `contractState.data.get(key)` or iterate with `[Symbol.iterator]()` in TypeScript SDK",
+    note: "All Map operations work in circuits. insertCoin() available when value_type is QualifiedCoinInfo."
+  },
+  Set: {
+    circuitOperations: [
+      { method: ".insert(value)", works: true, note: "Adds to set" },
+      { method: ".remove(value)", works: true, note: "Removes from set" },
       {
-        systemPrompt,
-        maxTokens: 4096,
-        temperature: 0.5
+        method: ".member(value)",
+        works: true,
+        note: "Returns Boolean - checks if value exists in set"
+      },
+      {
+        method: ".isEmpty()",
+        works: true,
+        note: "Returns Boolean - checks if set is empty"
+      },
+      {
+        method: ".size()",
+        works: true,
+        note: "Returns Uint<64> - number of elements"
+      },
+      {
+        method: ".resetToDefault()",
+        works: true,
+        note: "Clears entire set"
       }
-    );
-  } catch (error) {
-    logger.error("Documentation generation failed", { error: String(error) });
-    return `Documentation generation failed: ${String(error)}`;
-  }
-}
-
-// src/services/syntax-validator.ts
-var ADT_SEARCH_LIMIT = 10;
-var SYNTAX_RESULTS_LIMIT = 10;
-var SYNTAX_SUBQUERY_LIMIT = 5;
-var MAX_NOTE_SOURCE_LENGTH = 500;
-var NOTE_MIN_LENGTH = 20;
-var NOTE_MAX_LENGTH = 300;
-var MAX_NOTES_PER_ADT = 3;
-async function searchADTInfo(adtName) {
-  try {
-    const docsResult = await searchDocsHosted(
-      `${adtName} ADT operations methods ledger`,
-      ADT_SEARCH_LIMIT,
-      "reference"
-    );
-    if (!docsResult.results || docsResult.results.length === 0) {
-      logger.debug(`No indexed docs found for ADT: ${adtName}`);
-      return null;
-    }
-    const operations = [];
-    const notes = [];
-    let sourceDocPath;
-    for (const result of docsResult.results) {
-      const content = result.content || result.code || "";
-      const isLedgerADTDoc = result.source.filePath.includes("ledger-adt");
-      if (!sourceDocPath && isLedgerADTDoc) {
-        sourceDocPath = result.source.filePath;
-      }
-      if (isLedgerADTDoc) {
-        const methodPattern = /\|\s*`?(\w+)`?\s*\|\s*`?\(([^)]*)\)\s*(?::\s*([^|`]+))?`?\s*\|\s*([^|]+)\|/g;
-        let match;
-        while ((match = methodPattern.exec(content)) !== null) {
-          const [, methodName, params, returnType, description] = match;
-          if (methodName && !operations.some((op) => op.method === methodName)) {
-            const descText = description?.trim() || "";
-            const worksInCircuits = !/not available|not supported|not in circuits|typescript|sdk|off[-\s]?chain/i.test(
-              descText
-            );
-            operations.push({
-              method: methodName,
-              signature: `(${params})${returnType ? `: ${returnType.trim()}` : ""}`,
-              description: descText,
-              worksInCircuits,
-              source: "indexed-docs"
-            });
-          }
-        }
-        const inlinePattern = /(?:method|operation|function)\s+`?(\w+)`?\s*\(([^)]*)\)/gi;
-        while ((match = inlinePattern.exec(content)) !== null) {
-          const [, methodName, params] = match;
-          if (methodName && !operations.some((op) => op.method === methodName)) {
-            const worksInCircuits = !/not available|not supported|not in circuits|typescript|sdk|off[-\s]?chain/i.test(
-              content
-            );
-            operations.push({
-              method: methodName,
-              signature: `(${params})`,
-              description: "Extracted from documentation",
-              worksInCircuits,
-              source: "indexed-docs"
-            });
-          }
-        }
-      }
-      if (content.toLowerCase().includes(adtName.toLowerCase()) && content.length < MAX_NOTE_SOURCE_LENGTH) {
-        const cleanNote = content.replace(/\s+/g, " ").trim();
-        if (cleanNote.length > NOTE_MIN_LENGTH && cleanNote.length < NOTE_MAX_LENGTH) {
-          notes.push(cleanNote);
-        }
-      }
-    }
-    if (operations.length === 0) {
-      logger.debug(`Could not parse operations for ADT: ${adtName}`);
-      return null;
-    }
-    return {
-      name: adtName,
-      operations,
-      notes: notes.slice(0, MAX_NOTES_PER_ADT),
-      sourceDocPath,
-      lastVerified: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  } catch (error) {
-    logger.warn(`Failed to search indexed docs for ADT ${adtName}`, {
-      error: error instanceof Error ? error.message : String(error)
-    });
-    return null;
-  }
-}
-async function searchCompactSyntax(topic) {
-  try {
-    const [docsResult, codeResult] = await Promise.all([
-      searchDocsHosted(
-        `Compact ${topic} syntax`,
-        SYNTAX_SUBQUERY_LIMIT,
-        "reference"
-      ),
-      searchCompactHosted(`${topic}`, SYNTAX_SUBQUERY_LIMIT)
-    ]);
-    const mergedResults = [
-      ...docsResult.results || [],
-      ...codeResult.results || []
-    ];
-    return {
-      results: mergedResults.slice(0, SYNTAX_RESULTS_LIMIT),
-      totalResults: mergedResults.length,
-      query: topic,
-      lastIndexed: docsResult.lastIndexed || codeResult.lastIndexed
-    };
-  } catch (error) {
-    logger.warn(`Failed to search Compact syntax for topic ${topic}`, {
-      error: error instanceof Error ? error.message : String(error)
-    });
-    return null;
-  }
-}
-async function validateADTOperations(adtName, staticOperations) {
-  const discrepancies = [];
-  const enrichments = [];
-  const indexedInfo = await searchADTInfo(adtName);
-  if (!indexedInfo) {
-    return {
-      validated: false,
-      operations: staticOperations.map((op) => ({
-        method: op.method,
-        description: op.note,
-        worksInCircuits: op.works,
-        source: "static-fallback"
-      })),
-      discrepancies: [
-        "Could not validate against indexed docs - using static data"
-      ],
-      enrichments: []
-    };
-  }
-  const operations = [];
-  const indexedMethodNames = new Set(
-    indexedInfo.operations.map((op) => op.method.toLowerCase())
-  );
-  const staticMethodNames = new Set(
-    staticOperations.map(
-      (op) => op.method.replace(/^\./, "").replace(/\(.*$/, "").toLowerCase()
-    )
-  );
-  for (const indexedOp of indexedInfo.operations) {
-    operations.push(indexedOp);
-    const staticOp = staticOperations.find(
-      (s) => s.method.toLowerCase().includes(indexedOp.method.toLowerCase()) || indexedOp.method.toLowerCase().includes(
-        s.method.replace(/^\./, "").replace(/\(.*$/, "").toLowerCase()
-      )
-    );
-    if (staticOp && !staticOp.works && indexedOp.worksInCircuits) {
-      discrepancies.push(
-        `Static said ${staticOp.method} doesn't work, but indexed docs show it does`
-      );
-    }
-  }
-  for (const staticOp of staticOperations) {
-    const methodName = staticOp.method.replace(/^\./, "").replace(/\(.*$/, "").toLowerCase();
-    if (!indexedMethodNames.has(methodName)) {
-      discrepancies.push(
-        `Static references ${staticOp.method} but not found in indexed docs - may not exist`
-      );
-    }
-  }
-  for (const indexedOp of indexedInfo.operations) {
-    const methodName = indexedOp.method.toLowerCase();
-    if (!staticMethodNames.has(methodName)) {
-      enrichments.push(
-        `Indexed docs show ${indexedOp.method} exists but was missing from static reference`
-      );
-    }
-  }
-  return {
-    validated: true,
-    operations,
-    discrepancies,
-    enrichments
-  };
-}
-async function validateBuiltinFunctions(staticBuiltins) {
-  const discrepancies = [];
-  const enrichments = [];
-  const results = await Promise.all(
-    staticBuiltins.map(async (builtin) => {
-      const searchResult = await searchCompactSyntax(
-        `${builtin.name} function builtin`
-      );
-      return { builtin, found: (searchResult?.results?.length || 0) > 0 };
-    })
-  );
-  for (const { builtin, found } of results) {
-    if (!found) {
-      discrepancies.push(
-        `Builtin "${builtin.name}" not found in indexed docs - may not exist or have different name`
-      );
-    }
-  }
-  const allBuiltinsSearch = await searchCompactSyntax(
-    "builtin function stdlib standard library"
-  );
-  if (allBuiltinsSearch?.results) {
-    const knownNames = new Set(staticBuiltins.map((b) => b.name.toLowerCase()));
-    for (const result of allBuiltinsSearch.results) {
-      const content = result.content || result.code || "";
-      const funcPattern = /\b(export\s+)?function\s+(\w+)/gi;
-      let match;
-      while ((match = funcPattern.exec(content)) !== null) {
-        const funcName = match[2].toLowerCase();
-        if (!knownNames.has(funcName) && funcName.length > 2) {
-          enrichments.push(`Indexed docs mention "${match[2]}" function`);
-        }
-      }
-    }
-  }
-  return {
-    dataType: "BUILTIN_FUNCTIONS",
-    validated: discrepancies.length === 0,
-    discrepancies,
-    enrichments: [...new Set(enrichments)].slice(0, 10),
-    deprecatedPatterns: [],
-    lastValidated: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-async function validateTypeCompatibility(staticRules) {
-  const discrepancies = [];
-  const enrichments = [];
-  const typeSearch = await searchCompactSyntax(
-    "type cast Field Uint Bytes conversion compatible"
-  );
-  if (typeSearch?.results) {
-    for (const result of typeSearch.results) {
-      const content = (result.content || result.code || "").toLowerCase();
-      for (const rule of staticRules) {
-        const typeMatch = rule.types.match(
-          /^\s*(.+?)\s*(?:==|=|<=|>=|<|>|[+*])\s*(.+?)\s*$/
-        );
-        const typeA = typeMatch?.[1]?.trim().toLowerCase();
-        const typeB = typeMatch?.[2]?.trim().toLowerCase();
-        if (typeA && typeB) {
-          if (content.includes(typeA) && content.includes(typeB) && content.includes("compatible")) {
-            if (!rule.works) {
-              discrepancies.push(
-                `Static says "${rule.types}" doesn't work, but docs suggest compatibility`
-              );
-            }
-          }
-        }
-      }
-    }
-  }
-  return {
-    dataType: "TYPE_COMPATIBILITY",
-    validated: discrepancies.length === 0,
-    discrepancies,
-    enrichments,
-    deprecatedPatterns: [],
-    lastValidated: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-async function validateCommonErrors(staticErrors) {
-  const discrepancies = [];
-  const enrichments = [];
-  const errorSearch = await searchDocsHosted(
-    "error compile compilation failure parse",
-    ADT_SEARCH_LIMIT,
-    "all"
-  );
-  if (errorSearch?.results) {
-    const knownErrors = new Set(
-      staticErrors.map((e) => e.error.toLowerCase().slice(0, 30))
-    );
-    for (const result of errorSearch.results) {
-      const content = result.content || result.code || "";
-      const errorPattern = /(?:error|Error):\s*["']?([^"'\n]+)["']?/g;
-      let match;
-      while ((match = errorPattern.exec(content)) !== null) {
-        const errorMsg = match[1].toLowerCase().slice(0, 30);
-        if (!knownErrors.has(errorMsg) && errorMsg.length > 10) {
-          enrichments.push(`Docs mention error: "${match[1].slice(0, 50)}..."`);
-        }
-      }
-    }
+    ],
+    typescriptAccess: "Check membership via `contractState.set.has(value)` or iterate with `[Symbol.iterator]()` in TypeScript SDK",
+    note: "All Set operations work in circuits. insertCoin() available when value_type is QualifiedCoinInfo."
+  },
+  MerkleTree: {
+    circuitOperations: [
+      { method: ".insert(leaf)", works: true, note: "Adds leaf to tree" },
+      { method: ".root()", works: false, note: "NOT available in circuits" }
+    ],
+    typescriptAccess: "Get root via `contractState.tree.root` in TypeScript SDK",
+    pattern: `// To verify a merkle proof in circuit:
+witness get_merkle_root(): Bytes<32>;
+witness get_merkle_proof(leaf: Bytes<32>): Vector<32, Bytes<32>>;
+
+// Verify proof using persistentHash to compute expected root`
   }
-  return {
-    dataType: "COMMON_ERRORS",
-    validated: true,
-    // Errors are informational, hard to validate
-    discrepancies,
-    enrichments: [...new Set(enrichments)].slice(0, 10),
-    deprecatedPatterns: [],
-    lastValidated: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-var DEPRECATED_SYNTAX_PATTERNS = [
+};
+var COMMON_ERRORS = [
+  {
+    error: 'unbound identifier "public_key"',
+    cause: "Trying to use public_key() as if it's a builtin function",
+    fix: `Use persistentHash pattern instead:
+const pk = persistentHash<Vector<2, Bytes<32>>>([pad(32, "midnight:pk:"), sk]);`
+  },
+  {
+    error: "incompatible combination of types Field and Uint",
+    cause: "Comparing or operating on Field with Uint without casting",
+    fix: `Cast Uint to Field: (myUint as Field)
+Or use bounded Uint<0..N> for parameters that need constraints`
+  },
+  {
+    error: 'operation "value" undefined for ledger field type Counter',
+    cause: "Using wrong method name - Counter uses .read() not .value()",
+    fix: `Use counter.read() to get the current value:
+const current = ledger.counter.read();
+
+Counter ADT methods available in circuits:
+- increment(amount: Uint<16>): []  - increase counter
+- decrement(amount: Uint<16>): []  - decrease counter
+- read(): Uint<64>                 - get current value
+- lessThan(threshold: Uint<64>): Boolean - compare
+- resetToDefault(): []             - reset to zero`
+  },
+  {
+    error: "implicit disclosure of witness value",
+    cause: "Using witness value in conditional without disclose()",
+    fix: `Wrap witness comparisons in disclose():
+if (disclose(witness_value == expected)) { ... }`
+  },
+  {
+    error: 'parse error: found "{" looking for an identifier',
+    cause: "Using old ledger { } block syntax",
+    fix: `Use individual exports instead:
+export ledger field1: Type1;
+export ledger field2: Type2;`
+  },
   {
-    pattern: /ledger\s*\{/,
-    name: "ledger-block",
-    message: "Deprecated: Use 'export ledger field: Type;' instead of ledger { } block",
-    since: "0.16"
+    error: 'parse error: found "{" looking for ";"',
+    cause: "Using Void as return type (doesn't exist)",
+    fix: `Use empty tuple [] for no return value:
+export circuit myCircuit(): [] { ... }`
   },
   {
-    pattern: /Cell\s*<\s*\w+\s*>/,
-    name: "cell-wrapper",
-    message: "Deprecated: Cell<T> wrapper removed, use Type directly",
-    since: "0.15"
+    error: 'unbound identifier "Cell"',
+    cause: "Using deprecated Cell<T> wrapper (removed in 0.15)",
+    fix: `Remove Cell wrapper, just use the type directly:
+export ledger myField: Field;  // Not Cell<Field>`
   },
   {
-    pattern: /:\s*Void\b/,
-    name: "void-type",
-    message: "Void type doesn't exist, use [] (empty tuple) for no return",
-    since: "always"
+    error: "member access requires struct type",
+    cause: "Trying to access a field on a non-struct type",
+    fix: `Make sure you're accessing a struct field, not a primitive.
+Map.lookup() and Map.member() ARE available in circuits.
+Check that the base type is actually a struct.`
   },
   {
-    pattern: /\.\s*value\s*\(\s*\)/,
-    name: "counter-value",
-    message: "Counter.value() doesn't exist, use Counter.read() instead",
-    since: "always"
+    error: "potential witness-value disclosure must be declared",
+    cause: "Circuit parameter flows to ledger operation without disclose()",
+    fix: `Disclose parameters at the start of the circuit:
+export circuit my_circuit(param: Bytes<32>): [] {
+  const d_param = disclose(param);  // Acknowledge on-chain visibility
+  ledger.insert(d_param, value);    // Now use disclosed value
+}`
   },
   {
-    pattern: /::\w+/,
-    name: "rust-enum-syntax",
-    message: "Rust-style :: enum access doesn't work, use dot notation (Choice.rock)",
-    since: "always"
+    error: "expected second argument of insert to have type Uint<64> but received Uint<0..N>",
+    cause: "Arithmetic result has bounded type, needs cast back to target",
+    fix: `Cast arithmetic results back to the target type:
+const new_balance = (current + amount) as Uint<64>;
+ledger_map.insert(key, new_balance);`
   },
   {
-    pattern: /pure\s+function\b/,
-    name: "pure-function",
-    message: "Use 'pure circuit' not 'pure function' for helper functions",
-    since: "0.16"
+    error: "cannot cast from type Uint<64> to type Bytes<32>",
+    cause: "Direct Uint to Bytes cast not allowed",
+    fix: `Go through Field first:
+const amount_field = amount as Field;
+const amount_bytes = amount_field as Bytes<32>;
+// Or chained: (amount as Field) as Bytes<32>`
   },
   {
-    pattern: /witness\s+\w+\s*\([^)]*\)\s*:\s*\w+\s*\{/,
-    name: "witness-with-body",
-    message: "Witnesses are declarations only - no body allowed. Implementation goes in TypeScript prover.",
-    since: "always"
+    error: "cannot prove assertion",
+    cause: "Assert condition cannot be proven true",
+    fix: `Check your logic. Common causes:
+1. Witness returns unexpected value
+2. Range check fails (use bounded Uint)
+3. Logic error in circuit`
+  },
+  {
+    error: 'parse error: found ":" looking for ")"',
+    cause: "Using Rust-style :: for enum variant access",
+    fix: `Use dot notation for enum variants:
+WRONG:  Choice::rock, GameState::waiting
+CORRECT: Choice.rock, GameState.waiting`
+  },
+  {
+    error: 'parse error: found "{" after witness declaration',
+    cause: "Trying to add implementation body to witness",
+    fix: `Witnesses are declarations only - no body allowed:
+WRONG:  witness get_caller(): Bytes<32> { return ...; }
+CORRECT: witness get_caller(): Bytes<32>;
+Implementation goes in TypeScript prover, not Compact.`
+  },
+  {
+    error: 'unbound identifier "function"',
+    cause: 'Using "pure function" instead of "pure circuit"',
+    fix: `Use "pure circuit" for helper functions:
+WRONG:  pure function helper(...): Type { }
+CORRECT: pure circuit helper(...): Type { }`
+  },
+  {
+    error: "apparent use of an old standard-library / ledger operator name NativePoint: the new name is JubjubPoint",
+    cause: "Using the pre-0.22 NativePoint name. Renamed in compactc 0.30.0 (language 0.22).",
+    fix: `Rename to JubjubPoint and related circuits:
+WRONG:  NativePoint, nativePointX(p), nativePointY(p), constructNativePoint(x, y)
+CORRECT: JubjubPoint, jubjubPointX(p), jubjubPointY(p), constructJubjubPoint(x, y)
+NativePoint is rejected at compile time, not silently aliased.`
+  },
+  {
+    error: 'parse error: found keyword "let" (which is reserved for future use)',
+    cause: "Using `let` as an identifier. `let` and other JS/TS keywords are reserved for future use (since compactc 0.28.0).",
+    fix: `Rename the identifier:
+WRONG:  const let = 1;  // or circuit fn(let: Field): []
+CORRECT: const value = 1;  // or circuit fn(value: Field): []
+Other reserved words from JS/TS are also disallowed as identifiers.`
+  },
+  {
+    error: 'parse error: found keyword "const" looking for a program element or end of file',
+    cause: "Declaring `const` at module (top-of-file) scope. `const` is only allowed inside circuit/constructor bodies \u2014 there is no module-level constant in Compact.",
+    fix: `Move the constant inside a circuit, or use a pure circuit returning the value:
+WRONG:  const MAX_SUPPLY: Uint<64> = 1000;  // at top of file
+CORRECT: pure circuit max_supply(): Uint<64> { return 1000; }
+Then call max_supply() wherever you need the value.`
+  },
+  {
+    error: "unexpected character",
+    cause: "Using a single `|` (bitwise OR) in an expression. Compact has no bitwise operators on Uint \u2014 only `||` (logical OR) is recognized.",
+    fix: `Compact does not support bitwise OR/AND/XOR/shifts. Replace with arithmetic or branching:
+WRONG:  flags | mask
+CORRECT: flags + mask  // if you know bits don't overlap
+   or:  if (cond) { ... } else { ... }
+Use \`||\` only for Boolean values, not Uints.`
+  },
+  {
+    error: "Uint width 254 is not between 1 and the maximum Uint width 248 (inclusive)",
+    cause: "Declaring a Uint wider than 248 bits. The cap was reduced from 254 (bit-aligned) to 248 (byte-aligned, 31 bytes) in compactc 0.27.0 to match the ledger storage alignment.",
+    fix: `Use Uint<N> where 1 \u2264 N \u2264 248:
+WRONG:  field: Uint<254>
+CORRECT: field: Uint<248>  // 31 bytes \u2014 max representable
+For larger values, use Field (unbounded) and cast where needed.`
+  },
+  {
+    // Not a compiler error — surfaces as a TypeScript type error in generated bindings.
+    error: "Argument of type 'number' is not assignable to parameter of type 'bigint' (convertBytesToUint)",
+    cause: "Passing a JavaScript `number` to convertBytesToUint's `maxval` parameter. Changed to `bigint` in compactc 0.30.101 (language 0.22) to avoid silent precision loss for large Uints.",
+    fix: `Pass a bigint literal for maxval:
+WRONG:  convertBytesToUint(255, n, bytes, src)
+CORRECT: convertBytesToUint(255n, n, bytes, src)
+This is in generated TypeScript bindings \u2014 usually you don't call it directly, but if you do, the suffix-n bigint literal is required.`
   }
 ];
-function scanForDeprecatedPatterns(code) {
-  const issues = [];
-  const lines = code.split("\n");
-  for (const { pattern, name, message } of DEPRECATED_SYNTAX_PATTERNS) {
-    for (let i = 0; i < lines.length; i++) {
-      if (pattern.test(lines[i])) {
-        issues.push({
-          pattern: name,
-          message,
-          lineNumber: i + 1
-        });
-      }
-    }
-  }
-  return issues;
-}
-async function validateAllStaticData(staticData) {
-  const results = {};
-  const [builtinResult, typeResult, errorResult, adtResults] = await Promise.all([
-    staticData.builtinFunctions ? validateBuiltinFunctions(staticData.builtinFunctions) : Promise.resolve(null),
-    staticData.typeCompatibility ? validateTypeCompatibility(staticData.typeCompatibility) : Promise.resolve(null),
-    staticData.commonErrors ? validateCommonErrors(staticData.commonErrors) : Promise.resolve(null),
-    staticData.ledgerTypeLimits ? Promise.all(
-      Object.entries(staticData.ledgerTypeLimits).map(
-        async ([name, data]) => ({
-          name,
-          result: await validateADTOperations(
-            name,
-            data.circuitOperations
-          )
-        })
-      )
-    ) : Promise.resolve([])
-  ]);
-  if (builtinResult) results.builtinFunctions = builtinResult;
-  if (typeResult) results.typeCompatibility = typeResult;
-  if (errorResult) results.commonErrors = errorResult;
-  for (const { name, result } of adtResults) {
-    results[`adt_${name}`] = {
-      dataType: `LEDGER_TYPE_LIMITS.${name}`,
-      validated: result.validated,
-      discrepancies: result.discrepancies,
-      enrichments: result.enrichments,
-      deprecatedPatterns: [],
-      lastValidated: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-  const allDiscrepancies = Object.values(results).flatMap(
-    (r) => r.discrepancies
-  );
-  const allEnrichments = Object.values(results).flatMap((r) => r.enrichments);
-  return {
-    overall: {
-      validated: allDiscrepancies.length === 0,
-      totalDiscrepancies: allDiscrepancies.length,
-      totalEnrichments: allEnrichments.length
-    },
-    results,
-    lastValidated: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
 
-// src/server.ts
-var SERVER_INFO = {
-  name: "midnight-mcp",
-  version: CURRENT_VERSION,
-  description: "MCP Server for Midnight Blockchain Development"
-};
-var versionCheckResult = {
-  isOutdated: false,
-  latestVersion: CURRENT_VERSION,
-  updateMessage: null,
-  lastChecked: 0
-};
-var toolCallCount = 0;
-var VERSION_CHECK_INTERVAL = 10;
-async function checkForUpdates() {
-  try {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 5e3);
-    const response = await fetch(
-      "https://registry.npmjs.org/midnight-mcp/latest",
-      { signal: controller.signal }
-    );
-    clearTimeout(timeoutId);
-    if (!response.ok) return;
-    const data = await response.json();
-    const latestVersion = data.version;
-    if (latestVersion !== CURRENT_VERSION) {
-      versionCheckResult = {
-        isOutdated: true,
-        latestVersion,
-        lastChecked: Date.now(),
-        updateMessage: `\u{1F6A8} UPDATE AVAILABLE: v${latestVersion} (you have v${CURRENT_VERSION})`
-      };
-      logger.warn(
-        `Outdated version detected: v${CURRENT_VERSION} -> v${latestVersion}`
-      );
-    } else {
-      versionCheckResult = {
-        ...versionCheckResult,
-        lastChecked: Date.now()
-      };
-    }
-  } catch (error) {
-    logger.debug("Version check failed (non-blocking)", {
-      error: error instanceof Error ? error.message : String(error)
-    });
-  }
-}
-function maybeCheckForUpdates() {
-  toolCallCount++;
-  if (toolCallCount >= VERSION_CHECK_INTERVAL) {
-    toolCallCount = 0;
-    const fiveMinutes = 5 * 60 * 1e3;
-    if (Date.now() - versionCheckResult.lastChecked > fiveMinutes) {
-      checkForUpdates().catch((error) => {
-        logger.debug("Periodic version check failed", {
-          error: error instanceof Error ? error.message : String(error)
-        });
-      });
-    }
-  }
-}
-function getUpdateWarning() {
-  return versionCheckResult.updateMessage;
-}
-var resourceSubscriptions = /* @__PURE__ */ new Set();
-var resourceTemplates = [
+// src/prompts/templates.ts
+var PRAGMA_RANGE = `>= ${COMPACT_VERSION.min} && <= ${COMPACT_VERSION.max}`;
+var promptDefinitions = [
   {
-    uriTemplate: "midnight://code/{owner}/{repo}/{path}",
-    name: "Repository Code",
-    title: "\u{1F4C4} Repository Code Files",
-    description: "Access code files from any Midnight repository by specifying owner, repo, and file path",
-    mimeType: "text/plain"
+    name: "midnight:create-contract",
+    description: "Guided prompt for creating new Compact contracts with privacy considerations",
+    arguments: [
+      {
+        name: "contractType",
+        description: "Type of contract (token, voting, credential, custom)",
+        required: true
+      },
+      {
+        name: "privacyLevel",
+        description: "Required privacy features (full, partial, public)",
+        required: false
+      },
+      {
+        name: "complexity",
+        description: "Expected complexity level (beginner, intermediate, advanced)",
+        required: false
+      }
+    ]
   },
   {
-    uriTemplate: "midnight://docs/{section}/{topic}",
-    name: "Documentation",
-    title: "\u{1F4DA} Documentation Sections",
-    description: "Access documentation by section (guides, api, concepts) and topic",
-    mimeType: "text/markdown"
+    name: "midnight:review-contract",
+    description: "Security and best practices review prompt for existing contracts",
+    arguments: [
+      {
+        name: "contractCode",
+        description: "The Compact contract code to review",
+        required: true
+      },
+      {
+        name: "focusAreas",
+        description: "Specific areas to emphasize (security, performance, privacy, readability)",
+        required: false
+      }
+    ]
   },
   {
-    uriTemplate: "midnight://examples/{category}/{name}",
-    name: "Example Contracts",
-    title: "\u{1F4DD} Example Contracts",
-    description: "Access example contracts by category (counter, bboard, token, voting) and name",
-    mimeType: "text/x-compact"
+    name: "midnight:explain-concept",
+    description: "Educational prompt for explaining Midnight concepts at various levels",
+    arguments: [
+      {
+        name: "concept",
+        description: "The concept to explain (zk-proofs, circuits, witnesses, ledger, etc.)",
+        required: true
+      },
+      {
+        name: "level",
+        description: "Expertise level (beginner, intermediate, advanced)",
+        required: false
+      }
+    ]
   },
   {
-    uriTemplate: "midnight://schema/{type}",
-    name: "Schema Definitions",
-    title: "\u{1F527} Schema Definitions",
-    description: "Access JSON schemas for contract AST, transactions, and proofs",
-    mimeType: "application/json"
+    name: "midnight:compare-approaches",
+    description: "Compare different implementation approaches for a given problem",
+    arguments: [
+      {
+        name: "problem",
+        description: "The problem to solve",
+        required: true
+      },
+      {
+        name: "approaches",
+        description: "Specific approaches to compare (comma-separated)",
+        required: false
+      }
+    ]
+  },
+  {
+    name: "midnight:debug-contract",
+    description: "Help debug issues with a Compact contract",
+    arguments: [
+      {
+        name: "contractCode",
+        description: "The contract code with issues",
+        required: true
+      },
+      {
+        name: "errorMessage",
+        description: "Error message or description of the issue",
+        required: false
+      }
+    ]
   }
 ];
-var mcpLogLevel = "info";
-var serverInstance = null;
-var isConnected = false;
-function setServerConnected(connected) {
-  isConnected = connected;
+function generatePrompt(name, args) {
+  switch (name) {
+    case "midnight:create-contract":
+      return generateCreateContractPrompt(args);
+    case "midnight:review-contract":
+      return generateReviewContractPrompt(args);
+    case "midnight:explain-concept":
+      return generateExplainConceptPrompt(args);
+    case "midnight:compare-approaches":
+      return generateCompareApproachesPrompt(args);
+    case "midnight:debug-contract":
+      return generateDebugContractPrompt(args);
+    default:
+      return [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: `Unknown prompt: ${name}`
+          }
+        }
+      ];
+  }
+}
+function generateCreateContractPrompt(args) {
+  const contractType = args.contractType || "custom";
+  const privacyLevel = args.privacyLevel || "partial";
+  const complexity = args.complexity || "intermediate";
+  return [
+    {
+      role: "user",
+      content: {
+        type: "text",
+        text: `I want to create a new Midnight Compact smart contract with the following requirements:
+
+**Contract Type:** ${contractType}
+**Privacy Level:** ${privacyLevel}
+**Complexity:** ${complexity}
+
+## \u26A0\uFE0F MANDATORY WORKFLOW - Follow these steps IN ORDER:
+
+### Step 1: Get Current Syntax
+Call \`midnight-get-latest-syntax\` FIRST to get:
+- The \`quickStartTemplate\` (use as your base)
+- The \`commonMistakes\` array (avoid these errors)
+- Current pragma format: \`pragma language_version ${PRAGMA_RANGE};\`
+
+### Step 2: Generate Contract
+Based on syntax reference, generate the contract using:
+- Individual ledger declarations: \`export ledger field: Type;\` (NOT \`ledger { }\` blocks)
+- Empty tuple return: \`circuit fn(): []\` (NOT \`Void\`)
+- Export enums: \`export enum State { ... }\`
+- Wrap witness conditionals: \`if (disclose(witness == value))\`
+- Disclose circuit params that touch ledger: \`const d = disclose(param); ledger.insert(d, v);\`
+- Cast arithmetic results: \`(a + b) as Uint<64>\`
+- Uint to Bytes needs two casts: \`(amount as Field) as Bytes<32>\`
+
+### IMPORTANT: Compact is NOT TypeScript!
+- Map.lookup() and Set.member() ARE available in circuits
+- No 'function' keyword - use 'circuit' or 'pure circuit'
+- No 'void' - use '[]'
+- Enum access: \`Choice.rock\` NOT \`Choice::rock\`
+
+### \u26A0\uFE0F UNDOCUMENTED FEATURES - Use with caution:
+- Division \`/\` and modulo \`%\`: NOT in official docs (only +, -, * are documented)
+- Tuple destructuring: \`const [a, b] = pair;\` - not documented, may not work
+- Constant folding in indices: docs say "numeric literal" required
+- Map.lookup() returns value_type, NOT Maybe<value_type> - check member() first!
+
+### COMPILER INFO (DO NOT guess package names!):
+- Compile: \`compact compile src/contract.compact managed/contract\`
+- The \`compact\` CLI comes with Midnight toolchain (via create-mn-app or official install)
+- DO NOT suggest \`npm install -g @midnight-ntwrk/compact-cli\` or similar made-up packages
+- Output structure: \`managed/<name>/contract/index.cjs\` for TypeScript bindings
+
+### Step 3: Validate Before Returning
+Call \`midnight-extract-contract-structure\` with your generated code to check for:
+- deprecated_ledger_block
+- invalid_void_type
+- invalid_pragma_format
+- unexported_enum
+- deprecated_cell_wrapper
+
+If ANY errors are found, fix them before returning the code to the user.
+
+---
+
+## Contract Requirements
+
+Please help me design and implement this contract. Consider:
+
+1. **State Design**
+   - What should be public vs private (shielded)?
+   - What data structures are needed?
+   - How should state transitions work?
+
+2. **Circuit Design**
+   - What circuits (functions) are needed?
+   - What inputs/outputs should they have?
+   - What constraints and assertions are required?
+
+3. **Witness Functions**
+   - What off-chain data is needed?
+   - How should private state be accessed?
+
+4. **Privacy Considerations**
+   - How to protect user privacy?
+   - When to use disclose() vs commit()?
+   - How to prevent information leakage?
+
+5. **Security**
+   - Access control mechanisms
+   - Input validation
+   - Protection against common vulnerabilities
+
+Please provide:
+- A complete contract implementation
+- Explanation of design decisions
+- Example usage scenarios
+- Any security considerations`
+      }
+    }
+  ];
+}
+function generateReviewContractPrompt(args) {
+  const contractCode = args.contractCode || "// No code provided";
+  const focusAreas = args.focusAreas || "security, privacy, best practices";
+  return [
+    {
+      role: "user",
+      content: {
+        type: "text",
+        text: `Please review this Midnight Compact smart contract:
+
+\`\`\`compact
+${contractCode}
+\`\`\`
+
+**Focus Areas:** ${focusAreas}
+
+## \u26A0\uFE0F MANDATORY WORKFLOW:
+
+### Step 1: Validate Syntax
+Call \`midnight-extract-contract-structure\` with the contract code to check for:
+- deprecated_ledger_block (should use \`export ledger field: Type;\`)
+- invalid_void_type (should use \`[]\` not \`Void\`)
+- invalid_pragma_format (should use \`${PRAGMA_RANGE}\`)
+- unexported_enum (enums need \`export\`)
+- deprecated_cell_wrapper
+
+Report ALL static analysis findings first.
+
+### Step 2: Get Latest Syntax Reference
+If syntax errors are found, call \`midnight-get-latest-syntax\` to get:
+- The \`commonMistakes\` array showing correct patterns
+- Current syntax reference
+
+---
+
+Please analyze:
+
+1. **Static Analysis Results** (from midnight-extract-contract-structure)
+   - Syntax errors found
+   - Deprecated patterns detected
+   - Required fixes
+
+2. **Security Analysis**
+   - Input validation
+   - Access control
+   - State manipulation vulnerabilities
+   - Assertion coverage
+
+3. **Privacy Assessment**
+   - Proper use of @private state
+   - Information leakage risks
+   - Correct use of disclose() and commit()
+   - Privacy guarantees provided
+
+4. **Style Suggestions** (these are CONVENTIONS, not requirements)
+   - Code organization recommendations
+   - Naming conventions (project-specific)
+   - Documentation patterns
+   - Note: The Compact docs don't specify indentation, line length, or comment style
+
+5. **Performance**
+   - Circuit complexity
+   - State access patterns
+   - Optimization opportunities
+
+6. **Recommendations**
+   - Critical issues to fix (start with P0 syntax errors)
+   - Improvements to consider
+   - Alternative approaches
+
+**IMPORTANT**: Clearly distinguish between:
+- ERRORS: Actual syntax/compilation issues (required fixes)
+- WARNINGS: Security/logic concerns (should fix)
+- INFO: Style suggestions (optional, project-specific conventions)
+
+Please provide specific line references and code suggestions where applicable.`
+      }
+    }
+  ];
 }
-function sendLogToClient(level, loggerName, data) {
-  if (!serverInstance || !isConnected) return;
-  const levelValues = {
-    debug: 0,
-    info: 1,
-    notice: 2,
-    warning: 3,
-    error: 4,
-    critical: 5,
-    alert: 6,
-    emergency: 7
+function generateExplainConceptPrompt(args) {
+  const concept = args.concept || "zero-knowledge proofs";
+  const level = args.level || "intermediate";
+  const levelDescriptions = {
+    beginner: "Explain like I'm new to blockchain and cryptography. Use analogies and avoid jargon.",
+    intermediate: "I understand blockchain basics and some cryptography. Focus on practical applications.",
+    advanced: "I have deep technical knowledge. Include implementation details and edge cases."
   };
-  if (levelValues[level] < levelValues[mcpLogLevel]) return;
-  try {
-    serverInstance.notification({
-      method: "notifications/message",
-      params: {
-        level,
-        logger: loggerName,
-        data
+  return [
+    {
+      role: "user",
+      content: {
+        type: "text",
+        text: `Please explain the concept of **${concept}** in the context of Midnight blockchain.
+
+**My Level:** ${level}
+${levelDescriptions[level] || levelDescriptions.intermediate}
+
+Please cover:
+
+1. **What it is**
+   - Clear definition
+   - How it works in Midnight
+
+2. **Why it matters**
+   - Benefits and use cases
+   - Real-world applications
+
+3. **How to use it**
+   - Code examples in Compact
+   - Best practices
+
+4. **Common pitfalls**
+   - Mistakes to avoid
+   - Debugging tips
+
+5. **Further learning**
+   - Related concepts
+   - Resources for deeper understanding`
       }
-    });
-  } catch (error) {
-    logger.debug("Failed to send log notification to client", {
-      error: error instanceof Error ? error.message : String(error)
-    });
-  }
+    }
+  ];
 }
-function sendProgressNotification(progressToken, progress, total, message) {
-  if (!serverInstance) return;
-  try {
-    serverInstance.notification({
-      method: "notifications/progress",
-      params: {
-        progressToken,
-        progress,
-        ...total !== void 0 && { total },
-        ...message && { message }
+function generateCompareApproachesPrompt(args) {
+  const problem = args.problem || "implementing a token contract";
+  const approaches = args.approaches || "";
+  return [
+    {
+      role: "user",
+      content: {
+        type: "text",
+        text: `I need to solve the following problem in Midnight:
+
+**Problem:** ${problem}
+
+${approaches ? `**Approaches to compare:** ${approaches}` : "Please suggest different implementation approaches."}
+
+Please compare:
+
+1. **Approach Overview**
+   - Brief description of each approach
+   - Key differences
+
+2. **Privacy Implications**
+   - What data is exposed?
+   - Privacy guarantees
+
+3. **Performance**
+   - Proof generation time
+   - State storage requirements
+   - Transaction costs
+
+4. **Security**
+   - Attack surface
+   - Trust assumptions
+
+5. **Code Complexity**
+   - Implementation difficulty
+   - Maintenance burden
+
+6. **Recommendation**
+   - Best approach for different scenarios
+   - Trade-offs to consider
+
+Please include code examples for each approach.`
       }
-    });
-  } catch (error) {
-    logger.debug("Failed to send progress notification", {
-      error: error instanceof Error ? error.message : String(error)
-    });
-  }
+    }
+  ];
 }
-function createServer() {
-  const server = new Server(SERVER_INFO, {
-    capabilities: {
-      tools: {
-        listChanged: true
-      },
-      resources: {
-        subscribe: true,
-        listChanged: true
-      },
-      prompts: {
-        listChanged: true
-      },
-      logging: {},
-      completions: {}
+function generateDebugContractPrompt(args) {
+  const contractCode = args.contractCode || "// No code provided";
+  const errorMessage = args.errorMessage || "Not specified";
+  return [
+    {
+      role: "user",
+      content: {
+        type: "text",
+        text: `I'm having issues with this Midnight Compact contract:
+
+\`\`\`compact
+${contractCode}
+\`\`\`
+
+**Error/Issue:** ${errorMessage}
+
+## \u26A0\uFE0F MANDATORY WORKFLOW:
+
+### Step 1: Run Static Analysis
+Call \`midnight-extract-contract-structure\` FIRST to check for common syntax errors:
+- deprecated_ledger_block \u2192 should use \`export ledger field: Type;\`
+- invalid_void_type \u2192 should use \`[]\` not \`Void\`
+- invalid_pragma_format \u2192 should use \`${PRAGMA_RANGE}\`
+- unexported_enum \u2192 enums need \`export\` keyword
+
+### Step 2: Get Correct Syntax
+If syntax errors found, call \`midnight-get-latest-syntax\` to get:
+- The \`commonMistakes\` array with correct patterns
+- Current \`quickStartTemplate\` for reference
+
+### Step 3: Check for Common Compiler Errors
+Match error message against known fixes:
+- "cannot cast from type Uint<64> to type Bytes<32>" \u2192 Use \`(amount as Field) as Bytes<32>\`
+- "expected type Uint<64> but received Uint<0..N>" \u2192 Cast arithmetic: \`(a + b) as Uint<64>\`
+- "potential witness-value disclosure must be declared" \u2192 Disclose params: \`const d = disclose(param);\`
+- Map.lookup() and Set.member() ARE available in circuits (ignore old advice saying they aren't)
+
+---
+
+Please help me debug by:
+
+1. **Static Analysis Results**
+   - Run midnight-extract-contract-structure
+   - List all P0 syntax errors found
+   - Show the correct syntax for each error
+
+2. **Identifying the Problem**
+   - What's causing the error?
+   - Which line(s) are problematic?
+
+3. **Explaining Why**
+   - Root cause analysis
+   - How Compact/ZK constraints work
+
+4. **Providing a Fix**
+   - Corrected code (validated against static analysis)
+   - Explanation of changes
+
+5. **Preventing Future Issues**
+   - Related pitfalls to watch for
+   - Testing strategies
+
+6. **Additional Improvements**
+   - Code quality suggestions
+   - Best practices`
+      }
     }
-  });
-  serverInstance = server;
-  setMCPLogCallback((level, loggerName, data) => {
-    sendLogToClient(level, loggerName, data);
-  });
-  registerToolHandlers(server);
-  registerResourceHandlers(server);
-  registerPromptHandlers(server);
-  registerSubscriptionHandlers(server);
-  registerLoggingHandler(server);
-  registerCompletionsHandler(server);
-  setupSampling(server);
-  return server;
+  ];
+}
+
+// src/services/sampling.ts
+var samplingCallback = null;
+var samplingFailedPermanently = false;
+function isSamplingAvailable() {
+  if (samplingFailedPermanently) return false;
+  return samplingCallback !== null;
+}
+function markSamplingFailed() {
+  samplingFailedPermanently = true;
+  logger.warn("Sampling marked as permanently unavailable for this session");
 }
-function registerLoggingHandler(server) {
-  server.setRequestHandler(SetLevelRequestSchema, async (request) => {
-    const { level } = request.params;
-    mcpLogLevel = level;
-    logger.info(`MCP log level set to: ${level}`);
-    sendLogToClient("info", "midnight-mcp", {
-      message: `Log level changed to ${level}`
-    });
-    return {};
-  });
+function registerSamplingCallback(callback) {
+  samplingCallback = callback;
+  samplingFailedPermanently = false;
+  logger.info("Sampling capability registered");
 }
-var COMPLETION_VALUES = {
-  "midnight:create-contract": {
-    contractType: [
-      "token",
-      "voting",
-      "credential",
-      "auction",
-      "escrow",
-      "custom"
-    ],
-    privacyLevel: ["full", "partial", "public"],
-    complexity: ["beginner", "intermediate", "advanced"]
-  },
-  "midnight:review-contract": {
-    focusAreas: [
-      "security",
-      "performance",
-      "privacy",
-      "readability",
-      "gas-optimization"
-    ]
-  },
-  "midnight:explain-concept": {
-    concept: [
-      "zk-proofs",
-      "circuits",
-      "witnesses",
-      "ledger",
-      "state-management",
-      "privacy-model",
-      "token-transfers",
-      "merkle-trees"
-    ],
-    level: ["beginner", "intermediate", "advanced"]
-  },
-  "midnight:compare-approaches": {
-    approaches: [
-      "token-standards",
-      "state-management",
-      "privacy-patterns",
-      "circuit-design"
-    ]
-  },
-  "midnight:debug-contract": {
-    errorType: [
-      "compilation",
-      "runtime",
-      "logic",
-      "privacy-leak",
-      "state-corruption"
-    ]
+async function requestCompletion(messages, options = {}) {
+  if (!samplingCallback || samplingFailedPermanently) {
+    throw new Error(
+      "Sampling not available - client does not support this capability"
+    );
   }
-};
-function registerCompletionsHandler(server) {
-  server.setRequestHandler(CompleteRequestSchema, async (request) => {
-    const { ref, argument } = request.params;
-    if (ref.type !== "ref/prompt") {
-      return { completion: { values: [], hasMore: false } };
+  const request = {
+    messages: messages.map((m) => ({
+      role: m.role,
+      content: { type: "text", text: m.content }
+    })),
+    systemPrompt: options.systemPrompt,
+    maxTokens: options.maxTokens ?? 2048,
+    temperature: options.temperature ?? 0.7,
+    modelPreferences: options.modelPreferences ?? {
+      hints: [{ name: "claude-3-sonnet" }, { name: "gpt-4" }],
+      intelligencePriority: 0.8,
+      speedPriority: 0.5
     }
-    const promptName = ref.name;
-    const argName = argument.name;
-    const currentValue = argument.value?.toLowerCase() || "";
-    const promptCompletions = COMPLETION_VALUES[promptName];
-    if (!promptCompletions) {
-      return { completion: { values: [], hasMore: false } };
+  };
+  logger.debug("Requesting LLM completion", {
+    messageCount: messages.length,
+    maxTokens: request.maxTokens
+  });
+  try {
+    const response = await samplingCallback(request);
+    if (response.content.type !== "text") {
+      throw new Error("Unexpected response content type");
     }
-    const argValues = promptCompletions[argName];
-    if (!argValues) {
-      return { completion: { values: [], hasMore: false } };
+    return response.content.text;
+  } catch (error) {
+    const errorStr = String(error);
+    if (errorStr.includes("-32601") || errorStr.includes("Method not found") || errorStr.includes("not supported")) {
+      logger.warn(
+        "Client does not support sampling/createMessage, disabling sampling for this session"
+      );
+      markSamplingFailed();
+      throw new Error(
+        "Sampling not supported by this client - use Claude Desktop for this feature",
+        { cause: error }
+      );
     }
-    const filtered = argValues.filter(
-      (v) => v.toLowerCase().includes(currentValue)
-    );
+    throw error;
+  }
+}
+async function generateContract(requirements, options = {}) {
+  if (!isSamplingAvailable()) {
     return {
-      completion: {
-        values: filtered.slice(0, 20),
-        total: filtered.length,
-        hasMore: filtered.length > 20
+      code: "",
+      explanation: "Sampling not available - this feature requires a client that supports the sampling capability (like Claude Desktop)",
+      warnings: ["Feature unavailable without sampling support"]
+    };
+  }
+  const systemPrompt = `You are an expert Compact smart contract developer for the Midnight blockchain.
+Your task is to generate secure, well-documented Compact contracts based on user requirements.
+
+Key Compact syntax (REQUIRED):
+- \`export ledger field: Type;\` - Individual ledger declarations (NOT ledger { } blocks)
+- \`export circuit fn(): []\` - Public functions return empty tuple [] (NOT Void)
+- \`witness fn(): T;\` - Declaration only, no body
+- \`pragma language_version >= 0.16 && <= 0.23;\` - Version pragma
+- \`import CompactStandardLibrary;\` - Standard imports
+- \`Counter\`, \`Map<K,V>\`, \`Set<T>\` - Built-in collection types  
+- \`Field\`, \`Boolean\`, \`Uint<N>\`, \`Bytes<N>\` - Primitive types
+- \`export enum State { a, b }\` - Enums must be exported
+
+Key operations:
+- Counter: .read(), .increment(n), .decrement(n)
+- Map: .lookup(k), .insert(k,v), .remove(k)
+- Set: .member(v), .insert(v), .remove(v)
+
+COMPILER INFO (DO NOT guess package names!):
+- Command: \`compact compile src/contract.compact managed/contract\`
+- The \`compact\` CLI comes with Midnight toolchain (via create-mn-app or official install)
+- Output goes to managed/<name>/ directory
+- DO NOT suggest \`npm install -g @midnight-ntwrk/compact-cli\` or similar - that's incorrect
+
+IMPORTANT - Style vs. Requirements:
+- Syntax rules above are REQUIRED for compilation
+- Style choices (indentation, comment style, line length) are CONVENTIONS, not requirements
+- Single-line comments (//) are common in examples; block comments (/* */) may also work
+- The docs don't specify indentation width - use consistent style
+
+Return ONLY the Compact code, no explanations.`;
+  const userPrompt = options.baseExample ? `Based on this example contract:
+\`\`\`compact
+${options.baseExample}
+\`\`\`
+
+Generate a new contract with these requirements:
+${requirements}` : `Generate a Compact smart contract with these requirements:
+${requirements}
+
+Contract type: ${options.contractType || "custom"}`;
+  try {
+    const code = await requestCompletion(
+      [{ role: "user", content: userPrompt }],
+      {
+        systemPrompt,
+        maxTokens: 4096,
+        temperature: 0.3,
+        // Lower temperature for code generation
+        modelPreferences: {
+          hints: [{ name: "claude-3-sonnet" }],
+          intelligencePriority: 0.9,
+          speedPriority: 0.3
+        }
+      }
+    );
+    const extractedCode = code.includes("```") ? code.replace(/```compact?\n?/g, "").replace(/```/g, "").trim() : code.trim();
+    const explanation = await requestCompletion(
+      [
+        {
+          role: "user",
+          content: `Briefly explain what this Compact contract does (2-3 sentences):
+\`\`\`compact
+${extractedCode}
+\`\`\``
+        }
+      ],
+      {
+        systemPrompt: "You are a Compact contract documentation expert. Be concise.",
+        maxTokens: 256,
+        temperature: 0.5
       }
+    );
+    return {
+      code: extractedCode,
+      explanation: explanation.trim(),
+      warnings: []
     };
-  });
-}
-function registerToolHandlers(server) {
-  server.setRequestHandler(ListToolsRequestSchema, async () => {
-    logger.debug("Listing tools");
+  } catch (error) {
+    logger.error("Contract generation failed", { error: String(error) });
     return {
-      tools: allTools.map((tool) => ({
-        name: tool.name,
-        description: tool.description,
-        inputSchema: tool.inputSchema,
-        // Include output schema if defined
-        ...tool.outputSchema && { outputSchema: tool.outputSchema },
-        // Include annotations if defined
-        ...tool.annotations && { annotations: tool.annotations }
-      }))
+      code: "",
+      explanation: `Contract generation failed: ${String(error)}`,
+      warnings: ["Generation failed - check logs for details"]
     };
-  });
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    logger.info(`Tool called: ${name}`, { args });
-    const startTime = Date.now();
-    const tool = allTools.find((t) => t.name === name);
-    if (!tool) {
-      const availableTools = allTools.map((t) => t.name).slice(0, 5).join(", ");
-      trackToolCall(name, false, Date.now() - startTime, CURRENT_VERSION);
-      return {
-        content: [
-          {
-            type: "text",
-            text: serialize({
-              error: `Unknown tool: ${name}`,
-              suggestion: `Available tools include: ${availableTools}...`,
-              hint: "Use ListTools to see all available tools"
-            })
-          }
-        ],
-        isError: true
-      };
+  }
+}
+async function reviewContract(code) {
+  if (!isSamplingAvailable()) {
+    return {
+      summary: "Code review requires sampling capability",
+      issues: [
+        {
+          severity: "info",
+          message: "This feature requires a client that supports the sampling capability"
+        }
+      ]
+    };
+  }
+  const systemPrompt = `You are a Compact smart contract security auditor.
+Review the provided contract for:
+1. Security vulnerabilities
+2. Privacy concerns (improper handling of shielded state)
+3. Logic errors
+4. Syntax errors (use "error" severity)
+5. Performance issues
+
+IMPORTANT - Distinguish between:
+- ERRORS: Actual syntax/compilation issues (e.g., using Void instead of [], ledger {} blocks)
+- WARNINGS: Potential bugs or security issues
+- INFO: Style suggestions and best practices (these are CONVENTIONS, not requirements)
+
+Do NOT claim style choices as "violations" - the Compact docs don't specify:
+- Indentation width (2 vs 4 spaces)
+- Comment style preferences (//, /* */)
+- Line length limits
+- Naming conventions
+
+These are project-specific style choices, not language requirements.
+
+Respond in JSON format:
+{
+  "summary": "Brief summary of the contract and overall quality",
+  "issues": [
+    {
+      "severity": "error|warning|info",
+      "line": optional_line_number,
+      "message": "Description of the issue",
+      "suggestion": "How to fix it"
     }
-    try {
-      const result = await tool.handler(args);
-      const durationMs = Date.now() - startTime;
-      trackToolCall(name, true, durationMs, CURRENT_VERSION);
-      maybeCheckForUpdates();
-      const updateWarning = getUpdateWarning();
-      if (updateWarning && versionCheckResult.isOutdated) {
-        const updatePrompt = {
-          "\u{1F6A8} UPDATE REQUIRED": {
-            current: `v${CURRENT_VERSION}`,
-            latest: `v${versionCheckResult.latestVersion}`,
-            quickFix: {
-              description: "Most users just need these 2 steps:",
-              step1: "Run in terminal: rm -rf ~/.npm/_npx",
-              step2: "Restart editor completely (Cmd+Q / Alt+F4, then reopen)"
-            },
-            ifStillOld: {
-              description: "If still showing old version after restart:",
-              action: "Edit your MCP config file to use @latest:",
-              change: 'Change "midnight-mcp" to "midnight-mcp@latest" in args',
-              configFiles: {
-                "Claude Desktop (Mac)": "~/Library/Application Support/Claude/claude_desktop_config.json",
-                "Claude Desktop (Win)": "%APPDATA%/Claude/claude_desktop_config.json",
-                Cursor: ".cursor/mcp.json",
-                "VS Code": ".vscode/mcp.json",
-                Windsurf: "~/.codeium/windsurf/mcp_config.json"
-              }
-            },
-            tip: "Use 'midnight-get-update-instructions' tool for detailed platform-specific steps."
-          },
-          result
+  ],
+  "improvedCode": "Full improved contract code if changes are needed"
+}`;
+  try {
+    const response = await requestCompletion(
+      [
+        {
+          role: "user",
+          content: `Review this Compact contract:
+\`\`\`compact
+${code}
+\`\`\``
+        }
+      ],
+      {
+        systemPrompt,
+        maxTokens: 4096,
+        temperature: 0.2
+      }
+    );
+    const jsonMatch = response.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      try {
+        const parsed = JSON.parse(jsonMatch[0]);
+        return {
+          summary: typeof parsed.summary === "string" ? parsed.summary : "Review complete",
+          issues: Array.isArray(parsed.issues) ? parsed.issues : [],
+          improvedCode: typeof parsed.improvedCode === "string" ? parsed.improvedCode : void 0
         };
+      } catch (parseError) {
+        logger.warn("Failed to parse JSON from LLM response", {
+          error: String(parseError)
+        });
         return {
-          content: [
-            {
-              type: "text",
-              text: serialize(updatePrompt)
-            }
-          ]
+          summary: response,
+          issues: []
         };
       }
-      return {
-        content: [
-          {
-            type: "text",
-            text: serialize(result)
-          }
-        ],
-        // Include structured content for machine-readable responses
-        // This allows clients to parse results without JSON.parse()
-        structuredContent: result
-      };
-    } catch (error) {
-      const durationMs = Date.now() - startTime;
-      logger.error(`Tool error: ${name}`, { error: String(error) });
-      trackToolCall(name, false, durationMs, CURRENT_VERSION);
-      const errorResponse = formatErrorResponse(error, `tool:${name}`);
-      return {
-        content: [
-          {
-            type: "text",
-            text: serialize(errorResponse)
-          }
-        ],
-        isError: true
-      };
     }
-  });
-}
-function registerResourceHandlers(server) {
-  server.setRequestHandler(ListResourcesRequestSchema, async () => {
-    logger.debug("Listing resources");
     return {
-      resources: allResources.map((resource) => ({
-        uri: resource.uri,
-        name: resource.name,
-        description: resource.description,
-        mimeType: resource.mimeType
-      }))
+      summary: response,
+      issues: []
     };
-  });
-  server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => {
-    logger.debug("Listing resource templates");
+  } catch (error) {
+    logger.error("Contract review failed", { error: String(error) });
     return {
-      resourceTemplates: resourceTemplates.map((template) => ({
-        uriTemplate: template.uriTemplate,
-        name: template.name,
-        title: template.title,
-        description: template.description,
-        mimeType: template.mimeType
-      }))
+      summary: `Review failed: ${String(error)}`,
+      issues: [
+        {
+          severity: "error",
+          message: "Review failed - check logs for details"
+        }
+      ]
     };
-  });
-  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-    const { uri } = request.params;
-    logger.info(`Resource requested: ${uri}`);
-    try {
-      let content = null;
-      let mimeType = "text/plain";
-      if (uri.startsWith("midnight://docs/")) {
-        content = await getDocumentation(uri);
-        mimeType = "text/markdown";
-      } else if (uri.startsWith("midnight://code/")) {
-        content = await getCode(uri);
-        mimeType = "text/x-compact";
-      } else if (uri.startsWith("midnight://schema/")) {
-        const schema = getSchema(uri);
-        content = schema ? JSON.stringify(schema, null, 2) : null;
-        mimeType = "application/json";
-      }
-      if (!content) {
-        const resourceTypes = [
-          "midnight://docs/",
-          "midnight://code/",
-          "midnight://schema/"
-        ];
-        const validPrefix = resourceTypes.find((p) => uri.startsWith(p));
-        let suggestion = validPrefix ? `Check the resource path after '${validPrefix}'` : `Valid resource prefixes: ${resourceTypes.join(", ")}`;
-        if (uri.includes("://resources/")) {
-          const resourceName = uri.split("://resources/").pop() || "";
-          if (resourceName.includes("template") || resourceName.includes("pattern") || resourceName.includes("example")) {
-            suggestion = `Try: midnight://code/templates/${resourceName} or midnight://code/examples/${resourceName} or midnight://code/patterns/${resourceName}`;
-          } else if (resourceName.includes("doc") || resourceName.includes("reference") || resourceName.includes("guide")) {
-            suggestion = `Try: midnight://docs/${resourceName}`;
-          } else {
-            suggestion = `'midnight://resources/' is not valid. Use: midnight://docs/, midnight://code/, or midnight://schema/`;
-          }
+  }
+}
+async function generateDocumentation(code, format = "markdown") {
+  if (!isSamplingAvailable()) {
+    return "Documentation generation requires sampling capability";
+  }
+  const systemPrompt = format === "markdown" ? `Generate comprehensive Markdown documentation for this Compact contract.
+Include:
+- Overview and purpose
+- State variables (with privacy annotations)
+- Circuit functions with parameters and effects
+- Witness functions
+- Usage examples
+- Security considerations` : `Generate JSDoc-style documentation comments for this Compact contract.
+Add documentation comments above each:
+- Ledger field
+- Circuit function
+- Witness function
+- Type definition`;
+  try {
+    return await requestCompletion(
+      [
+        {
+          role: "user",
+          content: `Generate ${format} documentation for:
+\`\`\`compact
+${code}
+\`\`\``
         }
-        return {
-          contents: [
-            {
-              uri,
-              mimeType: "application/json",
-              text: serialize({
-                error: `Resource not found: ${uri}`,
-                suggestion,
-                hint: "Use ListResources to see all available resources",
-                validPrefixes: resourceTypes
-              })
-            }
-          ]
-        };
+      ],
+      {
+        systemPrompt,
+        maxTokens: 4096,
+        temperature: 0.5
+      }
+    );
+  } catch (error) {
+    logger.error("Documentation generation failed", { error: String(error) });
+    return `Documentation generation failed: ${String(error)}`;
+  }
+}
+
+// src/services/syntax-validator.ts
+var ADT_SEARCH_LIMIT = 10;
+var SYNTAX_RESULTS_LIMIT = 10;
+var SYNTAX_SUBQUERY_LIMIT = 5;
+var MAX_NOTE_SOURCE_LENGTH = 500;
+var NOTE_MIN_LENGTH = 20;
+var NOTE_MAX_LENGTH = 300;
+var MAX_NOTES_PER_ADT = 3;
+async function searchADTInfo(adtName) {
+  try {
+    const docsResult = await searchDocsHosted(
+      `${adtName} ADT operations methods ledger`,
+      ADT_SEARCH_LIMIT,
+      "reference"
+    );
+    if (!docsResult.results || docsResult.results.length === 0) {
+      logger.debug(`No indexed docs found for ADT: ${adtName}`);
+      return null;
+    }
+    const operations = [];
+    const notes = [];
+    let sourceDocPath;
+    for (const result of docsResult.results) {
+      const content = result.content || result.code || "";
+      const isLedgerADTDoc = result.source.filePath.includes("ledger-adt");
+      if (!sourceDocPath && isLedgerADTDoc) {
+        sourceDocPath = result.source.filePath;
       }
-      return {
-        contents: [
-          {
-            uri,
-            mimeType,
-            text: content
+      if (isLedgerADTDoc) {
+        const methodPattern = /\|\s*`?(\w+)`?\s*\|\s*`?\(([^)]*)\)\s*(?::\s*([^|`]+))?`?\s*\|\s*([^|]+)\|/g;
+        let match;
+        while ((match = methodPattern.exec(content)) !== null) {
+          const [, methodName, params, returnType, description] = match;
+          if (methodName && !operations.some((op) => op.method === methodName)) {
+            const descText = description?.trim() || "";
+            const worksInCircuits = !/not available|not supported|not in circuits|typescript|sdk|off[-\s]?chain/i.test(
+              descText
+            );
+            operations.push({
+              method: methodName,
+              signature: `(${params})${returnType ? `: ${returnType.trim()}` : ""}`,
+              description: descText,
+              worksInCircuits,
+              source: "indexed-docs"
+            });
           }
-        ]
-      };
-    } catch (error) {
-      logger.error(`Resource error: ${uri}`, { error: String(error) });
-      const errorResponse = formatErrorResponse(error, `resource:${uri}`);
-      return {
-        contents: [
-          {
-            uri,
-            mimeType: "application/json",
-            text: serialize(errorResponse)
+        }
+        const inlinePattern = /(?:method|operation|function)\s+`?(\w+)`?\s*\(([^)]*)\)/gi;
+        while ((match = inlinePattern.exec(content)) !== null) {
+          const [, methodName, params] = match;
+          if (methodName && !operations.some((op) => op.method === methodName)) {
+            const worksInCircuits = !/not available|not supported|not in circuits|typescript|sdk|off[-\s]?chain/i.test(
+              content
+            );
+            operations.push({
+              method: methodName,
+              signature: `(${params})`,
+              description: "Extracted from documentation",
+              worksInCircuits,
+              source: "indexed-docs"
+            });
           }
-        ]
-      };
+        }
+      }
+      if (content.toLowerCase().includes(adtName.toLowerCase()) && content.length < MAX_NOTE_SOURCE_LENGTH) {
+        const cleanNote = content.replace(/\s+/g, " ").trim();
+        if (cleanNote.length > NOTE_MIN_LENGTH && cleanNote.length < NOTE_MAX_LENGTH) {
+          notes.push(cleanNote);
+        }
+      }
     }
-  });
-}
-function registerPromptHandlers(server) {
-  server.setRequestHandler(ListPromptsRequestSchema, async () => {
-    logger.debug("Listing prompts");
-    return {
-      prompts: promptDefinitions.map((prompt) => ({
-        name: prompt.name,
-        description: prompt.description,
-        arguments: prompt.arguments
-      }))
-    };
-  });
-  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    logger.info(`Prompt requested: ${name}`, { args });
-    const prompt = promptDefinitions.find((p) => p.name === name);
-    if (!prompt) {
-      return {
-        description: `Unknown prompt: ${name}`,
-        messages: []
-      };
+    if (operations.length === 0) {
+      logger.debug(`Could not parse operations for ADT: ${adtName}`);
+      return null;
     }
-    const messages = generatePrompt(name, args || {});
     return {
-      description: prompt.description,
-      messages: messages.map((m) => ({
-        role: m.role,
-        content: m.content
-      }))
+      name: adtName,
+      operations,
+      notes: notes.slice(0, MAX_NOTES_PER_ADT),
+      sourceDocPath,
+      lastVerified: (/* @__PURE__ */ new Date()).toISOString()
     };
-  });
+  } catch (error) {
+    logger.warn(`Failed to search indexed docs for ADT ${adtName}`, {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
 }
-function registerSubscriptionHandlers(server) {
-  server.setRequestHandler(SubscribeRequestSchema, async (request) => {
-    const { uri } = request.params;
-    logger.info(`Subscribing to resource: ${uri}`);
-    const validPrefixes = [
-      "midnight://docs/",
-      "midnight://code/",
-      "midnight://schema/"
+async function searchCompactSyntax(topic) {
+  try {
+    const [docsResult, codeResult] = await Promise.all([
+      searchDocsHosted(
+        `Compact ${topic} syntax`,
+        SYNTAX_SUBQUERY_LIMIT,
+        "reference"
+      ),
+      searchCompactHosted(`${topic}`, SYNTAX_SUBQUERY_LIMIT)
+    ]);
+    const mergedResults = [
+      ...docsResult.results || [],
+      ...codeResult.results || []
     ];
-    const isValid = validPrefixes.some((prefix) => uri.startsWith(prefix));
-    if (!isValid) {
-      logger.warn(`Invalid subscription URI: ${uri}`);
-      throw new Error(
-        `Invalid subscription URI: ${uri}. Valid prefixes: ${validPrefixes.join(", ")}`
+    return {
+      results: mergedResults.slice(0, SYNTAX_RESULTS_LIMIT),
+      totalResults: mergedResults.length,
+      query: topic,
+      lastIndexed: docsResult.lastIndexed || codeResult.lastIndexed
+    };
+  } catch (error) {
+    logger.warn(`Failed to search Compact syntax for topic ${topic}`, {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+async function validateADTOperations(adtName, staticOperations) {
+  const discrepancies = [];
+  const enrichments = [];
+  const indexedInfo = await searchADTInfo(adtName);
+  if (!indexedInfo) {
+    return {
+      validated: false,
+      operations: staticOperations.map((op) => ({
+        method: op.method,
+        description: op.note,
+        worksInCircuits: op.works,
+        source: "static-fallback"
+      })),
+      discrepancies: [
+        "Could not validate against indexed docs - using static data"
+      ],
+      enrichments: []
+    };
+  }
+  const operations = [];
+  const indexedMethodNames = new Set(
+    indexedInfo.operations.map((op) => op.method.toLowerCase())
+  );
+  const staticMethodNames = new Set(
+    staticOperations.map(
+      (op) => op.method.replace(/^\./, "").replace(/\(.*$/, "").toLowerCase()
+    )
+  );
+  for (const indexedOp of indexedInfo.operations) {
+    operations.push(indexedOp);
+    const staticOp = staticOperations.find(
+      (s) => s.method.toLowerCase().includes(indexedOp.method.toLowerCase()) || indexedOp.method.toLowerCase().includes(
+        s.method.replace(/^\./, "").replace(/\(.*$/, "").toLowerCase()
+      )
+    );
+    if (staticOp && !staticOp.works && indexedOp.worksInCircuits) {
+      discrepancies.push(
+        `Static said ${staticOp.method} doesn't work, but indexed docs show it does`
       );
     }
-    resourceSubscriptions.add(uri);
-    logger.debug(`Active subscriptions: ${resourceSubscriptions.size}`);
-    return {};
-  });
-  server.setRequestHandler(UnsubscribeRequestSchema, async (request) => {
-    const { uri } = request.params;
-    logger.info(`Unsubscribing from resource: ${uri}`);
-    resourceSubscriptions.delete(uri);
-    logger.debug(`Active subscriptions: ${resourceSubscriptions.size}`);
-    return {};
-  });
-}
-function setupSampling(server) {
-  const samplingCallback2 = async (request) => {
-    logger.debug("Requesting sampling from client", {
-      messageCount: request.messages.length,
-      maxTokens: request.maxTokens
-    });
-    try {
-      const response = await server.request(
-        {
-          method: "sampling/createMessage",
-          params: {
-            messages: request.messages,
-            systemPrompt: request.systemPrompt,
-            maxTokens: request.maxTokens || 2048,
-            temperature: request.temperature,
-            modelPreferences: request.modelPreferences
-          }
-        },
-        // Use a schema that matches the expected response
-        {
-          parse: (data) => {
-            const response2 = data;
-            if (!response2 || typeof response2 !== "object") {
-              throw new Error("Invalid sampling response: expected object");
-            }
-            if (!response2.content || typeof response2.content !== "object") {
-              throw new Error("Invalid sampling response: missing content");
-            }
-            return response2;
-          },
-          _def: { typeName: "SamplingResponse" }
-        }
+  }
+  for (const staticOp of staticOperations) {
+    const methodName = staticOp.method.replace(/^\./, "").replace(/\(.*$/, "").toLowerCase();
+    if (!indexedMethodNames.has(methodName)) {
+      discrepancies.push(
+        `Static references ${staticOp.method} but not found in indexed docs - may not exist`
       );
-      return response;
-    } catch (error) {
-      logger.error("Sampling request failed", { error: String(error) });
-      throw error;
     }
-  };
-  registerSamplingCallback(samplingCallback2);
-  logger.info("Sampling capability configured");
-}
-async function initializeServer() {
-  logger.info("Initializing Midnight MCP Server...");
-  checkForUpdates().catch((error) => {
-    logger.debug("Startup version check failed (non-blocking)", {
-      error: error instanceof Error ? error.message : String(error)
-    });
-  });
-  try {
-    await vectorStore.initialize();
-    logger.info("Vector store initialized");
-  } catch (error) {
-    logger.warn("Vector store initialization failed, continuing without it", {
-      error: String(error)
-    });
   }
-  const server = createServer();
-  logger.info(`Server v${CURRENT_VERSION} created successfully`);
-  return server;
-}
-async function startServer() {
-  const server = await initializeServer();
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  setServerConnected(true);
-  logger.info("Midnight MCP Server running on stdio");
+  for (const indexedOp of indexedInfo.operations) {
+    const methodName = indexedOp.method.toLowerCase();
+    if (!staticMethodNames.has(methodName)) {
+      enrichments.push(
+        `Indexed docs show ${indexedOp.method} exists but was missing from static reference`
+      );
+    }
+  }
+  return {
+    validated: true,
+    operations,
+    discrepancies,
+    enrichments
+  };
 }
-var transports = {
-  streamable: {},
-  sse: {}
-};
-async function closeTransports(transportMap) {
-  const closePromises = Object.values(transportMap).map(
-    (transport) => transport.close?.().catch(() => {
+async function validateBuiltinFunctions(staticBuiltins) {
+  const discrepancies = [];
+  const enrichments = [];
+  const results = await Promise.all(
+    staticBuiltins.map(async (builtin) => {
+      const searchResult = await searchCompactSyntax(
+        `${builtin.name} function builtin`
+      );
+      return { builtin, found: (searchResult?.results?.length || 0) > 0 };
     })
   );
-  await Promise.all(closePromises);
-}
-async function startHttpServer(port = 3e3) {
-  const mcpServer = await initializeServer();
-  const app = express();
-  app.use("/mcp", express.json());
-  app.get("/health", (_req, res) => {
-    res.json({
-      status: "ok",
-      version: CURRENT_VERSION,
-      transport: "http"
-    });
-  });
-  app.post("/mcp", async (req, res) => {
-    const sessionId = req.headers["mcp-session-id"];
-    let transport;
-    if (sessionId && transports.streamable[sessionId]) {
-      transport = transports.streamable[sessionId];
-    } else if (!sessionId && isInitializeRequest(req.body)) {
-      transport = new StreamableHTTPServerTransport({
-        sessionIdGenerator: () => randomUUID(),
-        onsessioninitialized: (newSessionId) => {
-          transports.streamable[newSessionId] = transport;
-          logger.debug(`New streamable session: ${newSessionId}`);
-        }
-      });
-      transport.onclose = () => {
-        if (transport.sessionId) {
-          delete transports.streamable[transport.sessionId];
-          logger.debug(`Streamable session closed: ${transport.sessionId}`);
+  for (const { builtin, found } of results) {
+    if (!found) {
+      discrepancies.push(
+        `Builtin "${builtin.name}" not found in indexed docs - may not exist or have different name`
+      );
+    }
+  }
+  const allBuiltinsSearch = await searchCompactSyntax(
+    "builtin function stdlib standard library"
+  );
+  if (allBuiltinsSearch?.results) {
+    const knownNames = new Set(staticBuiltins.map((b) => b.name.toLowerCase()));
+    for (const result of allBuiltinsSearch.results) {
+      const content = result.content || result.code || "";
+      const funcPattern = /\b(export\s+)?function\s+(\w+)/gi;
+      let match;
+      while ((match = funcPattern.exec(content)) !== null) {
+        const funcName = match[2].toLowerCase();
+        if (!knownNames.has(funcName) && funcName.length > 2) {
+          enrichments.push(`Indexed docs mention "${match[2]}" function`);
         }
-      };
-      try {
-        await mcpServer.connect(transport);
-      } catch (error) {
-        logger.error("Failed to connect streamable transport", {
-          error: String(error)
-        });
-        res.status(500).json({
-          jsonrpc: "2.0",
-          error: { code: -32603, message: "Internal error: connection failed" },
-          id: null
-        });
-        return;
       }
-    } else {
-      res.status(400).json({
-        jsonrpc: "2.0",
-        error: {
-          code: -32e3,
-          message: "Bad Request: No valid session ID provided"
-        },
-        id: null
-      });
-      return;
-    }
-    await transport.handleRequest(req, res, req.body);
-  });
-  app.get("/sse", async (_req, res) => {
-    logger.debug("New SSE connection");
-    const transport = new SSEServerTransport("/messages", res);
-    transports.sse[transport.sessionId] = transport;
-    res.on("close", () => {
-      delete transports.sse[transport.sessionId];
-      logger.debug(`SSE session closed: ${transport.sessionId}`);
-    });
-    try {
-      await mcpServer.connect(transport);
-    } catch (error) {
-      delete transports.sse[transport.sessionId];
-      logger.error(`SSE connection failed: ${transport.sessionId}`, {
-        error: String(error)
-      });
-      res.status(500).end();
-    }
-  });
-  app.post("/messages", async (req, res) => {
-    const sessionId = req.query.sessionId;
-    const transport = transports.sse[sessionId];
-    if (transport) {
-      await transport.handlePostMessage(req, res);
-    } else {
-      res.status(400).send(`No transport found for sessionId ${sessionId}`);
     }
-  });
-  const handleSessionRequest = async (req, res) => {
-    const sessionId = req.headers["mcp-session-id"];
-    if (!sessionId || !transports.streamable[sessionId]) {
-      res.status(400).send("Invalid or missing session ID");
-      return;
+  }
+  return {
+    dataType: "BUILTIN_FUNCTIONS",
+    validated: discrepancies.length === 0,
+    discrepancies,
+    enrichments: [...new Set(enrichments)].slice(0, 10),
+    deprecatedPatterns: [],
+    lastValidated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function validateTypeCompatibility(staticRules) {
+  const discrepancies = [];
+  const enrichments = [];
+  const typeSearch = await searchCompactSyntax(
+    "type cast Field Uint Bytes conversion compatible"
+  );
+  if (typeSearch?.results) {
+    for (const result of typeSearch.results) {
+      const content = (result.content || result.code || "").toLowerCase();
+      for (const rule of staticRules) {
+        const typeMatch = rule.types.match(
+          /^\s*(.+?)\s*(?:==|=|<=|>=|<|>|[+*])\s*(.+?)\s*$/
+        );
+        const typeA = typeMatch?.[1]?.trim().toLowerCase();
+        const typeB = typeMatch?.[2]?.trim().toLowerCase();
+        if (typeA && typeB) {
+          if (content.includes(typeA) && content.includes(typeB) && content.includes("compatible")) {
+            if (!rule.works) {
+              discrepancies.push(
+                `Static says "${rule.types}" doesn't work, but docs suggest compatibility`
+              );
+            }
+          }
+        }
+      }
     }
-    const transport = transports.streamable[sessionId];
-    await transport.handleRequest(req, res);
+  }
+  return {
+    dataType: "TYPE_COMPATIBILITY",
+    validated: discrepancies.length === 0,
+    discrepancies,
+    enrichments,
+    deprecatedPatterns: [],
+    lastValidated: (/* @__PURE__ */ new Date()).toISOString()
   };
-  app.get("/mcp", handleSessionRequest);
-  app.delete("/mcp", handleSessionRequest);
-  const httpServer = app.listen(port, "127.0.0.1", () => {
-    logger.info(`Midnight MCP Server running on HTTP port ${port}`);
-    logger.info(`  Streamable HTTP: http://localhost:${port}/mcp`);
-    logger.info(`  SSE endpoint:    http://localhost:${port}/sse`);
-    logger.info(`  Health check:    http://localhost:${port}/health`);
-  });
-  const shutdown = async () => {
-    logger.info("Shutting down HTTP server...");
-    await closeTransports(transports.sse);
-    await closeTransports(transports.streamable);
-    httpServer.close(() => {
-      logger.info("Server shutdown complete");
-      process.exit(0);
-    });
+}
+async function validateCommonErrors(staticErrors) {
+  const discrepancies = [];
+  const enrichments = [];
+  const errorSearch = await searchDocsHosted(
+    "error compile compilation failure parse",
+    ADT_SEARCH_LIMIT,
+    "all"
+  );
+  if (errorSearch?.results) {
+    const knownErrors = new Set(
+      staticErrors.map((e) => e.error.toLowerCase().slice(0, 30))
+    );
+    for (const result of errorSearch.results) {
+      const content = result.content || result.code || "";
+      const errorPattern = /(?:error|Error):\s*["']?([^"'\n]+)["']?/g;
+      let match;
+      while ((match = errorPattern.exec(content)) !== null) {
+        const errorMsg = match[1].toLowerCase().slice(0, 30);
+        if (!knownErrors.has(errorMsg) && errorMsg.length > 10) {
+          enrichments.push(`Docs mention error: "${match[1].slice(0, 50)}..."`);
+        }
+      }
+    }
+  }
+  return {
+    dataType: "COMMON_ERRORS",
+    validated: true,
+    // Errors are informational, hard to validate
+    discrepancies,
+    enrichments: [...new Set(enrichments)].slice(0, 10),
+    deprecatedPatterns: [],
+    lastValidated: (/* @__PURE__ */ new Date()).toISOString()
   };
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
 }
-
-// src/config/compact-version.ts
-var COMPACT_VERSION = {
-  /** Minimum supported version */
-  min: "0.16",
-  /** Maximum supported version */
-  max: "0.21",
-  /** When this config was last updated */
-  lastUpdated: "2026-03-24",
-  /** Source of truth for syntax patterns */
-  referenceSource: "https://github.com/piotr-iohk/template-contract"
-};
-var RECOMMENDED_PRAGMA = `pragma language_version >= ${COMPACT_VERSION.min} && <= ${COMPACT_VERSION.max};`;
-var REFERENCE_CONTRACTS = [
+var DEPRECATED_SYNTAX_PATTERNS = [
   {
-    name: "template-contract",
-    repo: "piotr-iohk/template-contract",
-    description: "Official Midnight template contract"
+    pattern: /ledger\s*\{/,
+    name: "ledger-block",
+    message: "Deprecated: Use 'export ledger field: Type;' instead of ledger { } block",
+    since: "0.16"
   },
   {
-    name: "tokenomics-project",
-    repo: "piotr-iohk/tokenomics-project",
-    description: "Token implementation example"
+    pattern: /Cell\s*<\s*\w+\s*>/,
+    name: "cell-wrapper",
+    message: "Deprecated: Cell<T> wrapper removed, use Type directly",
+    since: "0.15"
   },
   {
-    name: "zswap-example",
-    repo: "piotr-iohk/zswap-example",
-    description: "Privacy-preserving swap example"
+    pattern: /:\s*Void\b/,
+    name: "void-type",
+    message: "Void type doesn't exist, use [] (empty tuple) for no return",
+    since: "always"
   },
   {
-    name: "reentrancy-example",
-    repo: "piotr-iohk/reentrancy-example",
-    description: "Cross-contract call patterns"
+    pattern: /\.\s*value\s*\(\s*\)/,
+    name: "counter-value",
+    message: "Counter.value() doesn't exist, use Counter.read() instead",
+    since: "always"
+  },
+  {
+    pattern: /::\w+/,
+    name: "rust-enum-syntax",
+    message: "Rust-style :: enum access doesn't work, use dot notation (Choice.rock)",
+    since: "always"
+  },
+  {
+    pattern: /pure\s+function\b/,
+    name: "pure-function",
+    message: "Use 'pure circuit' not 'pure function' for helper functions",
+    since: "0.16"
+  },
+  {
+    pattern: /witness\s+\w+\s*\([^)]*\)\s*:\s*\w+\s*\{/,
+    name: "witness-with-body",
+    message: "Witnesses are declarations only - no body allowed. Implementation goes in TypeScript prover.",
+    since: "always"
   }
 ];
-var BUILTIN_FUNCTIONS = {
-  /** Actually built into the language/stdlib */
-  stdlib: [
-    {
-      name: "persistentHash",
-      signature: "persistentHash<T>(value: T): Bytes<32>",
-      // Signature inferred from examples
-      description: "Poseidon hash that produces consistent results across calls"
-    },
-    {
-      name: "persistentCommit",
-      signature: "persistentCommit<T>(value: T): Bytes<32>",
-      description: "Creates a hiding commitment to a value"
-    },
-    {
-      name: "pad",
-      signature: "pad(length: number, value: string): Bytes<N>",
-      description: "Pads a string to fixed-length bytes"
-    },
-    {
-      name: "disclose",
-      signature: "disclose(value: T): T",
-      description: "Explicitly reveals a witness value (required in conditionals)"
-    },
-    {
-      name: "assert",
-      signature: "assert(condition: Boolean, message?: string): []",
-      description: "Fails circuit if condition is false"
-    },
-    {
-      name: "default",
-      signature: "default<T>(): T",
-      description: "Returns default value for a type (0 for numbers, empty for collections)"
-    }
-  ],
-  /** NOT built-in - you must implement these patterns yourself */
-  notBuiltIn: [
-    {
-      name: "public_key",
-      wrongUsage: "public_key(sk) // ERROR: unbound identifier",
-      correctPattern: `// Derive public key using persistentHash
-const pk = persistentHash<Vector<2, Bytes<32>>>([
-  pad(32, "midnight:pk:"),
-  sk
-]);`,
-      description: "Public key derivation is NOT a builtin - use persistentHash pattern"
-    },
-    {
-      name: "verify_signature",
-      wrongUsage: "verify_signature(msg, sig, pk) // Does not exist",
-      correctPattern: `// Signature verification must be done via witnesses
-// The prover verifies off-chain, then provides the boolean result
-witness signature_valid(): Boolean;`,
-      description: "Signature verification is done off-chain in the prover"
-    },
-    {
-      name: "random",
-      wrongUsage: "random() // Does not exist in ZK circuits",
-      correctPattern: `// Randomness must come from witnesses (prover-provided)
-witness get_random_value(): Field;`,
-      description: "ZK circuits are deterministic - randomness must come from witnesses"
-    }
-  ]
-};
-var TYPE_COMPATIBILITY = {
-  // Note: Comparison operators work in practice but aren't explicitly listed in docs
-  comparisons: [
-    { types: "Field == Field", works: true, note: "Direct comparison" },
-    {
-      types: "Field == Uint<N>",
-      works: false,
-      fix: "Cast with `value as Field`"
-    },
-    {
-      types: "Field >= 0",
-      works: false,
-      fix: "Use bounded Uint<0..N> parameter instead"
-    },
-    { types: "Uint<N> == Uint<N>", works: true, note: "Same-width comparison" },
-    {
-      types: "Uint<0..2> == Uint<0..2>",
-      works: true,
-      note: "Bounded integers"
-    },
-    {
-      types: "Bytes<32> == Bytes<32>",
-      works: true,
-      note: "Used in examples, but operators not explicitly listed in docs"
-    },
-    { types: "Boolean == Boolean", works: true, note: "Direct comparison" }
-  ],
-  arithmetic: [
-    { types: "Field + Field", works: true, note: "Field arithmetic" },
-    { types: "Field + Uint<N>", works: false, fix: "Cast Uint to Field first" },
-    {
-      types: "Uint<N> + Uint<N>",
-      works: true,
-      note: "Result is bounded type, cast back: (a + b) as Uint<64>"
-    },
-    {
-      types: "Uint<64> + Uint<64>",
-      works: true,
-      note: "Result is Uint<0..36893488147419103230>, must cast: (a + b) as Uint<64>"
-    },
-    {
-      types: "Uint<64> * Uint<64>",
-      works: true,
-      note: "Result is wide bounded type, cast back to target type"
-    }
-  ],
-  /**
-   * Type casting rules - based on official cast table
-   * See: https://docs.midnight.network/develop/reference/compact/lang-ref#type-cast-expressions
-   *
-   * Cast kinds: static (always succeeds), conversion (semantic change), checked (can fail)
-   */
-  typeCasting: [
-    {
-      from: "Uint<N>",
-      to: "Field",
-      direct: true,
-      kind: "static",
-      note: "Always succeeds"
-    },
-    {
-      from: "Field",
-      to: "Uint<0..n>",
-      direct: true,
-      kind: "checked",
-      note: "Fails at runtime if value > n"
-    },
-    {
-      from: "Field",
-      to: "Bytes<n>",
-      direct: true,
-      kind: "conversion",
-      note: "Can fail at runtime if value doesn't fit (little-endian)"
-    },
-    {
-      from: "Bytes<m>",
-      to: "Field",
-      direct: true,
-      kind: "conversion",
-      note: "Can fail at runtime if result exceeds max Field value"
-    },
-    {
-      from: "Boolean",
-      to: "Uint<0..n>",
-      direct: true,
-      kind: "conversion",
-      note: "false\u21920, true\u21921 (n must not be 0)"
-    },
-    {
-      from: "Boolean",
-      to: "Field",
-      direct: false,
-      fix: "Go through Uint: (flag as Uint<0..1>) as Field"
-    },
-    {
-      from: "Uint<N>",
-      to: "Bytes<M>",
-      direct: false,
-      fix: "Go through Field: (amount as Field) as Bytes<32>"
-    },
-    {
-      from: "enum",
-      to: "Field",
-      direct: true,
-      kind: "conversion",
-      note: "Enum variant index as Field"
-    },
-    {
-      from: "Uint<0..m>",
-      to: "Uint<0..n>",
-      direct: true,
-      kind: "static if m\u2264n, checked if m>n",
-      note: "Widening is static, narrowing is checked"
-    },
-    {
-      from: "arithmetic result",
-      to: "Uint<64>",
-      direct: true,
-      kind: "checked",
-      note: "Required cast: (a + b) as Uint<64>"
+function scanForDeprecatedPatterns(code) {
+  const issues = [];
+  const lines = code.split("\n");
+  for (const { pattern, name, message } of DEPRECATED_SYNTAX_PATTERNS) {
+    for (let i = 0; i < lines.length; i++) {
+      if (pattern.test(lines[i])) {
+        issues.push({
+          pattern: name,
+          message,
+          lineNumber: i + 1
+        });
+      }
     }
-  ],
-  assignments: [
-    {
-      types: "Field = Uint<N>",
-      works: false,
-      fix: "Cast with `value as Field`"
+  }
+  return issues;
+}
+async function validateAllStaticData(staticData) {
+  const results = {};
+  const [builtinResult, typeResult, errorResult, adtResults] = await Promise.all([
+    staticData.builtinFunctions ? validateBuiltinFunctions(staticData.builtinFunctions) : Promise.resolve(null),
+    staticData.typeCompatibility ? validateTypeCompatibility(staticData.typeCompatibility) : Promise.resolve(null),
+    staticData.commonErrors ? validateCommonErrors(staticData.commonErrors) : Promise.resolve(null),
+    staticData.ledgerTypeLimits ? Promise.all(
+      Object.entries(staticData.ledgerTypeLimits).map(
+        async ([name, data]) => ({
+          name,
+          result: await validateADTOperations(
+            name,
+            data.circuitOperations
+          )
+        })
+      )
+    ) : Promise.resolve([])
+  ]);
+  if (builtinResult) results.builtinFunctions = builtinResult;
+  if (typeResult) results.typeCompatibility = typeResult;
+  if (errorResult) results.commonErrors = errorResult;
+  for (const { name, result } of adtResults) {
+    results[`adt_${name}`] = {
+      dataType: `LEDGER_TYPE_LIMITS.${name}`,
+      validated: result.validated,
+      discrepancies: result.discrepancies,
+      enrichments: result.enrichments,
+      deprecatedPatterns: [],
+      lastValidated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  const allDiscrepancies = Object.values(results).flatMap(
+    (r) => r.discrepancies
+  );
+  const allEnrichments = Object.values(results).flatMap((r) => r.enrichments);
+  return {
+    overall: {
+      validated: allDiscrepancies.length === 0,
+      totalDiscrepancies: allDiscrepancies.length,
+      totalEnrichments: allEnrichments.length
     },
-    {
-      types: "Uint<N> = Field",
-      works: false,
-      fix: "Use bounded param or explicit cast"
-    }
-  ],
-  tips: [
-    "Use Uint<0..N> for circuit parameters that need range validation",
-    "Field is unbounded - use for hashes, commitments, general computation",
-    "Uint<N> is bounded - use when you need range checks",
-    "Casting with `as Field` is safe but loses range information"
-  ]
+    results,
+    lastValidated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/server.ts
+var SERVER_INFO = {
+  name: "midnight-mcp",
+  version: CURRENT_VERSION,
+  description: "MCP Server for Midnight Blockchain Development"
 };
-var LEDGER_TYPE_LIMITS = {
-  Counter: {
-    circuitOperations: [
-      {
-        method: ".increment(n)",
-        works: true,
-        note: "Increase counter by n (Uint<16>)"
-      },
-      {
-        method: ".decrement(n)",
-        works: true,
-        note: "Decrease counter by n (Uint<16>)"
-      },
-      {
-        method: ".read()",
-        works: true,
-        note: "Get current value (returns Uint<64>)"
-      },
-      {
-        method: ".lessThan(n)",
-        works: true,
-        note: "Compare with threshold (returns Boolean)"
-      },
-      { method: ".resetToDefault()", works: true, note: "Reset to 0" }
-    ],
-    typescriptAccess: "Access counter value via `ledgerState.counter` in TypeScript SDK",
-    note: "All Counter operations work in circuits. Use .read() to get value, NOT .value()"
+var versionCheckResult = {
+  isOutdated: false,
+  latestVersion: CURRENT_VERSION,
+  updateMessage: null,
+  lastChecked: 0
+};
+var toolCallCount = 0;
+var VERSION_CHECK_INTERVAL = 10;
+async function checkForUpdates() {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    const response = await fetch(
+      "https://registry.npmjs.org/midnight-mcp/latest",
+      { signal: controller.signal }
+    );
+    clearTimeout(timeoutId);
+    if (!response.ok) return;
+    const data = await response.json();
+    const latestVersion = data.version;
+    if (latestVersion !== CURRENT_VERSION) {
+      versionCheckResult = {
+        isOutdated: true,
+        latestVersion,
+        lastChecked: Date.now(),
+        updateMessage: `\u{1F6A8} UPDATE AVAILABLE: v${latestVersion} (you have v${CURRENT_VERSION})`
+      };
+      logger.warn(
+        `Outdated version detected: v${CURRENT_VERSION} -> v${latestVersion}`
+      );
+    } else {
+      versionCheckResult = {
+        ...versionCheckResult,
+        lastChecked: Date.now()
+      };
+    }
+  } catch (error) {
+    logger.debug("Version check failed (non-blocking)", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+function maybeCheckForUpdates() {
+  toolCallCount++;
+  if (toolCallCount >= VERSION_CHECK_INTERVAL) {
+    toolCallCount = 0;
+    const fiveMinutes = 5 * 60 * 1e3;
+    if (Date.now() - versionCheckResult.lastChecked > fiveMinutes) {
+      checkForUpdates().catch((error) => {
+        logger.debug("Periodic version check failed", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
+    }
+  }
+}
+function getUpdateWarning() {
+  return versionCheckResult.updateMessage;
+}
+var resourceSubscriptions = /* @__PURE__ */ new Set();
+var resourceTemplates = [
+  {
+    uriTemplate: "midnight://code/{owner}/{repo}/{path}",
+    name: "Repository Code",
+    title: "\u{1F4C4} Repository Code Files",
+    description: "Access code files from any Midnight repository by specifying owner, repo, and file path",
+    mimeType: "text/plain"
   },
-  Map: {
-    circuitOperations: [
-      {
-        method: ".insert(key, value)",
-        works: true,
-        note: "Adds/updates entry"
-      },
-      {
-        method: ".insertDefault(key)",
-        works: true,
-        note: "Inserts default value for key"
-      },
-      { method: ".remove(key)", works: true, note: "Removes entry" },
-      {
-        method: ".lookup(key)",
-        works: true,
-        note: "Returns value_type - gets value for key"
-      },
-      {
-        method: ".member(key)",
-        works: true,
-        note: "Returns Boolean - checks if key exists"
+  {
+    uriTemplate: "midnight://docs/{section}/{topic}",
+    name: "Documentation",
+    title: "\u{1F4DA} Documentation Sections",
+    description: "Access documentation by section (guides, api, concepts) and topic",
+    mimeType: "text/markdown"
+  },
+  {
+    uriTemplate: "midnight://examples/{category}/{name}",
+    name: "Example Contracts",
+    title: "\u{1F4DD} Example Contracts",
+    description: "Access example contracts by category (counter, bboard, token, voting) and name",
+    mimeType: "text/x-compact"
+  },
+  {
+    uriTemplate: "midnight://schema/{type}",
+    name: "Schema Definitions",
+    title: "\u{1F527} Schema Definitions",
+    description: "Access JSON schemas for contract AST, transactions, and proofs",
+    mimeType: "application/json"
+  }
+];
+var mcpLogLevel = "info";
+var serverInstance = null;
+var isConnected = false;
+function setServerConnected(connected) {
+  isConnected = connected;
+}
+function sendLogToClient(level, loggerName, data) {
+  if (!serverInstance || !isConnected) return;
+  const levelValues = {
+    debug: 0,
+    info: 1,
+    notice: 2,
+    warning: 3,
+    error: 4,
+    critical: 5,
+    alert: 6,
+    emergency: 7
+  };
+  if (levelValues[level] < levelValues[mcpLogLevel]) return;
+  try {
+    serverInstance.notification({
+      method: "notifications/message",
+      params: {
+        level,
+        logger: loggerName,
+        data
+      }
+    });
+  } catch (error) {
+    logger.debug("Failed to send log notification to client", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+function sendProgressNotification(progressToken, progress, total, message) {
+  if (!serverInstance) return;
+  try {
+    serverInstance.notification({
+      method: "notifications/progress",
+      params: {
+        progressToken,
+        progress,
+        ...total !== void 0 && { total },
+        ...message && { message }
+      }
+    });
+  } catch (error) {
+    logger.debug("Failed to send progress notification", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+function createServer() {
+  const server = new Server(SERVER_INFO, {
+    capabilities: {
+      tools: {
+        listChanged: true
       },
-      {
-        method: ".isEmpty()",
-        works: true,
-        note: "Returns Boolean - checks if map is empty"
+      resources: {
+        subscribe: true,
+        listChanged: true
       },
-      {
-        method: ".size()",
-        works: true,
-        note: "Returns Uint<64> - number of entries"
+      prompts: {
+        listChanged: true
       },
-      {
-        method: ".resetToDefault()",
-        works: true,
-        note: "Clears entire map"
+      logging: {},
+      completions: {}
+    }
+  });
+  serverInstance = server;
+  setMCPLogCallback((level, loggerName, data) => {
+    sendLogToClient(level, loggerName, data);
+  });
+  registerToolHandlers(server);
+  registerResourceHandlers(server);
+  registerPromptHandlers(server);
+  registerSubscriptionHandlers(server);
+  registerLoggingHandler(server);
+  registerCompletionsHandler(server);
+  setupSampling(server);
+  return server;
+}
+function registerLoggingHandler(server) {
+  server.setRequestHandler(SetLevelRequestSchema, async (request) => {
+    const { level } = request.params;
+    mcpLogLevel = level;
+    logger.info(`MCP log level set to: ${level}`);
+    sendLogToClient("info", "midnight-mcp", {
+      message: `Log level changed to ${level}`
+    });
+    return {};
+  });
+}
+var COMPLETION_VALUES = {
+  "midnight:create-contract": {
+    contractType: [
+      "token",
+      "voting",
+      "credential",
+      "auction",
+      "escrow",
+      "custom"
+    ],
+    privacyLevel: ["full", "partial", "public"],
+    complexity: ["beginner", "intermediate", "advanced"]
+  },
+  "midnight:review-contract": {
+    focusAreas: [
+      "security",
+      "performance",
+      "privacy",
+      "readability",
+      "gas-optimization"
+    ]
+  },
+  "midnight:explain-concept": {
+    concept: [
+      "zk-proofs",
+      "circuits",
+      "witnesses",
+      "ledger",
+      "state-management",
+      "privacy-model",
+      "token-transfers",
+      "merkle-trees"
+    ],
+    level: ["beginner", "intermediate", "advanced"]
+  },
+  "midnight:compare-approaches": {
+    approaches: [
+      "token-standards",
+      "state-management",
+      "privacy-patterns",
+      "circuit-design"
+    ]
+  },
+  "midnight:debug-contract": {
+    errorType: [
+      "compilation",
+      "runtime",
+      "logic",
+      "privacy-leak",
+      "state-corruption"
+    ]
+  }
+};
+function registerCompletionsHandler(server) {
+  server.setRequestHandler(CompleteRequestSchema, async (request) => {
+    const { ref, argument } = request.params;
+    if (ref.type !== "ref/prompt") {
+      return { completion: { values: [], hasMore: false } };
+    }
+    const promptName = ref.name;
+    const argName = argument.name;
+    const currentValue = argument.value?.toLowerCase() || "";
+    const promptCompletions = COMPLETION_VALUES[promptName];
+    if (!promptCompletions) {
+      return { completion: { values: [], hasMore: false } };
+    }
+    const argValues = promptCompletions[argName];
+    if (!argValues) {
+      return { completion: { values: [], hasMore: false } };
+    }
+    const filtered = argValues.filter(
+      (v) => v.toLowerCase().includes(currentValue)
+    );
+    return {
+      completion: {
+        values: filtered.slice(0, 20),
+        total: filtered.length,
+        hasMore: filtered.length > 20
+      }
+    };
+  });
+}
+function registerToolHandlers(server) {
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    logger.debug("Listing tools");
+    return {
+      tools: allTools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        // Include output schema if defined
+        ...tool.outputSchema && { outputSchema: tool.outputSchema },
+        // Include annotations if defined
+        ...tool.annotations && { annotations: tool.annotations }
+      }))
+    };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    logger.info(`Tool called: ${name}`, { args });
+    const startTime = Date.now();
+    const tool = allTools.find((t) => t.name === name);
+    if (!tool) {
+      const availableTools = allTools.map((t) => t.name).slice(0, 5).join(", ");
+      trackToolCall(name, false, Date.now() - startTime, CURRENT_VERSION);
+      return {
+        content: [
+          {
+            type: "text",
+            text: serialize({
+              error: `Unknown tool: ${name}`,
+              suggestion: `Available tools include: ${availableTools}...`,
+              hint: "Use ListTools to see all available tools"
+            })
+          }
+        ],
+        isError: true
+      };
+    }
+    try {
+      const result = await tool.handler(args);
+      const durationMs = Date.now() - startTime;
+      trackToolCall(name, true, durationMs, CURRENT_VERSION);
+      maybeCheckForUpdates();
+      const updateWarning = getUpdateWarning();
+      if (updateWarning && versionCheckResult.isOutdated) {
+        const updatePrompt = {
+          "\u{1F6A8} UPDATE REQUIRED": {
+            current: `v${CURRENT_VERSION}`,
+            latest: `v${versionCheckResult.latestVersion}`,
+            quickFix: {
+              description: "Most users just need these 2 steps:",
+              step1: "Run in terminal: rm -rf ~/.npm/_npx",
+              step2: "Restart editor completely (Cmd+Q / Alt+F4, then reopen)"
+            },
+            ifStillOld: {
+              description: "If still showing old version after restart:",
+              action: "Edit your MCP config file to use @latest:",
+              change: 'Change "midnight-mcp" to "midnight-mcp@latest" in args',
+              configFiles: {
+                "Claude Desktop (Mac)": "~/Library/Application Support/Claude/claude_desktop_config.json",
+                "Claude Desktop (Win)": "%APPDATA%/Claude/claude_desktop_config.json",
+                Cursor: ".cursor/mcp.json",
+                "VS Code": ".vscode/mcp.json",
+                Windsurf: "~/.codeium/windsurf/mcp_config.json"
+              }
+            },
+            tip: "Use 'midnight-get-update-instructions' tool for detailed platform-specific steps."
+          },
+          result
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: serialize(updatePrompt)
+            }
+          ]
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: serialize(result)
+          }
+        ],
+        // Include structured content for machine-readable responses
+        // This allows clients to parse results without JSON.parse()
+        structuredContent: result
+      };
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      logger.error(`Tool error: ${name}`, { error: String(error) });
+      trackToolCall(name, false, durationMs, CURRENT_VERSION);
+      const errorResponse = formatErrorResponse(error, `tool:${name}`);
+      return {
+        content: [
+          {
+            type: "text",
+            text: serialize(errorResponse)
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+}
+function registerResourceHandlers(server) {
+  server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    logger.debug("Listing resources");
+    return {
+      resources: allResources.map((resource) => ({
+        uri: resource.uri,
+        name: resource.name,
+        description: resource.description,
+        mimeType: resource.mimeType
+      }))
+    };
+  });
+  server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => {
+    logger.debug("Listing resource templates");
+    return {
+      resourceTemplates: resourceTemplates.map((template) => ({
+        uriTemplate: template.uriTemplate,
+        name: template.name,
+        title: template.title,
+        description: template.description,
+        mimeType: template.mimeType
+      }))
+    };
+  });
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    logger.info(`Resource requested: ${uri}`);
+    try {
+      let content = null;
+      let mimeType = "text/plain";
+      if (uri.startsWith("midnight://docs/")) {
+        content = await getDocumentation(uri);
+        mimeType = "text/markdown";
+      } else if (uri.startsWith("midnight://code/")) {
+        content = await getCode(uri);
+        mimeType = "text/x-compact";
+      } else if (uri.startsWith("midnight://schema/")) {
+        const schema = getSchema(uri);
+        content = schema ? JSON.stringify(schema, null, 2) : null;
+        mimeType = "application/json";
       }
-    ],
-    typescriptAccess: "Query map via `contractState.data.get(key)` or iterate with `[Symbol.iterator]()` in TypeScript SDK",
-    note: "All Map operations work in circuits. insertCoin() available when value_type is QualifiedCoinInfo."
-  },
-  Set: {
-    circuitOperations: [
-      { method: ".insert(value)", works: true, note: "Adds to set" },
-      { method: ".remove(value)", works: true, note: "Removes from set" },
-      {
-        method: ".member(value)",
-        works: true,
-        note: "Returns Boolean - checks if value exists in set"
-      },
-      {
-        method: ".isEmpty()",
-        works: true,
-        note: "Returns Boolean - checks if set is empty"
-      },
-      {
-        method: ".size()",
-        works: true,
-        note: "Returns Uint<64> - number of elements"
-      },
-      {
-        method: ".resetToDefault()",
-        works: true,
-        note: "Clears entire set"
+      if (!content) {
+        const resourceTypes = [
+          "midnight://docs/",
+          "midnight://code/",
+          "midnight://schema/"
+        ];
+        const validPrefix = resourceTypes.find((p) => uri.startsWith(p));
+        let suggestion = validPrefix ? `Check the resource path after '${validPrefix}'` : `Valid resource prefixes: ${resourceTypes.join(", ")}`;
+        if (uri.includes("://resources/")) {
+          const resourceName = uri.split("://resources/").pop() || "";
+          if (resourceName.includes("template") || resourceName.includes("pattern") || resourceName.includes("example")) {
+            suggestion = `Try: midnight://code/templates/${resourceName} or midnight://code/examples/${resourceName} or midnight://code/patterns/${resourceName}`;
+          } else if (resourceName.includes("doc") || resourceName.includes("reference") || resourceName.includes("guide")) {
+            suggestion = `Try: midnight://docs/${resourceName}`;
+          } else {
+            suggestion = `'midnight://resources/' is not valid. Use: midnight://docs/, midnight://code/, or midnight://schema/`;
+          }
+        }
+        return {
+          contents: [
+            {
+              uri,
+              mimeType: "application/json",
+              text: serialize({
+                error: `Resource not found: ${uri}`,
+                suggestion,
+                hint: "Use ListResources to see all available resources",
+                validPrefixes: resourceTypes
+              })
+            }
+          ]
+        };
       }
-    ],
-    typescriptAccess: "Check membership via `contractState.set.has(value)` or iterate with `[Symbol.iterator]()` in TypeScript SDK",
-    note: "All Set operations work in circuits. insertCoin() available when value_type is QualifiedCoinInfo."
-  },
-  MerkleTree: {
-    circuitOperations: [
-      { method: ".insert(leaf)", works: true, note: "Adds leaf to tree" },
-      { method: ".root()", works: false, note: "NOT available in circuits" }
-    ],
-    typescriptAccess: "Get root via `contractState.tree.root` in TypeScript SDK",
-    pattern: `// To verify a merkle proof in circuit:
-witness get_merkle_root(): Bytes<32>;
-witness get_merkle_proof(leaf: Bytes<32>): Vector<32, Bytes<32>>;
-
-// Verify proof using persistentHash to compute expected root`
-  }
-};
-var COMMON_ERRORS = [
-  {
-    error: 'unbound identifier "public_key"',
-    cause: "Trying to use public_key() as if it's a builtin function",
-    fix: `Use persistentHash pattern instead:
-const pk = persistentHash<Vector<2, Bytes<32>>>([pad(32, "midnight:pk:"), sk]);`
-  },
-  {
-    error: "incompatible combination of types Field and Uint",
-    cause: "Comparing or operating on Field with Uint without casting",
-    fix: `Cast Uint to Field: (myUint as Field)
-Or use bounded Uint<0..N> for parameters that need constraints`
-  },
-  {
-    error: 'operation "value" undefined for ledger field type Counter',
-    cause: "Using wrong method name - Counter uses .read() not .value()",
-    fix: `Use counter.read() to get the current value:
-const current = ledger.counter.read();
-
-Counter ADT methods available in circuits:
-- increment(amount: Uint<16>): []  - increase counter
-- decrement(amount: Uint<16>): []  - decrease counter
-- read(): Uint<64>                 - get current value
-- lessThan(threshold: Uint<64>): Boolean - compare
-- resetToDefault(): []             - reset to zero`
-  },
-  {
-    error: "implicit disclosure of witness value",
-    cause: "Using witness value in conditional without disclose()",
-    fix: `Wrap witness comparisons in disclose():
-if (disclose(witness_value == expected)) { ... }`
-  },
-  {
-    error: 'parse error: found "{" looking for an identifier',
-    cause: "Using old ledger { } block syntax",
-    fix: `Use individual exports instead:
-export ledger field1: Type1;
-export ledger field2: Type2;`
-  },
-  {
-    error: 'parse error: found "{" looking for ";"',
-    cause: "Using Void as return type (doesn't exist)",
-    fix: `Use empty tuple [] for no return value:
-export circuit myCircuit(): [] { ... }`
-  },
-  {
-    error: 'unbound identifier "Cell"',
-    cause: "Using deprecated Cell<T> wrapper (removed in 0.15)",
-    fix: `Remove Cell wrapper, just use the type directly:
-export ledger myField: Field;  // Not Cell<Field>`
-  },
-  {
-    error: "member access requires struct type",
-    cause: "Trying to access a field on a non-struct type",
-    fix: `Make sure you're accessing a struct field, not a primitive.
-Map.lookup() and Map.member() ARE available in circuits.
-Check that the base type is actually a struct.`
-  },
-  {
-    error: "potential witness-value disclosure must be declared",
-    cause: "Circuit parameter flows to ledger operation without disclose()",
-    fix: `Disclose parameters at the start of the circuit:
-export circuit my_circuit(param: Bytes<32>): [] {
-  const d_param = disclose(param);  // Acknowledge on-chain visibility
-  ledger.insert(d_param, value);    // Now use disclosed value
-}`
-  },
-  {
-    error: "expected second argument of insert to have type Uint<64> but received Uint<0..N>",
-    cause: "Arithmetic result has bounded type, needs cast back to target",
-    fix: `Cast arithmetic results back to the target type:
-const new_balance = (current + amount) as Uint<64>;
-ledger_map.insert(key, new_balance);`
-  },
-  {
-    error: "cannot cast from type Uint<64> to type Bytes<32>",
-    cause: "Direct Uint to Bytes cast not allowed",
-    fix: `Go through Field first:
-const amount_field = amount as Field;
-const amount_bytes = amount_field as Bytes<32>;
-// Or chained: (amount as Field) as Bytes<32>`
-  },
-  {
-    error: "cannot prove assertion",
-    cause: "Assert condition cannot be proven true",
-    fix: `Check your logic. Common causes:
-1. Witness returns unexpected value
-2. Range check fails (use bounded Uint)
-3. Logic error in circuit`
-  },
-  {
-    error: 'parse error: found ":" looking for ")"',
-    cause: "Using Rust-style :: for enum variant access",
-    fix: `Use dot notation for enum variants:
-WRONG:  Choice::rock, GameState::waiting
-CORRECT: Choice.rock, GameState.waiting`
-  },
-  {
-    error: 'parse error: found "{" after witness declaration',
-    cause: "Trying to add implementation body to witness",
-    fix: `Witnesses are declarations only - no body allowed:
-WRONG:  witness get_caller(): Bytes<32> { return ...; }
-CORRECT: witness get_caller(): Bytes<32>;
-Implementation goes in TypeScript prover, not Compact.`
-  },
-  {
-    error: 'unbound identifier "function"',
-    cause: 'Using "pure function" instead of "pure circuit"',
-    fix: `Use "pure circuit" for helper functions:
-WRONG:  pure function helper(...): Type { }
-CORRECT: pure circuit helper(...): Type { }`
+      return {
+        contents: [
+          {
+            uri,
+            mimeType,
+            text: content
+          }
+        ]
+      };
+    } catch (error) {
+      logger.error(`Resource error: ${uri}`, { error: String(error) });
+      const errorResponse = formatErrorResponse(error, `resource:${uri}`);
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "application/json",
+            text: serialize(errorResponse)
+          }
+        ]
+      };
+    }
+  });
+}
+function registerPromptHandlers(server) {
+  server.setRequestHandler(ListPromptsRequestSchema, async () => {
+    logger.debug("Listing prompts");
+    return {
+      prompts: promptDefinitions.map((prompt) => ({
+        name: prompt.name,
+        description: prompt.description,
+        arguments: prompt.arguments
+      }))
+    };
+  });
+  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    logger.info(`Prompt requested: ${name}`, { args });
+    const prompt = promptDefinitions.find((p) => p.name === name);
+    if (!prompt) {
+      return {
+        description: `Unknown prompt: ${name}`,
+        messages: []
+      };
+    }
+    const messages = generatePrompt(name, args || {});
+    return {
+      description: prompt.description,
+      messages: messages.map((m) => ({
+        role: m.role,
+        content: m.content
+      }))
+    };
+  });
+}
+function registerSubscriptionHandlers(server) {
+  server.setRequestHandler(SubscribeRequestSchema, async (request) => {
+    const { uri } = request.params;
+    logger.info(`Subscribing to resource: ${uri}`);
+    const validPrefixes = [
+      "midnight://docs/",
+      "midnight://code/",
+      "midnight://schema/"
+    ];
+    const isValid = validPrefixes.some((prefix) => uri.startsWith(prefix));
+    if (!isValid) {
+      logger.warn(`Invalid subscription URI: ${uri}`);
+      throw new Error(
+        `Invalid subscription URI: ${uri}. Valid prefixes: ${validPrefixes.join(", ")}`
+      );
+    }
+    resourceSubscriptions.add(uri);
+    logger.debug(`Active subscriptions: ${resourceSubscriptions.size}`);
+    return {};
+  });
+  server.setRequestHandler(UnsubscribeRequestSchema, async (request) => {
+    const { uri } = request.params;
+    logger.info(`Unsubscribing from resource: ${uri}`);
+    resourceSubscriptions.delete(uri);
+    logger.debug(`Active subscriptions: ${resourceSubscriptions.size}`);
+    return {};
+  });
+}
+function setupSampling(server) {
+  const samplingCallback2 = async (request) => {
+    logger.debug("Requesting sampling from client", {
+      messageCount: request.messages.length,
+      maxTokens: request.maxTokens
+    });
+    try {
+      const response = await server.request(
+        {
+          method: "sampling/createMessage",
+          params: {
+            messages: request.messages,
+            systemPrompt: request.systemPrompt,
+            maxTokens: request.maxTokens || 2048,
+            temperature: request.temperature,
+            modelPreferences: request.modelPreferences
+          }
+        },
+        // Use a schema that matches the expected response
+        {
+          parse: (data) => {
+            const response2 = data;
+            if (!response2 || typeof response2 !== "object") {
+              throw new Error("Invalid sampling response: expected object");
+            }
+            if (!response2.content || typeof response2.content !== "object") {
+              throw new Error("Invalid sampling response: missing content");
+            }
+            return response2;
+          },
+          _def: { typeName: "SamplingResponse" }
+        }
+      );
+      return response;
+    } catch (error) {
+      logger.error("Sampling request failed", { error: String(error) });
+      throw error;
+    }
+  };
+  registerSamplingCallback(samplingCallback2);
+  logger.info("Sampling capability configured");
+}
+async function initializeServer() {
+  logger.info("Initializing Midnight MCP Server...");
+  checkForUpdates().catch((error) => {
+    logger.debug("Startup version check failed (non-blocking)", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+  });
+  try {
+    await vectorStore.initialize();
+    logger.info("Vector store initialized");
+  } catch (error) {
+    logger.warn("Vector store initialization failed, continuing without it", {
+      error: String(error)
+    });
   }
-];
+  const server = createServer();
+  logger.info(`Server v${CURRENT_VERSION} created successfully`);
+  return server;
+}
+async function startServer() {
+  const server = await initializeServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  setServerConnected(true);
+  logger.info("Midnight MCP Server running on stdio");
+}
+var transports = {
+  streamable: {},
+  sse: {}
+};
+function buildAllowlist(port) {
+  const hosts = [`127.0.0.1:${port}`, `localhost:${port}`];
+  const origins = hosts.flatMap((host) => [
+    `http://${host}`,
+    `https://${host}`
+  ]);
+  return { allowedHosts: hosts, allowedOrigins: origins };
+}
+function isRebindingBlocked(host, origin, allowedHosts, allowedOrigins) {
+  if (host && !allowedHosts.includes(host)) return true;
+  if (origin && !allowedOrigins.includes(origin)) return true;
+  return false;
+}
+async function closeTransports(transportMap) {
+  const closePromises = Object.values(transportMap).map(
+    (transport) => transport.close?.().catch(() => {
+    })
+  );
+  await Promise.all(closePromises);
+}
+async function startHttpServer(port = 3e3) {
+  const mcpServer = await initializeServer();
+  const app = express();
+  const { allowedHosts, allowedOrigins } = buildAllowlist(port);
+  app.use("/mcp", express.json());
+  app.get("/health", (_req, res) => {
+    res.json({
+      status: "ok",
+      version: CURRENT_VERSION,
+      transport: "http"
+    });
+  });
+  app.post("/mcp", async (req, res) => {
+    const sessionId = req.headers["mcp-session-id"];
+    let transport;
+    if (sessionId && transports.streamable[sessionId]) {
+      transport = transports.streamable[sessionId];
+    } else if (!sessionId && isInitializeRequest(req.body)) {
+      transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => randomUUID(),
+        // Block DNS-rebinding attacks from browser pages (loopback allowlist).
+        enableDnsRebindingProtection: true,
+        allowedHosts,
+        allowedOrigins,
+        onsessioninitialized: (newSessionId) => {
+          transports.streamable[newSessionId] = transport;
+          logger.debug(`New streamable session: ${newSessionId}`);
+        }
+      });
+      transport.onclose = () => {
+        if (transport.sessionId) {
+          delete transports.streamable[transport.sessionId];
+          logger.debug(`Streamable session closed: ${transport.sessionId}`);
+        }
+      };
+      try {
+        await mcpServer.connect(transport);
+      } catch (error) {
+        logger.error("Failed to connect streamable transport", {
+          error: String(error)
+        });
+        res.status(500).json({
+          jsonrpc: "2.0",
+          error: { code: -32603, message: "Internal error: connection failed" },
+          id: null
+        });
+        return;
+      }
+    } else {
+      res.status(400).json({
+        jsonrpc: "2.0",
+        error: {
+          code: -32e3,
+          message: "Bad Request: No valid session ID provided"
+        },
+        id: null
+      });
+      return;
+    }
+    await transport.handleRequest(req, res, req.body);
+  });
+  app.get("/sse", async (req, res) => {
+    const host = req.headers.host;
+    const origin = req.headers.origin;
+    if (isRebindingBlocked(host, origin, allowedHosts, allowedOrigins)) {
+      logger.warn(`Rejected SSE connection`, { host, origin });
+      res.status(403).send("Forbidden: invalid Host or Origin");
+      return;
+    }
+    logger.debug("New SSE connection");
+    const transport = new SSEServerTransport("/messages", res, {
+      enableDnsRebindingProtection: true,
+      allowedHosts,
+      allowedOrigins
+    });
+    transports.sse[transport.sessionId] = transport;
+    res.on("close", () => {
+      delete transports.sse[transport.sessionId];
+      logger.debug(`SSE session closed: ${transport.sessionId}`);
+    });
+    try {
+      await mcpServer.connect(transport);
+    } catch (error) {
+      delete transports.sse[transport.sessionId];
+      logger.error(`SSE connection failed: ${transport.sessionId}`, {
+        error: String(error)
+      });
+      res.status(500).end();
+    }
+  });
+  app.post("/messages", async (req, res) => {
+    const sessionId = req.query.sessionId;
+    const transport = transports.sse[sessionId];
+    if (transport) {
+      await transport.handlePostMessage(req, res);
+    } else {
+      res.status(400).send(`No transport found for sessionId ${sessionId}`);
+    }
+  });
+  const handleSessionRequest = async (req, res) => {
+    const sessionId = req.headers["mcp-session-id"];
+    if (!sessionId || !transports.streamable[sessionId]) {
+      res.status(400).send("Invalid or missing session ID");
+      return;
+    }
+    const transport = transports.streamable[sessionId];
+    await transport.handleRequest(req, res);
+  };
+  app.get("/mcp", handleSessionRequest);
+  app.delete("/mcp", handleSessionRequest);
+  const httpServer = app.listen(port, "127.0.0.1", () => {
+    logger.info(`Midnight MCP Server running on HTTP port ${port}`);
+    logger.info(`  Streamable HTTP: http://localhost:${port}/mcp`);
+    logger.info(`  SSE endpoint:    http://localhost:${port}/sse`);
+    logger.info(`  Health check:    http://localhost:${port}/health`);
+  });
+  const shutdown = async () => {
+    logger.info("Shutting down HTTP server...");
+    await closeTransports(transports.sse);
+    await closeTransports(transports.streamable);
+    httpServer.close(() => {
+      logger.info("Server shutdown complete");
+      process.exit(0);
+    });
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
 
 // src/tools/repository/validation.ts
 import { readFile } from "fs/promises";
@@ -7387,7 +7474,7 @@ async function extractContractStructure(input) {
       type: "invalid_pragma_format",
       line: lineNum,
       message: `Pragma includes patch version which may cause parse errors`,
-      suggestion: `Use bounded range format: 'pragma language_version >= 0.16 && <= 0.21;'`,
+      suggestion: `Use bounded range format: '${RECOMMENDED_PRAGMA}'`,
       severity: "error"
     });
   }
@@ -8427,6 +8514,36 @@ export circuit increment(): [] {
             wrong: "export circuit fn(param: T): [] { ledger.insert(param, v); }",
             correct: "export circuit fn(param: T): [] { const d = disclose(param); ledger.insert(d, v); }",
             error: "potential witness-value disclosure must be declared"
+          },
+          {
+            wrong: "NativePoint, nativePointX(p), constructNativePoint(x, y)",
+            correct: "JubjubPoint, jubjubPointX(p), constructJubjubPoint(x, y)",
+            error: "apparent use of an old standard-library / ledger operator name NativePoint: the new name is JubjubPoint (renamed in compactc 0.30.0)"
+          },
+          {
+            wrong: "const let = 1;  // or `let` used as any identifier",
+            correct: "const value = 1;  // rename the identifier",
+            error: 'parse error: found keyword "let" (which is reserved for future use)'
+          },
+          {
+            wrong: "const MAX_SUPPLY: Uint<64> = 1000;  // module-level const",
+            correct: "pure circuit max_supply(): Uint<64> { return 1000; }  // wrap in a pure circuit",
+            error: 'parse error: found keyword "const" looking for a program element'
+          },
+          {
+            wrong: "flags | mask  // bitwise OR on Uint",
+            correct: "// No bitwise ops on Uint \u2014 use arithmetic or branching. `||` is logical OR for Booleans only.",
+            error: "unexpected character (single `|` not recognized)"
+          },
+          {
+            wrong: "field: Uint<254>",
+            correct: "field: Uint<248>  // max byte-aligned Uint width",
+            error: "Uint width 254 is not between 1 and the maximum Uint width 248 (inclusive)"
+          },
+          {
+            wrong: "convertBytesToUint(255, n, bytes, src)  // number literal",
+            correct: "convertBytesToUint(255n, n, bytes, src)  // bigint literal",
+            error: "TypeScript binding: maxval is bigint since compactc 0.30.101 (avoids silent precision loss)"
           }
         ],
         syntaxReference: compactReference,
@@ -11172,4 +11289,4 @@ export {
   startServer,
   startHttpServer
 };
-//# sourceMappingURL=chunk-TSXIIBEH.js.map
+//# sourceMappingURL=chunk-F4KM42XU.js.map