tribunal-kit 6.0.0 → 7.0.0

package/bin/mcp-server.js

@@ -13,16 +13,24 @@
  * Protocol: MCP 2024-11-05 over JSON-RPC 2.0 / stdio
  */
 
-const path = require("path");
-const { spawnSync } = require("child_process");
+const path = require('path');
+const { spawnSync } = require('child_process');
 
-const PKG = require(path.resolve(__dirname, "../package.json"));
+const PKG = require(path.resolve(__dirname, '../package.json'));
 
 // Timeout for intentionally isolated child processes (30 seconds).
 const SPAWN_TIMEOUT_MS = 30000;
 
+class RpcError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = 'RpcError';
+  }
+}
+
 // Minimal JSON-RPC 2.0 over stdio
-const readline = require("readline");
+const readline = require('readline');
 
 const rl = readline.createInterface({
   input: process.stdin,
@@ -36,17 +44,12 @@ const rl = readline.createInterface({
  * explicitly supplied payload and schema.
  */
 function runTribunalAudit() {
-  const fs = require("fs");
+  const fs = require('fs');
   const projectRoot = process.cwd();
-  const manifestScript = path.join(
-    projectRoot,
-    ".agent",
-    "scripts",
-    "integrity_manifest.js",
-  );
+  const manifestScript = path.join(projectRoot, '.agent', 'scripts', 'integrity_manifest.js');
 
   if (!fs.existsSync(manifestScript)) {
-    return "Error: .agent/scripts/integrity_manifest.js was not found. Run `tk init` first.";
+    return 'Error: .agent/scripts/integrity_manifest.js was not found. Run `tk init` first.';
   }
 
   try {
@@ -56,7 +59,7 @@ function runTribunalAudit() {
 
     const { integrity } = manifest;
     const lines = [
-      "Tribunal audit complete.",
+      'Tribunal audit complete.',
       `Agents: ${manifest.agents.total} (${manifest.agents.reviewer_count} reviewers)`,
       `Skills: ${manifest.skills.total}`,
       `Scripts: ${manifest.scripts.total}`,
@@ -66,11 +69,13 @@ function runTribunalAudit() {
     ];
 
     if (integrity.phantom_references > 0 || integrity.invalid_claims > 0) {
-      lines.push("Audit found integrity issues; run `tk guardrail --scan` for remediation details.");
+      lines.push(
+        'Audit found integrity issues; run `tk guardrail --scan` for remediation details.',
+      );
     } else {
-      lines.push("All discovered references and global asset-count claims are valid.");
+      lines.push('All discovered references and global asset-count claims are valid.');
     }
-    return lines.join("\n");
+    return lines.join('\n');
   } catch (error) {
     return `Audit failed: ${error.message}`;
   }
@@ -80,228 +85,393 @@ function runTribunalAudit() {
  * Search case law in an isolated process because its CLI owns persistent state.
  */
 function searchCaseLaw(query) {
-  const caseLawScript = path.resolve(
-    __dirname,
-    "../.agent/scripts/case_law_manager.js",
-  );
+  const caseLawScript = path.resolve(__dirname, '../.agent/scripts/case_law_manager.js');
   // case_law_manager is a standalone stateful CLI, so retain its process boundary.
-  const result = spawnSync(
-    process.execPath,
-    [caseLawScript, "search-cases", "--query", query],
-    {
-      encoding: "utf8",
-      timeout: SPAWN_TIMEOUT_MS,
-    },
-  );
+  const result = spawnSync(process.execPath, [caseLawScript, 'search-cases', '--query', query], {
+    encoding: 'utf8',
+    timeout: SPAWN_TIMEOUT_MS,
+  });
   if (result.error) {
-    if (result.error.code === "ETIMEDOUT") return "Error: Case law search timed out (exceeded 30s limit)";
+    if (result.error.code === 'ETIMEDOUT')
+      return 'Error: Case law search timed out (exceeded 30s limit)';
     return `Error executing case law search: ${result.error.message}`;
   }
-  return result.stdout || result.stderr || "No results";
+  return result.stdout || result.stderr || 'No results';
 }
 
-
 function stripBoilerplate(text) {
   if (!text) return text;
-  let minified = text.replace(/AI coding assistants often fall into specific bad habits[\s\S]*$/g, "");
-  minified = minified.replace(/## 🤖 LLM-Specific Traps[\s\S]*$/g, "");
-  minified = minified.replace(/## 🏛️ Tribunal Integration[\s\S]*$/g, "");
-  minified = minified.replace(/## Pre-Flight Checklist[\s\S]*$/g, "");
+  let minified = text.replace(
+    /AI coding assistants often fall into specific bad habits[\s\S]*$/g,
+    '',
+  );
+  minified = minified.replace(/## 🤖 LLM-Specific Traps[\s\S]*$/g, '');
+  minified = minified.replace(/## 🏛️ Tribunal Integration[\s\S]*$/g, '');
+  minified = minified.replace(/## Pre-Flight Checklist[\s\S]*$/g, '');
   return minified.trim();
 }
 
+function getAgentDir() {
+  const fs = require('fs');
+  const local = path.join(process.cwd(), '.agent');
+  if (fs.existsSync(local)) return local;
+  return path.resolve(__dirname, '../.agent');
+}
+
 function handleRequest(req) {
-  if (req.method === "notifications/initialized" || req.method === "notifications/cancelled") {
+  const fs = require('fs');
+  if (req.method === 'notifications/initialized' || req.method === 'notifications/cancelled') {
     return null;
   }
-  if (req.method === "ping") {
+  if (req.method === 'ping') {
     return {};
   }
-  if (req.method === "resources/list") {
-    return { resources: [] };
-  }
-  if (req.method === "prompts/list") {
-    return { prompts: [] };
-  }
 
   // MCP spec: method names follow path-style convention
-  if (req.method === "initialize") {
+  if (req.method === 'initialize') {
     return {
-      protocolVersion: "2024-11-05",
+      protocolVersion: '2025-03-26',
       capabilities: {
         tools: {},
         resources: { subscribe: false, listChanged: false },
         prompts: { listChanged: false },
       },
       serverInfo: {
-        name: "tribunal-kit-mcp",
+        name: 'tribunal-kit-mcp',
         version: PKG.version,
       },
     };
   }
 
-  if (req.method === "tools/list") {
+  if (req.method === 'resources/list') {
+    const agentDir = getAgentDir();
+    const resources = [];
+
+    // Agents
+    const agentsDir = path.join(agentDir, 'agents');
+    if (fs.existsSync(agentsDir)) {
+      const files = fs.readdirSync(agentsDir).filter(f => f.endsWith('.md'));
+      for (const f of files) {
+        const name = path.basename(f, '.md');
+        resources.push({
+          uri: `tribunal://agent/${name}`,
+          name: `Agent: ${name}`,
+          description: `Tribunal Specialist Agent rule file for ${name}`,
+          mimeType: 'text/markdown',
+        });
+      }
+    }
+
+    // Skills
+    const skillsDir = path.join(agentDir, 'skills');
+    if (fs.existsSync(skillsDir)) {
+      const dirs = fs.readdirSync(skillsDir, { withFileTypes: true });
+      for (const d of dirs) {
+        if (d.isDirectory()) {
+          const skillFile = path.join(skillsDir, d.name, 'SKILL.md');
+          if (fs.existsSync(skillFile)) {
+            resources.push({
+              uri: `tribunal://skill/${d.name}`,
+              name: `Skill: ${d.name}`,
+              description: `Tribunal Skill instruction file for ${d.name}`,
+              mimeType: 'text/markdown',
+            });
+          }
+        }
+      }
+    }
+
+    // Workflows
+    const workflowsDir = path.join(agentDir, 'workflows');
+    if (fs.existsSync(workflowsDir)) {
+      const files = fs.readdirSync(workflowsDir).filter(f => f.endsWith('.md'));
+      for (const f of files) {
+        const name = path.basename(f, '.md');
+        resources.push({
+          uri: `tribunal://workflow/${name}`,
+          name: `Workflow: ${name}`,
+          description: `Tribunal Workflow guide for ${name}`,
+          mimeType: 'text/markdown',
+        });
+      }
+    }
+
+    return { resources };
+  }
+
+  if (req.method === 'resources/read') {
+    const uri = req.params && req.params.uri;
+    if (!uri) throw new Error('Missing uri parameter');
+    const agentDir = getAgentDir();
+    let filePath = null;
+
+    if (uri.startsWith('tribunal://agent/')) {
+      const name = uri.replace('tribunal://agent/', '');
+      filePath = path.join(agentDir, 'agents', `${name}.md`);
+    } else if (uri.startsWith('tribunal://skill/')) {
+      const name = uri.replace('tribunal://skill/', '');
+      filePath = path.join(agentDir, 'skills', name, 'SKILL.md');
+    } else if (uri.startsWith('tribunal://workflow/')) {
+      const name = uri.replace('tribunal://workflow/', '');
+      filePath = path.join(agentDir, 'workflows', `${name}.md`);
+    }
+
+    if (!filePath || !fs.existsSync(filePath)) {
+      throw new Error(`Resource not found: ${uri}`);
+    }
+
+    const text = fs.readFileSync(filePath, 'utf8');
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: 'text/markdown',
+          text,
+        },
+      ],
+    };
+  }
+
+  if (req.method === 'prompts/list') {
+    const agentDir = getAgentDir();
+    const prompts = [];
+    const workflowsDir = path.join(agentDir, 'workflows');
+
+    if (fs.existsSync(workflowsDir)) {
+      const files = fs.readdirSync(workflowsDir).filter(f => f.endsWith('.md'));
+      for (const f of files) {
+        const name = path.basename(f, '.md');
+        prompts.push({
+          name,
+          description: `Execute tribunal workflow /${name}`,
+          arguments: [
+            {
+              name: 'task',
+              description: 'The task or target file to execute the workflow against',
+              required: false,
+            },
+          ],
+        });
+      }
+    }
+
+    return { prompts };
+  }
+
+  if (req.method === 'prompts/get') {
+    const name = req.params && req.params.name;
+    const task = (req.params && req.params.arguments && req.params.arguments.task) || '';
+    if (!name) throw new Error('Missing prompt name parameter');
+
+    const agentDir = getAgentDir();
+    const workflowPath = path.join(agentDir, 'workflows', `${name}.md`);
+    if (!fs.existsSync(workflowPath)) {
+      throw new Error(`Prompt workflow not found: ${name}`);
+    }
+
+    const content = fs.readFileSync(workflowPath, 'utf8');
+    const promptText = task ? `${content}\n\nTarget Task/File: ${task}` : content;
+
+    return {
+      messages: [
+        {
+          role: 'user',
+          content: {
+            type: 'text',
+            text: promptText,
+          },
+        },
+      ],
+    };
+  }
+
+  if (req.method === 'tools/list') {
     return {
       tools: [
         {
-          name: "run_tribunal_audit",
-          description:
-            "Runs a full anti-hallucination audit across the workspace.",
+          name: 'run_tribunal_audit',
+          description: 'Runs a full anti-hallucination audit across the workspace.',
           inputSchema: {
-            type: "object",
+            type: 'object',
             properties: {},
             additionalProperties: false,
           },
         },
         {
-          name: "sync_ide_bridges",
-          description:
-            "Synchronize IDE bridge files with the current GEMINI.md rules.",
+          name: 'sync_ide_bridges',
+          description: 'Synchronize IDE bridge files with the current GEMINI.md rules.',
           inputSchema: {
-            type: "object",
+            type: 'object',
             properties: {},
             additionalProperties: false,
           },
         },
         {
-          name: "search_case_law",
+          name: 'search_case_law',
           description:
-            "Search historical code rejections and legal precedent. Use this before writing code to avoid past mistakes.",
+            'Search historical code rejections and legal precedent. Use this before writing code to avoid past mistakes.',
           inputSchema: {
-            type: "object",
+            type: 'object',
             properties: {
               query: {
-                type: "string",
+                type: 'string',
                 description: "Search query (e.g. 'useEffect state')",
               },
             },
-            required: ["query"],
+            required: ['query'],
             additionalProperties: false,
           },
         },
         {
-          name: "list_tribunal_agents",
-          description: "List all available Tribunal Kit agents.",
+          name: 'list_tribunal_agents',
+          description: 'List all available Tribunal Kit agents.',
           inputSchema: {
-            type: "object",
+            type: 'object',
             properties: {},
             additionalProperties: false,
           },
         },
         {
-          name: "get_tribunal_agent",
-          description: "Get the full markdown rules for a specific Tribunal agent.",
+          name: 'get_tribunal_agent',
+          description: 'Get the full markdown rules for a specific Tribunal agent.',
           inputSchema: {
-            type: "object",
+            type: 'object',
             properties: {
-              name: { type: "string", description: "The agent name (e.g. 'frontend-specialist')" },
+              name: { type: 'string', description: "The agent name (e.g. 'frontend-specialist')" },
             },
-            required: ["name"],
+            required: ['name'],
             additionalProperties: false,
           },
         },
         {
-          name: "list_tribunal_skills",
-          description: "List all available Tribunal Kit skills.",
+          name: 'list_tribunal_skills',
+          description: 'List all available Tribunal Kit skills.',
           inputSchema: {
-            type: "object",
+            type: 'object',
             properties: {},
             additionalProperties: false,
           },
         },
         {
-          name: "get_tribunal_skill",
-          description: "Get the full markdown instructions for a specific Tribunal skill.",
+          name: 'get_tribunal_skill',
+          description: 'Get the full markdown instructions for a specific Tribunal skill.',
           inputSchema: {
-            type: "object",
+            type: 'object',
             properties: {
-              name: { type: "string", description: "The skill name (e.g. 'react-specialist')" },
+              name: { type: 'string', description: "The skill name (e.g. 'react-specialist')" },
             },
-            required: ["name"],
+            required: ['name'],
             additionalProperties: false,
           },
         },
         {
-          name: "recall_memory",
-          description: "Budget-constrained memory recall from the 4-Type Taxonomy Persistent Memory Engine. Returns the most relevant memories that fit within the token budget, ranked by relevance × recency × priority. Use this BEFORE writing code to recall project guidelines without bloating context.",
+          name: 'recall_memory',
+          description:
+            'Budget-constrained memory recall from the 4-Type Taxonomy Persistent Memory Engine. Returns the most relevant memories that fit within the token budget, ranked by relevance × recency × priority. Use this BEFORE writing code to recall project guidelines without bloating context.',
           inputSchema: {
-            type: "object",
+            type: 'object',
             properties: {
               query: {
-                type: "string",
+                type: 'string',
                 description: "Search query (e.g. 'database', 'auth', 'deploy')",
               },
               budget: {
-                type: "number",
-                description: "Maximum token budget for recall (default: 2000). Only the top-ranked memories that fit within this budget are returned.",
+                type: 'number',
+                description:
+                  'Maximum token budget for recall (default: 2000). Only the top-ranked memories that fit within this budget are returned.',
               },
             },
-            required: ["query"],
+            required: ['query'],
             additionalProperties: false,
           },
         },
         {
-          name: "store_memory",
-          description: "Store a new memory entry in the 4-Type Taxonomy Persistent Memory Engine. Memories are schema-validated and persisted across sessions. Types: semantic (permanent facts), procedural (how-to recipes), episodic (30-day TTL events), working (session scratch).",
+          name: 'store_memory',
+          description:
+            'Store a new memory entry in the 4-Type Taxonomy Persistent Memory Engine. Memories are schema-validated and persisted across sessions. Types: semantic (permanent facts), procedural (how-to recipes), episodic (30-day TTL events), working (session scratch).',
           inputSchema: {
-            type: "object",
+            type: 'object',
             properties: {
               type: {
-                type: "string",
-                enum: ["semantic", "procedural", "episodic", "working"],
-                description: "Memory type: semantic (facts), procedural (recipes), episodic (events), working (scratch)",
+                type: 'string',
+                enum: ['semantic', 'procedural', 'episodic', 'working'],
+                description:
+                  'Memory type: semantic (facts), procedural (recipes), episodic (events), working (scratch)',
               },
               content: {
-                type: "string",
-                description: "The memory content to store",
+                type: 'string',
+                description: 'The memory content to store',
               },
               tags: {
-                type: "array",
-                items: { type: "string" },
-                description: "Searchable tags for this memory",
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Searchable tags for this memory',
               },
             },
-            required: ["type", "content"],
+            required: ['type', 'content'],
             additionalProperties: false,
           },
         },
         {
-          name: "get_sparse_context",
-          description: "Get a JIT, token-optimized context prompt tailored to the active task and files. Uses the Context Density Broker to score and select relevant skills, stripping duplicate boilerplate and saving up to 85% in prompt tokens.",
+          name: 'get_sparse_context',
+          description:
+            'Get a JIT, token-optimized context prompt tailored to the active task and files. Uses the Context Density Broker to score and select relevant skills, stripping duplicate boilerplate and saving up to 85% in prompt tokens.',
           inputSchema: {
-            type: "object",
+            type: 'object',
             properties: {
               task: {
-                type: "string",
+                type: 'string',
                 description: "The user task description (e.g. 'JWT auth API')",
               },
               files: {
-                type: "array",
-                items: { type: "string" },
+                type: 'array',
+                items: { type: 'string' },
                 description: "List of files being touched (e.g. ['src/auth.js'])",
               },
               model: {
-                type: "string",
-                enum: ["large", "small"],
-                description: "Model tier: large (default, includes key rules of supplementary skills) or small (essential skills only)",
+                type: 'string',
+                enum: ['large', 'small'],
+                description:
+                  'Model tier: large (default, includes key rules of supplementary skills) or small (essential skills only)',
               },
             },
-            required: ["task"],
+            required: ['task'],
             additionalProperties: false,
           },
         },
         {
-          name: "align_output",
-          description: "Align model outputs to Fabel-5 constraints: strips conversational introductions and conclusions, collapses single/double bullet items to prose, and checks for code traps (unawaited dynamic functions in Next.js 15, deprecated hooks in React 19, or non-existent models).",
+          name: 'align_output',
+          description:
+            'Align model outputs to Fabel-5 constraints: strips conversational introductions and conclusions, collapses single/double bullet items to prose, and checks for code traps (unawaited dynamic functions in Next.js 15, deprecated hooks in React 19, or non-existent models).',
           inputSchema: {
-            type: "object",
+            type: 'object',
             properties: {
               text: {
-                type: "string",
-                description: "The raw output text generated by the model to be aligned.",
+                type: 'string',
+                description: 'The raw output text generated by the model to be aligned.',
+              },
+            },
+            required: ['text'],
+            additionalProperties: false,
+          },
+        },
+        {
+          name: 'verify_contracts',
+          description:
+            'Verify proposed code changes against project behavioral contracts. Use BEFORE writing code to ensure compliance with team conventions.',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              file: {
+                type: 'string',
+                description: "Relative or absolute file path to verify (e.g. 'src/api/user.ts')",
+              },
+              content: {
+                type: 'string',
+                description: 'Proposed file content to verify against loaded contracts',
               },
             },
-            required: ["text"],
+            required: ['file', 'content'],
             additionalProperties: false,
           },
         },
@@ -309,217 +479,325 @@ function handleRequest(req) {
     };
   }
 
-  if (req.method === "tools/call") {
+  if (req.method === 'tools/call') {
     const toolName = req.params && req.params.name;
     if (!toolName) {
-      throw {
-        code: -32602,
-        message: "Missing required parameter: params.name",
-      };
+      throw new RpcError(-32602, 'Missing required parameter: params.name');
     }
 
-    if (toolName === "run_tribunal_audit") {
+    if (toolName === 'run_tribunal_audit') {
       const text = runTribunalAudit();
-      return { content: [{ type: "text", text }] };
+      return { content: [{ type: 'text', text }] };
     }
 
-    if (toolName === "sync_ide_bridges") {
-      const fs = require("fs");
+    if (toolName === 'sync_ide_bridges') {
+      const fs = require('fs');
       const cwd = process.cwd();
-      const agentDest = path.join(cwd, ".agent");
+      const agentDest = path.join(cwd, '.agent');
       if (!fs.existsSync(agentDest)) {
         return {
           content: [
             {
-              type: "text",
-              text: "Error: .agent/ directory not found. Run `tk init` first.",
+              type: 'text',
+              text: 'Error: .agent/ directory not found. Run `tk init` first.',
+            },
+          ],
+        };
+      }
+      try {
+        const { generateIDEBridges } = require(path.resolve(__dirname, '../dist/commands/init.js'));
+        // generateIDEBridges is async — execute synchronously in MCP context
+        generateIDEBridges(cwd, agentDest, true)
+          .then(() => {})
+          .catch(() => {});
+        return {
+          content: [
+            {
+              type: 'text',
+              text: 'Sync complete',
+            },
+          ],
+        };
+      } catch (e) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Sync failed: ${e.message}`,
             },
           ],
         };
       }
-      // Run synchronously by spawning a minimal script
-      const result = spawnSync(
-        process.execPath,
-        [
-          "-e",
-          `
-                const { generateIDEBridges } = require('${path.resolve(__dirname, "../dist/commands/init.js").replace(/\\/g, "\\\\")}');
-                generateIDEBridges('${cwd.replace(/\\/g, "\\\\")}', '${agentDest.replace(/\\/g, "\\\\")}', false).then(() => console.log('Sync complete'));
-            `,
-        ],
-        { encoding: "utf8", timeout: SPAWN_TIMEOUT_MS },
-      );
-      return {
-        content: [
-          {
-            type: "text",
-            text: result.stdout || result.stderr || "Sync complete",
-          },
-        ],
-      };
     }
 
-    if (toolName === "search_case_law") {
-      const query =
-        req.params && req.params.arguments && req.params.arguments.query;
-      if (!query || typeof query !== "string") {
-        throw {
-          code: -32602,
-          message: "Missing or invalid required argument: query (string)",
-        };
+    if (toolName === 'search_case_law') {
+      const query = req.params && req.params.arguments && req.params.arguments.query;
+      if (!query || typeof query !== 'string') {
+        throw new RpcError(-32602, 'Missing or invalid required argument: query (string)');
       }
       const text = searchCaseLaw(query);
-      return { content: [{ type: "text", text }] };
+      return { content: [{ type: 'text', text }] };
     }
 
-    if (toolName === "list_tribunal_agents") {
-      const fs = require("fs");
-      const agentDir = path.join(process.cwd(), ".agent", "agents");
-      if (!fs.existsSync(agentDir)) return { content: [{ type: "text", text: "No agents found or .agent directory missing." }] };
-      const agents = fs.readdirSync(agentDir).filter(f => f.endsWith('.md')).map(f => f.replace('.md', ''));
-      return { content: [{ type: "text", text: "Available Agents:\n- " + agents.join("\n- ") }] };
+    if (toolName === 'list_tribunal_agents') {
+      const fs = require('fs');
+      const agentDir = path.join(getAgentDir(), 'agents');
+      if (!fs.existsSync(agentDir))
+        return {
+          content: [{ type: 'text', text: 'No agents found or .agent directory missing.' }],
+        };
+      const agents = fs
+        .readdirSync(agentDir)
+        .filter(f => f.endsWith('.md'))
+        .map(f => f.replace('.md', ''));
+      return { content: [{ type: 'text', text: 'Available Agents:\n- ' + agents.join('\n- ') }] };
     }
 
-    if (toolName === "get_tribunal_agent") {
-      const fs = require("fs");
+    if (toolName === 'get_tribunal_agent') {
+      const fs = require('fs');
       const name = req.params?.arguments?.name;
-      if (!name || typeof name !== "string") throw { code: -32602, message: "Missing or invalid argument: name (string)" };
+      if (!name || typeof name !== 'string')
+        throw new RpcError(-32602, 'Missing or invalid argument: name (string)');
       const sanitizedName = path.basename(name);
-      const agentsDir = path.resolve(process.cwd(), ".agent", "agents");
+      const agentsDir = path.resolve(getAgentDir(), 'agents');
       const agentPath = path.resolve(agentsDir, `${sanitizedName}.md`);
       // Path containment: ensure resolved path stays within agents directory
-      if (!agentPath.startsWith(agentsDir)) throw { code: -32602, message: "Invalid agent name: path traversal detected" };
-      if (!fs.existsSync(agentPath)) return { content: [{ type: "text", text: `Agent '${sanitizedName}' not found.` }] };
-      const text = fs.readFileSync(agentPath, "utf8");
-      return { content: [{ type: "text", text: stripBoilerplate(text) }] };
+      if (!agentPath.startsWith(agentsDir))
+        throw new RpcError(-32602, 'Invalid agent name: path traversal detected');
+      if (!fs.existsSync(agentPath))
+        return { content: [{ type: 'text', text: `Agent '${sanitizedName}' not found.` }] };
+      const text = fs.readFileSync(agentPath, 'utf8');
+      return { content: [{ type: 'text', text: stripBoilerplate(text) }] };
     }
 
-    if (toolName === "list_tribunal_skills") {
-      const fs = require("fs");
-      const skillsDir = path.join(process.cwd(), ".agent", "skills");
-      if (!fs.existsSync(skillsDir)) return { content: [{ type: "text", text: "No skills found or .agent directory missing." }] };
-      const skills = fs.readdirSync(skillsDir, { withFileTypes: true }).filter(d => d.isDirectory()).map(d => d.name);
-      return { content: [{ type: "text", text: "Available Skills:\n- " + skills.join("\n- ") }] };
+    if (toolName === 'list_tribunal_skills') {
+      const fs = require('fs');
+      const skillsDir = path.join(getAgentDir(), 'skills');
+      if (!fs.existsSync(skillsDir))
+        return {
+          content: [{ type: 'text', text: 'No skills found or .agent directory missing.' }],
+        };
+      const skills = fs
+        .readdirSync(skillsDir, { withFileTypes: true })
+        .filter(d => d.isDirectory())
+        .map(d => d.name);
+      return { content: [{ type: 'text', text: 'Available Skills:\n- ' + skills.join('\n- ') }] };
     }
 
-    if (toolName === "get_tribunal_skill") {
-      const fs = require("fs");
+    if (toolName === 'get_tribunal_skill') {
+      const fs = require('fs');
       const name = req.params?.arguments?.name;
-      if (!name || typeof name !== "string") throw { code: -32602, message: "Missing or invalid argument: name (string)" };
+      if (!name || typeof name !== 'string')
+        throw new RpcError(-32602, 'Missing or invalid argument: name (string)');
       const sanitizedName = path.basename(name);
-      const skillsDir = path.resolve(process.cwd(), ".agent", "skills");
-      const skillPath = path.resolve(skillsDir, sanitizedName, "SKILL.md");
+      const skillsDir = path.resolve(getAgentDir(), 'skills');
+      const skillPath = path.resolve(skillsDir, sanitizedName, 'SKILL.md');
       // Path containment: ensure resolved path stays within skills directory
-      if (!skillPath.startsWith(skillsDir)) throw { code: -32602, message: "Invalid skill name: path traversal detected" };
-      if (!fs.existsSync(skillPath)) return { content: [{ type: "text", text: `Skill '${sanitizedName}' not found.` }] };
-      const text = fs.readFileSync(skillPath, "utf8");
-      return { content: [{ type: "text", text: stripBoilerplate(text) }] };
+      if (!skillPath.startsWith(skillsDir))
+        throw new RpcError(-32602, 'Invalid skill name: path traversal detected');
+      if (!fs.existsSync(skillPath))
+        return { content: [{ type: 'text', text: `Skill '${sanitizedName}' not found.` }] };
+      const text = fs.readFileSync(skillPath, 'utf8');
+      return { content: [{ type: 'text', text: stripBoilerplate(text) }] };
     }
 
-    if (toolName === "get_sparse_context") {
+    if (toolName === 'get_sparse_context') {
       const task = req.params?.arguments?.task;
       const files = req.params?.arguments?.files || [];
-      const model = req.params?.arguments?.model || "large";
+      const model = req.params?.arguments?.model || 'large';
 
-      if (!task) throw { code: -32602, message: "Missing required argument: task" };
+      if (!task) throw new RpcError(-32602, 'Missing required argument: task');
 
-      const agentDest = path.join(process.cwd(), ".agent");
-      const fs = require("fs");
+      const agentDest = getAgentDir();
+      const fs = require('fs');
       if (!fs.existsSync(agentDest)) {
-        return { content: [{ type: "text", text: "Error: .agent/ directory not found. Run `tk init` first." }] };
+        return {
+          content: [
+            { type: 'text', text: 'Error: .agent/ directory not found. Run `tk init` first.' },
+          ],
+        };
       }
 
       try {
-        const brokerScript = path.join(agentDest, "scripts", "context_broker.js");
+        const brokerScript = path.join(agentDest, 'scripts', 'context_broker.js');
         const { broker } = require(brokerScript);
         const brokerResult = broker(task, files, model, agentDest);
-        return { content: [{ type: "text", text: stripBoilerplate(brokerResult.promptText) }] };
+        return { content: [{ type: 'text', text: stripBoilerplate(brokerResult.promptText) }] };
       } catch (e) {
-        return { content: [{ type: "text", text: `Failed to retrieve sparse context: ${e.message}` }] };
+        return {
+          content: [{ type: 'text', text: `Failed to retrieve sparse context: ${e.message}` }],
+        };
       }
     }
 
-    if (toolName === "recall_memory") {
+    if (toolName === 'recall_memory') {
       const query = req.params?.arguments?.query;
-      if (!query || typeof query !== "string") {
-        throw { code: -32602, message: "Missing or invalid required argument: query (string)" };
+      if (!query || typeof query !== 'string') {
+        throw new RpcError(-32602, 'Missing or invalid required argument: query (string)');
       }
       const budget = req.params?.arguments?.budget || 2000;
-      const agentDest = path.join(process.cwd(), ".agent");
-      const fs = require("fs");
+      const agentDest = getAgentDir();
+      const fs = require('fs');
       if (!fs.existsSync(agentDest)) {
-        return { content: [{ type: "text", text: "Error: .agent/ directory not found. Run `tk init` first." }] };
+        return {
+          content: [
+            { type: 'text', text: 'Error: .agent/ directory not found. Run `tk init` first.' },
+          ],
+        };
       }
       try {
-        const { _memoryRecall } = require("../dist/commands/memory.js");
+        const { _memoryRecall } = require('../dist/commands/memory.js');
         const { results, tokens_used } = _memoryRecall(agentDest, query, budget);
         if (results.length === 0) {
-          return { content: [{ type: "text", text: `No memories match query: "${query}"` }] };
+          return { content: [{ type: 'text', text: `No memories match query: "${query}"` }] };
         }
         let text = `## Memory Recall (${results.length} results, ~${tokens_used}/${budget} tokens)\n\n`;
         for (const entry of results) {
           text += `- **[${entry.memory_type.toUpperCase()}]** #${entry.id}: ${entry.content}`;
-          if (entry.tags.length > 0) text += ` _(${entry.tags.join(", ")})_`;
+          if (entry.tags.length > 0) text += ` _(${entry.tags.join(', ')})_`;
           text += `\n`;
         }
-        return { content: [{ type: "text", text }] };
+        return { content: [{ type: 'text', text }] };
       } catch (e) {
-        return { content: [{ type: "text", text: `Memory recall failed: ${e.message}` }] };
+        return { content: [{ type: 'text', text: `Memory recall failed: ${e.message}` }] };
       }
     }
 
-    if (toolName === "store_memory") {
+    if (toolName === 'store_memory') {
       const memType = req.params?.arguments?.type;
       const content = req.params?.arguments?.content;
       const tags = req.params?.arguments?.tags || [];
       if (!memType || !content) {
-        throw { code: -32602, message: "Missing required arguments: type (string), content (string)" };
+        throw new RpcError(-32602, 'Missing required arguments: type (string), content (string)');
       }
-      const validTypes = ["semantic", "procedural", "episodic", "working"];
+      const validTypes = ['semantic', 'procedural', 'episodic', 'working'];
       if (!validTypes.includes(memType)) {
-        throw { code: -32602, message: `Invalid memory type: "${memType}". Must be one of: ${validTypes.join(", ")}` };
+        throw new RpcError(
+          -32602,
+          `Invalid memory type: "${memType}". Must be one of: ${validTypes.join(', ')}`,
+        );
       }
-      const agentDest = path.join(process.cwd(), ".agent");
-      const fs = require("fs");
+      const agentDest = getAgentDir();
+      const fs = require('fs');
       if (!fs.existsSync(agentDest)) {
-        return { content: [{ type: "text", text: "Error: .agent/ directory not found. Run `tk init` first." }] };
+        return {
+          content: [
+            { type: 'text', text: 'Error: .agent/ directory not found. Run `tk init` first.' },
+          ],
+        };
       }
       try {
-        const { _memoryStore } = require("../dist/commands/memory.js");
+        const { _memoryStore } = require('../dist/commands/memory.js');
         const result = _memoryStore(agentDest, memType, content, tags, null);
-        return { content: [{ type: "text", text: `Memory stored: #${result.id} (${memType}, ~${result.token_estimate} tokens)` }] };
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Memory stored: #${result.id} (${memType}, ~${result.token_estimate} tokens)`,
+            },
+          ],
+        };
       } catch (e) {
-        return { content: [{ type: "text", text: `Memory store failed: ${e.message}` }] };
+        return { content: [{ type: 'text', text: `Memory store failed: ${e.message}` }] };
       }
     }
 
-    if (toolName === "align_output") {
+    if (toolName === 'align_output') {
       const text = req.params?.arguments?.text;
-      if (typeof text !== "string") {
-        throw { code: -32602, message: "Missing or invalid required argument: text (string)" };
+      if (typeof text !== 'string') {
+        throw new RpcError(-32602, 'Missing or invalid required argument: text (string)');
       }
       try {
-        const { alignText, validateCodeContent } = require("../dist/commands/align.js");
+        const { alignText, validateCodeContent } = require('../dist/commands/align.js');
         const aligned = alignText(text);
         const warnings = validateCodeContent(aligned);
-        
+
         let outputText = aligned;
         if (warnings.length > 0) {
-          outputText += "\n\n⚠️  OCAE Alignment Validator Warnings:\n";
+          outputText += '\n\n⚠️  OCAE Alignment Validator Warnings:\n';
           for (const warnMsg of warnings) {
             outputText += `● ${warnMsg}\n`;
           }
         }
-        return { content: [{ type: "text", text: outputText }] };
+        return { content: [{ type: 'text', text: outputText }] };
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Output alignment failed: ${e.message}` }] };
+      }
+    }
+
+    if (toolName === 'verify_contracts') {
+      const file = req.params?.arguments?.file;
+      const content = req.params?.arguments?.content;
+
+      if (!file || typeof file !== 'string' || typeof content !== 'string') {
+        throw new RpcError(
+          -32602,
+          'Missing or invalid required arguments: file (string), content (string)',
+        );
+      }
+
+      try {
+        const projectRoot = process.cwd();
+        const contractEnginePath = path.join(getAgentDir(), 'scripts', 'contract_engine.js');
+        if (!require('fs').existsSync(contractEnginePath)) {
+          return {
+            content: [
+              { type: 'text', text: 'Error: contract_engine.js not found. Run `tk init` first.' },
+            ],
+          };
+        }
+
+        const contractEngine = require(contractEnginePath);
+        const contracts = contractEngine.loadContracts(projectRoot);
+
+        if (contracts.length === 0) {
+          return {
+            content: [
+              {
+                type: 'text',
+                text: 'No active behavioral contracts found in .tribunal/contracts/.',
+              },
+            ],
+          };
+        }
+
+        const relativePath = path.relative(projectRoot, file).replace(/\\/g, '/');
+        const allViolations = [];
+
+        for (const contract of contracts) {
+          const vList = contractEngine.evaluateContract(contract, relativePath, content);
+          if (vList.length > 0) {
+            allViolations.push(...vList);
+          }
+        }
+
+        if (allViolations.length === 0) {
+          return {
+            content: [
+              {
+                type: 'text',
+                text: '✅ Contract check passed. Zero behavioral violations detected.',
+              },
+            ],
+          };
+        }
+
+        let report = `📜 Contract Verification Results (${allViolations.length} violations):\n`;
+        for (const v of allViolations) {
+          report += `● [${v.severity.toUpperCase()}] ${v.contract}: ${v.message}\n`;
+          if (v.line) report += `   Line ${v.line}: ${v.snippet || ''}\n`;
+        }
+
+        return { content: [{ type: 'text', text: report }] };
       } catch (e) {
-        return { content: [{ type: "text", text: `Alignment failed: ${e.message}` }] };
+        return { content: [{ type: 'text', text: `Contract verification failed: ${e.message}` }] };
       }
     }
 
-    throw { code: -32601, message: `Unknown tool: ${toolName}` };
+    throw new RpcError(-32601, `Unknown tool: ${toolName}`);
   }
 
-  throw { code: -32601, message: `Unknown method: ${req.method}` };
+  throw new RpcError(-32601, `Unknown method: ${req.method}`);
 }
 
 function processSingleRequest(req) {
@@ -529,31 +807,32 @@ function processSingleRequest(req) {
     if (req.id === undefined || req.id === null) {
       return null;
     }
-    return { jsonrpc: "2.0", id: req.id, result };
+    return { jsonrpc: '2.0', id: req.id, result };
   } catch (e) {
-    const code = e && typeof e.code === "number" ? e.code : -32603;
-    const message = e && e.message ? e.message : "Internal server error";
+    const code = e && typeof e.code === 'number' ? e.code : -32603;
+    const message = e && e.message ? e.message : 'Internal server error';
     if (req.id === undefined || req.id === null) {
       return {
-        jsonrpc: "2.0",
+        jsonrpc: '2.0',
         id: null,
         error: { code, message },
       };
     }
     return {
-      jsonrpc: "2.0",
+      jsonrpc: '2.0',
       id: req.id,
       error: { code, message },
     };
   }
 }
 
-rl.on("line", (line) => {
-  if (line.length > 1048576) { // 1MB limit
+rl.on('line', line => {
+  if (line.length > 1048576) {
+    // 1MB limit
     const errorRes = {
-      jsonrpc: "2.0",
+      jsonrpc: '2.0',
       id: null,
-      error: { code: -32700, message: "Parse error: input line too long (exceeds 1MB limit)" },
+      error: { code: -32700, message: 'Parse error: input line too long (exceeds 1MB limit)' },
     };
     console.log(JSON.stringify(errorRes));
     return;
@@ -566,9 +845,9 @@ rl.on("line", (line) => {
   } catch (parseErr) {
     // Invalid JSON — send a parse error
     const errorRes = {
-      jsonrpc: "2.0",
+      jsonrpc: '2.0',
       id: null,
-      error: { code: -32700, message: "Parse error: " + parseErr.message },
+      error: { code: -32700, message: 'Parse error: ' + parseErr.message },
     };
     console.log(JSON.stringify(errorRes));
     return;
@@ -593,7 +872,7 @@ rl.on("line", (line) => {
   }
 });
 
-if (process.env.NODE_ENV === "test") {
+if (process.env.NODE_ENV === 'test') {
   module.exports = {
     handleRequest,
     stripBoilerplate,