@martinloop/mcp 0.3.5 → 0.3.6

package/dist/vendor/core/routing.js

@@ -84,6 +84,144 @@ function calculateDirectConfidence(signals, input) {
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// Cost-aware model tier routing
+//
+// Engine-agnostic tier system — each engine maps tiers to real model IDs.
+// Never pay for reasoning/orchestration on simple tasks.
+//
+// Tier → concrete model per engine:
+//   haiku  → claude-haiku-4-5, gpt-4o-mini, gemini-2.5-flash, deepseek-chat, qwen3-8b,  llama-3.1-8b
+//   sonnet → claude-sonnet-4-6, gpt-4o,     gemini-2.5-pro,  deepseek-r1,   qwen3-32b, llama-3.3-70b
+//   opus   → claude-opus-4-6,  o3,          gemini-2.5-ultra, deepseek-r1-671b, qwen3-235b, llama-3.1-405b
+//
+// Pricing reference (USD per 1M tokens, approx 2026):
+//   haiku:  $0.80 input / $4.00 output  (~1x baseline)
+//   sonnet: $3.00 input / $15.00 output (~4x haiku)
+//   opus:   $15.00 input / $75.00 output (~19x haiku)
+// ---------------------------------------------------------------------------
+const SONNET_AVG_COST_PER_USD_BUDGET = 0.35; // sonnet uses ~35% of budget on average
+const HAIKU_AVG_COST_PER_USD_BUDGET = 0.10; // haiku uses ~10% — ~3.5x cheaper
+function selectModelTier(mode) {
+    // Route already encodes complexity. Direct = passed the simplicity check → haiku.
+    if (mode === "direct")
+        return "haiku";
+    if (mode === "manager")
+        return "sonnet";
+    return "opus";
+}
+/**
+ * Resolve a tier to a concrete model ID for a specific engine.
+ * Allows downstream adapters to switch models automatically.
+ */
+export function resolveModelForTier(tier, engine) {
+    const matrix = {
+        claude: {
+            haiku: "claude-haiku-4-5-20251001",
+            sonnet: "claude-sonnet-4-6",
+            opus: "claude-opus-4-6"
+        },
+        codex: {
+            haiku: "gpt-4o-mini",
+            sonnet: "gpt-4.1",
+            opus: "o3"
+        },
+        gemini: {
+            haiku: "gemini-2.5-flash",
+            sonnet: "gemini-2.5-pro",
+            opus: "gemini-2.5-ultra"
+        },
+        openai: {
+            haiku: "gpt-4o-mini",
+            sonnet: "gpt-4o",
+            opus: "o3"
+        },
+        deepseek: {
+            haiku: "deepseek-chat",
+            sonnet: "deepseek-r1",
+            opus: "deepseek-r1"
+        },
+        qwen: {
+            haiku: "qwen/qwen3-8b",
+            sonnet: "qwen/qwen3-32b",
+            opus: "qwen/qwen3-235b-a22b"
+        },
+        llama: {
+            haiku: "meta-llama/llama-3.1-8b-instruct",
+            sonnet: "meta-llama/llama-3.3-70b-instruct",
+            opus: "meta-llama/llama-3.1-405b-instruct"
+        }
+    };
+    const engineKey = engine.toLowerCase().split("-")[0] ?? engine;
+    const claudeMatrix = matrix.claude;
+    return matrix[engineKey]?.[tier] ?? claudeMatrix?.[tier] ?? "claude-sonnet-4-6";
+}
+function estimateSavingVsSonnet(tier, budgetUsd) {
+    if (tier === "sonnet")
+        return 0;
+    if (tier === "haiku")
+        return Math.round((SONNET_AVG_COST_PER_USD_BUDGET - HAIKU_AVG_COST_PER_USD_BUDGET) * budgetUsd * 100) / 100;
+    // opus costs more than sonnet — negative saving
+    return Math.round(-1 * SONNET_AVG_COST_PER_USD_BUDGET * budgetUsd * 0.5 * 100) / 100;
+}
+/**
+ * Select the best available engine for a given tier requirement.
+ *
+ * When multiple engines are available, picks the cheapest that meets
+ * the capability requirement. Falls back gracefully:
+ * - If required tier unavailable, upgrades to next tier of same engine
+ * - If only one engine family available, uses its best equivalent
+ *
+ * @param requiredTier - Minimum capability tier needed
+ * @param availableEngines - What's installed and authenticated
+ * @returns Best engine ID and concrete model to use
+ */
+export function selectBestEngine(requiredTier, availableEngines) {
+    const available = availableEngines.filter((e) => e.available);
+    if (available.length === 0) {
+        // Nothing detected — default to claude (user must install)
+        return {
+            engineId: "claude",
+            model: resolveModelForTier(requiredTier, "claude"),
+            reasoning: "No engines detected. Defaulting to claude. Run martin doctor for setup instructions."
+        };
+    }
+    const tierRank = {
+        haiku: 0, sonnet: 1, opus: 2
+    };
+    const requiredRank = tierRank[requiredTier];
+    // Find the cheapest engine that meets or exceeds the required tier
+    const eligible = available
+        .filter((e) => tierRank[e.capabilityTier] >= requiredRank)
+        .sort((a, b) => {
+        // Sort by cost (cheap first), then by exact tier match
+        const costOrder = { cheap: 0, mid: 1, expensive: 2 };
+        if (costOrder[a.costTier] !== costOrder[b.costTier]) {
+            return costOrder[a.costTier] - costOrder[b.costTier];
+        }
+        // Prefer exact tier match over overqualified
+        const aExact = a.capabilityTier === requiredTier ? 0 : 1;
+        const bExact = b.capabilityTier === requiredTier ? 0 : 1;
+        return aExact - bExact;
+    });
+    if (eligible.length > 0) {
+        const best = eligible[0];
+        const model = resolveModelForTier(requiredTier, best.id);
+        return {
+            engineId: best.id,
+            model,
+            reasoning: `Selected ${best.id} (${model}) as cheapest available engine for ${requiredTier}-tier task.`
+        };
+    }
+    // All available engines are below required tier — upgrade to best available
+    const best = available.sort((a, b) => tierRank[b.capabilityTier] - tierRank[a.capabilityTier])[0];
+    const model = resolveModelForTier(best.capabilityTier, best.id);
+    return {
+        engineId: best.id,
+        model,
+        reasoning: `No ${requiredTier}-tier engine available. Upgrading to ${best.id} (${model}) — best available.`
+    };
+}
 export function classifyRoute(input) {
     const policy = { ...DEFAULT_ROUTING_POLICY, ...input.policy };
     const signals = extractComplexitySignals(input);
@@ -92,6 +230,7 @@ export function classifyRoute(input) {
     const blockedSteps = [];
     // Policy override: forced mode
     if (policy.mode === "direct") {
+        const tier = selectModelTier("direct");
         return {
             selectedMode: "direct",
             confidence: 1,
@@ -100,10 +239,13 @@ export function classifyRoute(input) {
             reason: ["Policy forces direct execution mode."],
             blockedSteps: ["manager", "planner", "router", "consensus"],
             compressed: true,
-            compressionSummary: "Policy: direct mode — skipping all orchestration."
+            compressionSummary: "Policy: direct mode — skipping all orchestration.",
+            recommendedModelTier: tier,
+            estimatedSavingVsSonnetUsd: estimateSavingVsSonnet(tier, input.budgetUsd)
         };
     }
     if (policy.mode === "consensus") {
+        const tier = selectModelTier("consensus");
         return {
             selectedMode: "consensus",
             confidence: 0.5,
@@ -111,7 +253,9 @@ export function classifyRoute(input) {
             expectedPreworkBurnPct: 35,
             reason: ["Policy forces consensus mode."],
             blockedSteps: [],
-            compressed: false
+            compressed: false,
+            recommendedModelTier: tier,
+            estimatedSavingVsSonnetUsd: estimateSavingVsSonnet(tier, input.budgetUsd)
         };
     }
     // Adaptive routing
@@ -124,6 +268,7 @@ export function classifyRoute(input) {
         if (signals.scopeRestricted)
             reason.push("Path scope is restricted.");
         blockedSteps.push("manager", "consensus");
+        const tier = selectModelTier("direct");
         return {
             selectedMode: "direct",
             confidence: directConfidence,
@@ -132,7 +277,9 @@ export function classifyRoute(input) {
             reason,
             blockedSteps,
             compressed: true,
-            compressionSummary: `Compressed from manager→planner→worker to direct worker. Estimated savings: ${String(Math.round(input.budgetUsd * 0.3 * 100) / 100)} USD.`
+            compressionSummary: `Compressed from manager→planner→worker to direct worker. Estimated savings: ${String(Math.round(input.budgetUsd * 0.3 * 100) / 100)} USD.`,
+            recommendedModelTier: tier,
+            estimatedSavingVsSonnetUsd: estimateSavingVsSonnet(tier, input.budgetUsd)
         };
     }
     // Complex task — needs orchestration
@@ -145,14 +292,18 @@ export function classifyRoute(input) {
     if (signals.fileCount > 5)
         reason.push(`Touches ${String(signals.fileCount)}+ files.`);
     const needsConsensus = signals.hasSecurityKeywords && signals.hasMigrationKeywords;
+    const mode = needsConsensus ? "consensus" : "manager";
+    const tier = selectModelTier(mode);
     return {
-        selectedMode: needsConsensus ? "consensus" : "manager",
+        selectedMode: mode,
         confidence: directConfidence,
         expectedCostUsd: input.budgetUsd * (needsConsensus ? 0.8 : 0.6),
         expectedPreworkBurnPct: needsConsensus ? 40 : 25,
         reason,
         blockedSteps: needsConsensus ? [] : ["consensus"],
-        compressed: false
+        compressed: false,
+        recommendedModelTier: tier,
+        estimatedSavingVsSonnetUsd: estimateSavingVsSonnet(tier, input.budgetUsd)
     };
 }
 function estimateDirectCost(budgetUsd) {

package/dist/vendor/core/test-integrity.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Test Integrity Validator
+ *
+ * Detects circular test validation — the problem where AI agents generate
+ * tests that only pass because they test the agent's own output, not real
+ * behavior. A test that passes on both the pre-change and post-change
+ * codebase proves nothing about the change.
+ *
+ * Strategy:
+ * 1. Snapshot which test files existed before the agent ran
+ * 2. After the run, identify NEW test files the agent created
+ * 3. For each new test: check if it imports/references pre-existing code
+ *    (real test) or only references agent-generated code (circular test)
+ * 4. Flag tests that don't exercise any pre-existing function
+ *
+ * This module provides the analysis primitives. The verification pipeline
+ * calls these during the post-run verification step.
+ */
+export interface TestIntegrityReport {
+    totalNewTests: number;
+    realTests: number;
+    suspiciousTests: number;
+    findings: TestIntegrityFinding[];
+    verdict: "pass" | "warn" | "fail";
+    summary: string;
+}
+export interface TestIntegrityFinding {
+    filePath: string;
+    issue: "no_pre_existing_imports" | "self_referential" | "trivial_assertion" | "empty_test";
+    severity: "high" | "medium" | "low";
+    detail: string;
+}
+/**
+ * Detect test files in a directory tree.
+ */
+export declare function findTestFiles(rootDir: string): string[];
+/**
+ * Check if a filename matches test file patterns.
+ */
+export declare function isTestFile(filename: string, fullPath?: string): boolean;
+/**
+ * Snapshot existing test files before an agent run.
+ */
+export declare function snapshotTestFiles(rootDir: string): Set<string>;
+/**
+ * Identify new test files created during an agent run.
+ */
+export declare function identifyNewTests(rootDir: string, preRunSnapshot: Set<string>): string[];
+/**
+ * Extract import paths from a TypeScript/JavaScript file.
+ */
+export declare function extractImports(content: string): string[];
+/**
+ * Check if a test file contains only trivial assertions.
+ */
+export declare function hasTrivialAssertionsOnly(content: string): boolean;
+/**
+ * Check if a test file imports any pre-existing source files.
+ */
+export declare function importsPreExistingCode(testContent: string, preRunSourceFiles: Set<string>): boolean;
+/**
+ * Validate the integrity of tests created during a governed run.
+ */
+export declare function validateTestIntegrity(rootDir: string, preRunTestSnapshot: Set<string>, preRunSourceFiles: Set<string>): TestIntegrityReport;

package/dist/vendor/core/test-integrity.js

@@ -0,0 +1,197 @@
+/**
+ * Test Integrity Validator
+ *
+ * Detects circular test validation — the problem where AI agents generate
+ * tests that only pass because they test the agent's own output, not real
+ * behavior. A test that passes on both the pre-change and post-change
+ * codebase proves nothing about the change.
+ *
+ * Strategy:
+ * 1. Snapshot which test files existed before the agent ran
+ * 2. After the run, identify NEW test files the agent created
+ * 3. For each new test: check if it imports/references pre-existing code
+ *    (real test) or only references agent-generated code (circular test)
+ * 4. Flag tests that don't exercise any pre-existing function
+ *
+ * This module provides the analysis primitives. The verification pipeline
+ * calls these during the post-run verification step.
+ */
+import { readFileSync, readdirSync, existsSync } from "node:fs";
+import { join, relative } from "node:path";
+const TEST_FILE_PATTERNS = [
+    /\.test\.[tj]sx?$/,
+    /\.spec\.[tj]sx?$/,
+    /\/__tests__\//,
+    /\/tests?\//
+];
+const TRIVIAL_ASSERTION_PATTERNS = [
+    /expect\(true\)\.toBe\(true\)/,
+    /expect\(1\)\.toBe\(1\)/,
+    /expect\(\)\.toBeUndefined\(\)/,
+    /assert\.ok\(true\)/,
+    /expect\(.*\)\.toBeDefined\(\)/,
+    /expect\(typeof\s+\w+\)\.toBe\(['"]\w+['"]\)/
+];
+const IMPORT_PATTERN = /(?:import\s+.*from\s+['"]([^'"]+)['"]|require\s*\(\s*['"]([^'"]+)['"]\s*\))/g;
+/**
+ * Detect test files in a directory tree.
+ */
+export function findTestFiles(rootDir) {
+    const results = [];
+    function walk(dir) {
+        if (!existsSync(dir))
+            return;
+        try {
+            const entries = readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = join(dir, entry.name);
+                if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git")
+                    continue;
+                if (entry.isDirectory()) {
+                    walk(fullPath);
+                }
+                else if (entry.isFile() && isTestFile(entry.name, fullPath)) {
+                    results.push(relative(rootDir, fullPath));
+                }
+            }
+        }
+        catch {
+            // Permission denied or inaccessible — skip silently
+        }
+    }
+    walk(rootDir);
+    return results;
+}
+/**
+ * Check if a filename matches test file patterns.
+ */
+export function isTestFile(filename, fullPath) {
+    const checkPath = fullPath ?? filename;
+    return TEST_FILE_PATTERNS.some((pattern) => pattern.test(checkPath));
+}
+/**
+ * Snapshot existing test files before an agent run.
+ */
+export function snapshotTestFiles(rootDir) {
+    return new Set(findTestFiles(rootDir));
+}
+/**
+ * Identify new test files created during an agent run.
+ */
+export function identifyNewTests(rootDir, preRunSnapshot) {
+    const currentTests = findTestFiles(rootDir);
+    return currentTests.filter((testPath) => !preRunSnapshot.has(testPath));
+}
+/**
+ * Extract import paths from a TypeScript/JavaScript file.
+ */
+export function extractImports(content) {
+    const imports = [];
+    let match;
+    const pattern = new RegExp(IMPORT_PATTERN.source, "g");
+    while ((match = pattern.exec(content)) !== null) {
+        const importPath = match[1] ?? match[2];
+        if (importPath)
+            imports.push(importPath);
+    }
+    return imports;
+}
+/**
+ * Check if a test file contains only trivial assertions.
+ */
+export function hasTrivialAssertionsOnly(content) {
+    const assertionLines = content.split("\n").filter((line) => /expect\(|assert\.|should\./i.test(line));
+    if (assertionLines.length === 0)
+        return true;
+    return assertionLines.every((line) => TRIVIAL_ASSERTION_PATTERNS.some((pattern) => pattern.test(line)));
+}
+/**
+ * Check if a test file imports any pre-existing source files.
+ */
+export function importsPreExistingCode(testContent, preRunSourceFiles) {
+    const imports = extractImports(testContent);
+    return imports.some((importPath) => {
+        // Relative imports that reference pre-existing files
+        if (importPath.startsWith(".") || importPath.startsWith("/")) {
+            // Normalize: strip extension, check if any pre-existing source matches
+            const normalized = importPath.replace(/\.[tj]sx?$/, "");
+            return [...preRunSourceFiles].some((srcFile) => {
+                const normalizedSrc = srcFile.replace(/\.[tj]sx?$/, "");
+                return normalizedSrc.endsWith(normalized) || normalized.endsWith(normalizedSrc);
+            });
+        }
+        // Package imports always count as real (they reference pre-existing deps)
+        return true;
+    });
+}
+/**
+ * Validate the integrity of tests created during a governed run.
+ */
+export function validateTestIntegrity(rootDir, preRunTestSnapshot, preRunSourceFiles) {
+    const newTests = identifyNewTests(rootDir, preRunTestSnapshot);
+    const findings = [];
+    for (const testPath of newTests) {
+        const fullPath = join(rootDir, testPath);
+        let content;
+        try {
+            content = readFileSync(fullPath, "utf8");
+        }
+        catch {
+            findings.push({
+                filePath: testPath,
+                issue: "empty_test",
+                severity: "high",
+                detail: "Test file could not be read."
+            });
+            continue;
+        }
+        if (content.trim().length === 0) {
+            findings.push({
+                filePath: testPath,
+                issue: "empty_test",
+                severity: "high",
+                detail: "Test file is empty."
+            });
+            continue;
+        }
+        if (hasTrivialAssertionsOnly(content)) {
+            findings.push({
+                filePath: testPath,
+                issue: "trivial_assertion",
+                severity: "high",
+                detail: "Test contains only trivial assertions (expect(true).toBe(true) or equivalent)."
+            });
+            continue;
+        }
+        if (!importsPreExistingCode(content, preRunSourceFiles)) {
+            findings.push({
+                filePath: testPath,
+                issue: "no_pre_existing_imports",
+                severity: "medium",
+                detail: "Test does not import any pre-existing source code. May be testing only agent-generated output."
+            });
+        }
+    }
+    const suspiciousTests = findings.filter((f) => f.severity === "high").length;
+    const realTests = newTests.length - suspiciousTests;
+    const verdict = suspiciousTests > 0 && suspiciousTests >= newTests.length * 0.5
+        ? "fail"
+        : suspiciousTests > 0
+            ? "warn"
+            : "pass";
+    const summary = newTests.length === 0
+        ? "No new test files detected."
+        : verdict === "pass"
+            ? `${newTests.length} new test(s) validated — all reference pre-existing code.`
+            : verdict === "warn"
+                ? `${suspiciousTests} of ${newTests.length} new test(s) flagged for review.`
+                : `Test integrity check failed: ${suspiciousTests} of ${newTests.length} new test(s) appear circular or trivial.`;
+    return {
+        totalNewTests: newTests.length,
+        realTests,
+        suspiciousTests,
+        findings,
+        verdict,
+        summary
+    };
+}

package/dist/workflow-state.d.ts

@@ -1,5 +1,5 @@
 import type { LoopBudget, ReceiptScope } from "./vendor/contracts/index.js";
-type McpWorkflowStepName = "doctor" | "plan" | "preflight";
+type McpWorkflowStepName = "doctor" | "plan" | "preflight" | "estimate" | "start";
 interface McpWorkflowReceipt {
     step: McpWorkflowStepName;
     recordedAt: string;

package/dist/workflow-state.js

@@ -4,6 +4,7 @@ import { join, resolve } from "node:path";
 const WORKFLOW_STATE_DIRECTORY = "_martin";
 const WORKFLOW_STATE_FILENAME = "workflow-state.json";
 const DOCTOR_TTL_MS = 24 * 60 * 60 * 1000;
+const ESTIMATE_TTL_MS = 6 * 60 * 60 * 1000; // Estimate expires after 6h — re-estimate if objective changes
 const PLAN_TTL_MS = 24 * 60 * 60 * 1000;
 const PREFLIGHT_TTL_MS = 6 * 60 * 60 * 1000;
 export async function recordMcpWorkflowStep(input) {
@@ -42,6 +43,11 @@ export async function evaluateMcpRunGate(input) {
         receipt.scopeKey === scopeKey)) {
         missingSteps.push("doctor");
     }
+    // Estimate is required before any run — it proves the agent assessed cost first.
+    // The estimate TTL is 6h; it doesn't need to match the exact objective key.
+    if (!isFresh(mcpState["estimate"], ESTIMATE_TTL_MS, (receipt) => receipt.workingDirectory === workingDirectory)) {
+        missingSteps.push("estimate");
+    }
     if (!isFresh(mcpState["plan"], PLAN_TTL_MS, (receipt) => receipt.workingDirectory === workingDirectory &&
         receipt.scopeKey === scopeKey &&
         receipt.objectiveKey === objectiveKey)) {
@@ -65,10 +71,12 @@ export async function evaluateMcpRunGate(input) {
         };
     }
     const nextAction = missingSteps[0] === "doctor"
-        ? "Call martin_doctor for this workingDirectory before any real run."
-        : missingSteps[0] === "plan"
-            ? "Call martin_plan with the exact objective before martin_run."
-            : "Call martin_preflight with the exact objective, verifier plan, and engine before martin_run.";
+        ? "Call martin_doctor to confirm environment before any work."
+        : missingSteps[0] === "estimate"
+            ? "Call martin_estimate with the objective to get cost and route before spending."
+            : missingSteps[0] === "plan"
+                ? "Call martin_plan with the exact objective before martin_run."
+                : "Call martin_preflight with the exact objective, verifier plan, and engine before martin_run.";
     return {
         allowed: false,
         nextAction,

package/package.json

@@ -1,76 +1,76 @@
-{
-  "name": "@martinloop/mcp",
-  "version": "0.3.5",
-  "mcpName": "io.github.Keesan12/martin-loop",
-  "private": false,
-  "type": "module",
-  "description": "Governed MCP server for AI coding agents with budgets, verifier gates, and inspectable runs.",
-  "license": "Apache-2.0",
-  "author": "MartinLoop contributors",
-  "homepage": "https://martinloop.com/",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Keesan12/martin-loop.git",
-    "directory": "packages/mcp"
-  },
-  "bugs": {
-    "url": "https://github.com/Keesan12/martin-loop/issues"
-  },
-  "keywords": [
-    "mcp",
-    "model-context-protocol",
-    "martin-loop",
-    "ai-agent",
-    "claude",
-    "codex",
-    "martin_doctor",
-    "martin_triage_runs",
-    "martin_run_dossier",
-    "mcp-resources",
-    "mcp-prompts"
-  ],
-  "bin": {
-    "mcp": "./dist/server.js",
-    "martin-loop-mcp": "./dist/server.js"
-  },
-  "exports": {
-    "./server.json": "./server.json",
-    "./package.json": "./package.json"
-  },
-  "files": [
-    "dist",
-    "README.md",
-    "server.json"
-  ],
-  "engines": {
-    "node": ">=20.0.0"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "build": "node ./scripts/build-package.mjs",
-    "prepack": "pnpm build",
-    "smoke:pack": "node ./scripts/smoke-package.mjs",
-    "smoke:published": "node ./scripts/smoke-published-package.mjs",
-    "smoke:published:pack": "node ./scripts/smoke-published-package.mjs --package-spec=pack",
-    "verify:release": "node --test ../../scripts/tests/publish-mcp-workflow.test.mjs ../../scripts/tests/mcp-publish-reliability.test.mjs ../../scripts/tests/mcp-release-docs.test.mjs",
-    "test:baseline": "node ./scripts/run-test-lane.mjs baseline",
-    "test": "vitest run --maxWorkers=1",
-    "lint": "tsc -p tsconfig.json --noEmit",
-    "start": "node dist/server.js",
-    "inspect:live": "node ./scripts/inspect-live.mjs"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "@open-policy-agent/opa-wasm": "^1.10.0",
-    "@opentelemetry/api-logs": "^0.214.0",
-    "@opentelemetry/exporter-logs-otlp-http": "^0.214.0",
-    "@opentelemetry/resources": "^2.6.1",
-    "@opentelemetry/sdk-logs": "^0.214.0",
-    "ts-morph": "^21.0.0"
-  },
-  "devDependencies": {
-    "@martin/contracts": "workspace:*"
-  }
-}
+{
+  "name": "@martinloop/mcp",
+  "version": "0.3.6",
+  "mcpName": "io.github.Keesan12/martin-loop",
+  "private": false,
+  "type": "module",
+  "description": "Governed MCP server for AI coding agents with budgets, verifier gates, and inspectable runs.",
+  "license": "Apache-2.0",
+  "author": "MartinLoop contributors",
+  "homepage": "https://martinloop.com/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Keesan12/martin-loop.git",
+    "directory": "packages/mcp"
+  },
+  "bugs": {
+    "url": "https://github.com/Keesan12/martin-loop/issues"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "martin-loop",
+    "ai-agent",
+    "claude",
+    "codex",
+    "martin_doctor",
+    "martin_triage_runs",
+    "martin_run_dossier",
+    "mcp-resources",
+    "mcp-prompts"
+  ],
+  "bin": {
+    "mcp": "./dist/server.js",
+    "martin-loop-mcp": "./dist/server.js"
+  },
+  "exports": {
+    "./server.json": "./server.json",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "server.json"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "node ./scripts/build-package.mjs",
+    "prepack": "pnpm build",
+    "smoke:pack": "node ./scripts/smoke-package.mjs",
+    "smoke:published": "node ./scripts/smoke-published-package.mjs",
+    "smoke:published:pack": "node ./scripts/smoke-published-package.mjs --package-spec=pack",
+    "verify:release": "node --test ../../scripts/tests/publish-mcp-workflow.test.mjs ../../scripts/tests/mcp-publish-reliability.test.mjs ../../scripts/tests/mcp-release-docs.test.mjs",
+    "test:baseline": "node ./scripts/run-test-lane.mjs baseline",
+    "test": "vitest run --maxWorkers=1",
+    "lint": "tsc -p tsconfig.json --noEmit",
+    "start": "node dist/server.js",
+    "inspect:live": "node ./scripts/inspect-live.mjs"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@open-policy-agent/opa-wasm": "^1.10.0",
+    "@opentelemetry/api-logs": "^0.214.0",
+    "@opentelemetry/exporter-logs-otlp-http": "^0.214.0",
+    "@opentelemetry/resources": "^2.6.1",
+    "@opentelemetry/sdk-logs": "^0.214.0",
+    "ts-morph": "^21.0.0"
+  },
+  "devDependencies": {
+    "@martin/contracts": "workspace:*"
+  }
+}