@martinloop/mcp 0.5.5 → 0.5.6

package/dist/vendor/adapters/stub-agent-cli.js

@@ -0,0 +1,43 @@
+import { createAdapterCapabilities } from "./runtime-support.js";
+export function createStubAgentCliAdapter(options) {
+    const metadata = {
+        command: options.command.join(" "),
+        providerId: "agent-cli",
+        model: options.profile ?? options.command[0] ?? "default",
+        transport: "cli",
+        capabilities: createAdapterCapabilities(),
+        ...(options.profile ? { profile: options.profile } : {})
+    };
+    return {
+        adapterId: `agent-cli:stub:${options.command.join(":")}`,
+        kind: "agent-cli",
+        label: options.label ?? `Stub agent CLI (${options.command.join(" ")})`,
+        metadata,
+        async execute(request) {
+            if (options.responder) {
+                return await options.responder(request);
+            }
+            return {
+                status: "failed",
+                summary: `Stub agent CLI ${options.command.join(" ")} did not execute a live session.`,
+                usage: {
+                    actualUsd: 0,
+                    tokensIn: 0,
+                    tokensOut: 0,
+                    provenance: "unavailable"
+                },
+                verification: {
+                    passed: false,
+                    summary: "No CLI execution was attempted."
+                },
+                failure: {
+                    message: `Agent CLI ${options.command.join(" ")} is not configured for live execution.`,
+                    classHint: "environment_mismatch"
+                }
+            };
+        }
+    };
+}
+// Internal test-compatibility re-export. Public builders remove the entire
+// stub compatibility surface before constructing distributable packages.
+export { createStubDirectProviderAdapter } from "./stub-direct-provider.js";

package/dist/vendor/adapters/stub-direct-provider.d.ts

@@ -0,0 +1,8 @@
+import type { MartinAdapter, MartinAdapterRequest, MartinAdapterResult } from "../core/index.js";
+export interface StubDirectProviderAdapterOptions {
+    providerId: string;
+    model: string;
+    label?: string;
+    responder?: (request: MartinAdapterRequest) => Promise<MartinAdapterResult> | MartinAdapterResult;
+}
+export declare function createStubDirectProviderAdapter(options: StubDirectProviderAdapterOptions): MartinAdapter;

package/dist/vendor/adapters/stub-direct-provider.js

@@ -0,0 +1,16 @@
+import { createDirectProviderAdapter } from "./direct-provider.js";
+export function createStubDirectProviderAdapter(options) {
+    const adapter = createDirectProviderAdapter({
+        providerId: options.providerId,
+        model: options.model,
+        label: options.label ?? `Stub direct provider (${options.providerId}/${options.model})`,
+        capabilities: {
+            workspaceMutations: false
+        },
+        responder: options.responder
+    });
+    return {
+        ...adapter,
+        adapterId: `direct:stub:${options.providerId}:${options.model}`,
+    };
+}

package/dist/vendor/core/index.js

@@ -1,5 +1,3 @@
-import { spawnSync } from "node:child_process";
-import { isAbsolute, relative, resolve } from "node:path";
 import { DEFAULT_AGENT_EXECUTION_INTENT, normalizeProviderExecutionTimeoutMs, appendLoopEvent, createLoopRecord } from "../contracts/index.js";
 import { classifyFailure, computeEvidenceVector, evaluatePatchDecision, evaluateCostGovernor, evaluateBudgetPreflight, inferExit, nextPolicyPhase, policyPhaseToLifecycleState, scorePatchDecision, selectRecoveryRecipe } from "./policy.js";
 import { evaluateChangeApprovalLeash, evaluateFilesystemLeash, evaluateSecretLeash, redactSecretsFromText, resolveExecutionProfile, evaluateVerificationLeash } from "./leash.js";
@@ -796,6 +794,7 @@ export async function runMartin(input) {
             const attemptCompletedAt = now();
             const compiledContext = compilePromptPacket(request);
             const expectedVerifierBinding = resolveExpectedVerifierBinding(request);
+            const verifierConfigured = expectedVerifierBinding.commands.length > 0;
             const verification = normalizeVerificationOutcome(result, expectedVerifierBinding);
             // PATCH → VERIFY
             currentPhase = "VERIFY";
@@ -1135,17 +1134,12 @@ export async function runMartin(input) {
             // Uses the task's repoRoot to build/load the grounding index, then scans any diff
             let groundingScanResult;
             const patchDiff = buildPatchDiff(result, changedFiles);
-            const workspaceMutationCapable = executingAdapter.metadata.capabilities?.workspaceMutations !== false;
-            const hasReportedOrObservedChanges = changedFiles.length > 0 || (result.execution?.changedFiles?.length ?? 0) > 0;
-            const groundingEvidenceRequired = result.status === "completed" && workspaceMutationCapable && hasReportedOrObservedChanges;
-            let groundingEvidenceAvailable = !groundingEvidenceRequired;
-            if (groundingEvidenceRequired && patchDiff && input.task.repoRoot) {
+            if (patchDiff && input.task.repoRoot) {
                 try {
                     const groundingIndex = await loadOrBuildRepoGroundingIndex(input.task.repoRoot);
-                    groundingScanResult = reconcileExistingGroundingFiles(scanPatchForGroundingViolations(patchDiff, groundingIndex, {
+                    groundingScanResult = scanPatchForGroundingViolations(patchDiff, groundingIndex, {
                         allowedPaths: input.task.allowedPaths
-                    }), input.task.repoRoot, rollbackBoundary);
-                    groundingEvidenceAvailable = true;
+                    });
                     if (input.store && groundingScanResult.violations.length > 0) {
                         await input.store.appendLedger(loop.loopId, makeLedgerEvent({
                             kind: "grounding.violations_found",
@@ -1161,22 +1155,10 @@ export async function runMartin(input) {
                     }
                 }
                 catch {
-                    // Availability is persisted below so scanner failures and missing
-                    // grounding inputs follow the same recover-forward trust contract.
+                    // Grounding scan is best-effort — never fail the loop because of a scan error
                 }
             }
-            if (groundingEvidenceRequired && !groundingEvidenceAvailable) {
-                // The completed work remains useful, but unavailable grounding evidence
-                // cannot be converted into a zero-violation governance claim.
-                loop = {
-                    ...loop,
-                    metadata: {
-                        ...loop.metadata,
-                        groundingEvidenceStatus: "unavailable"
-                    }
-                };
-            }
-            const shouldEvaluatePatchTruth = result.status === "completed" && tracksWorkspaceMutations && groundingEvidenceAvailable;
+            const shouldEvaluatePatchTruth = result.status === "completed" && tracksWorkspaceMutations && verifierConfigured;
             let patchDecision;
             if (shouldEvaluatePatchTruth) {
                 patchDecision = evaluatePatchDecision({
@@ -1237,7 +1219,7 @@ export async function runMartin(input) {
                 }
                 else {
                     await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                        kind: verification.passed ? "attempt.kept" : "attempt.discarded",
+                        kind: verification.passed || !verifierConfigured ? "attempt.kept" : "attempt.discarded",
                         runId: loop.loopId,
                         attemptIndex: currentAttemptIndex,
                         payload: { reason: verification.summary }
@@ -1314,6 +1296,7 @@ export async function runMartin(input) {
                 lastResult: effectiveResult,
                 lastFailure: failure,
                 costState,
+                verificationRequired: verifierConfigured,
                 canSwitchAdapter: failure?.recommendedIntervention === "switch_adapter" &&
                     adapterChain[currentAdapterIndex] !== undefined &&
                     currentAdapter.adapterId !== executingAdapter.adapterId
@@ -1578,9 +1561,6 @@ function mergeCostProvenance(previous, current) {
     return COST_PROVENANCE_RANK[current] < COST_PROVENANCE_RANK[previous] ? current : previous;
 }
 function resolveChangedFiles(result, repoRoot, rollbackBoundary) {
-    if (repoRoot && rollbackBoundary?.headRef) {
-        return listAttemptChangedFilesSinceBoundary({ repoRoot, boundary: rollbackBoundary });
-    }
     if (result.execution?.changedFiles !== undefined) {
         return result.execution.changedFiles;
     }
@@ -1601,41 +1581,6 @@ function buildPatchDiff(result, changedFiles) {
     }
     return undefined;
 }
-function reconcileExistingGroundingFiles(scan, repoRoot, boundary) {
-    const resolvedFiles = new Set(scan.resolvedFiles);
-    const violations = scan.violations.filter((violation) => {
-        if (violation.kind !== "file_not_found") {
-            return true;
-        }
-        const absolutePath = resolve(repoRoot, violation.reference);
-        const relativePath = relative(repoRoot, absolutePath);
-        const isInsideRepo = relativePath.length > 0 && !relativePath.startsWith("..") && !isAbsolute(relativePath);
-        if (!isInsideRepo || !isTrackedRepoFileAtBoundary(repoRoot, violation.reference, boundary)) {
-            return true;
-        }
-        resolvedFiles.add(violation.reference);
-        return false;
-    });
-    return {
-        ...scan,
-        violations,
-        resolvedFiles: [...resolvedFiles]
-    };
-}
-function isTrackedRepoFileAtBoundary(repoRoot, filePath, boundary) {
-    if (!boundary) {
-        return false;
-    }
-    const normalizedPath = filePath.replace(/\\/gu, "/");
-    if (boundary.snapshots.some((snapshot) => snapshot.existed && snapshot.path === normalizedPath)) {
-        return true;
-    }
-    if (!boundary.headRef) {
-        return false;
-    }
-    const result = spawnSync("git", ["-C", repoRoot, "cat-file", "-e", `${boundary.headRef}:${normalizedPath}`], { encoding: "utf8", stdio: "ignore", windowsHide: true });
-    return result.status === 0;
-}
 function createBudgetSettlement(input) {
     const totalActualUsd = getUsageUsd(input.usage);
     return {

package/dist/vendor/core/policy.d.ts

@@ -97,6 +97,7 @@ export declare function inferExit(input: {
     lastFailure?: FailureAssessment;
     costState: CostGovernorState;
     canSwitchAdapter?: boolean;
+    verificationRequired?: boolean;
 }): ExitDecision;
 export interface BudgetPreflightInput {
     promptCharCount: number;

package/dist/vendor/core/policy.js

@@ -210,6 +210,14 @@ export function calculateCostPerOutcome(input) {
     };
 }
 export function inferExit(input) {
+    if (input.lastResult.status === "completed" && input.verificationRequired === false) {
+        return {
+            shouldExit: true,
+            lifecycleState: "completed",
+            status: "completed",
+            reason: "Execution-only work completed without verifier evidence; outcome is not VERIFIED."
+        };
+    }
     if (input.lastResult.status === "completed" && input.lastResult.verification.passed) {
         return {
             shouldExit: true,

package/dist/vendor/core/rollback.d.ts

@@ -1,4 +1,7 @@
 import type { PatchDecision, RollbackBoundaryArtifact, RollbackOutcomeArtifact } from "../contracts/index.js";
+export declare class RollbackStateUnavailableError extends Error {
+    constructor(message: string);
+}
 export declare function listAttemptChangedFilesSinceBoundary(input: {
     repoRoot?: string;
     boundary?: RollbackBoundaryArtifact;

package/dist/vendor/core/rollback.js

@@ -1,7 +1,12 @@
 import { spawnSync } from "node:child_process";
-import { readFileSync } from "node:fs";
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { dirname, relative, resolve } from "node:path";
+export class RollbackStateUnavailableError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "RollbackStateUnavailableError";
+    }
+}
 export function listAttemptChangedFilesSinceBoundary(input) {
     if (!input.repoRoot) {
         return [];
@@ -12,24 +17,11 @@ export function listAttemptChangedFilesSinceBoundary(input) {
     }
     const baselineTracked = new Set(input.boundary.trackedDirtyFiles);
     const baselineUntracked = new Set(input.boundary.untrackedFiles);
-    const baselineContentChanges = input.boundary.snapshots
-        .filter((snapshot) => snapshot.existed && repoFileDiffersFromSnapshot(input.repoRoot, snapshot))
-        .map((snapshot) => snapshot.path);
     return uniqueSorted([
         ...repoState.trackedDirtyFiles.filter((filePath) => !baselineTracked.has(filePath)),
-        ...repoState.untrackedFiles.filter((filePath) => !baselineUntracked.has(filePath)),
-        ...baselineContentChanges
+        ...repoState.untrackedFiles.filter((filePath) => !baselineUntracked.has(filePath))
     ]);
 }
-function repoFileDiffersFromSnapshot(repoRoot, snapshot) {
-    try {
-        const current = readFileSync(resolveRepoPath(repoRoot, snapshot.path));
-        return current.toString("base64") !== snapshot.contentBase64;
-    }
-    catch {
-        return true;
-    }
-}
 export async function captureRollbackBoundary(input) {
     if (!input.repoRoot) {
         return undefined;
@@ -147,6 +139,7 @@ function readRepoState(repoRoot) {
     };
 }
 function readGitLines(repoRoot, args) {
+    let lastFailure = "unknown Git failure";
     for (let attempt = 0; attempt < 2; attempt++) {
         const result = spawnSync("git", args, {
             cwd: repoRoot,
@@ -158,13 +151,14 @@ function readGitLines(repoRoot, args) {
                 .map((line) => normalizeRepoPath(line))
                 .filter(Boolean));
         }
+        lastFailure = gitFailureMessage(result);
         // Retry once after a short delay — handles git lock-file contention
         // that occurs when another process holds .git/index.lock.
         if (attempt === 0 && result.status !== 0) {
-            spawnSync("sleep", ["0.5"], { encoding: "utf8" });
+            delaySynchronously(500);
         }
     }
-    return [];
+    throw new RollbackStateUnavailableError(`Git rollback state unavailable for ${args.join(" ")}: ${lastFailure}`);
 }
 function readGitScalar(repoRoot, args) {
     const result = spawnSync("git", args, {
@@ -172,7 +166,7 @@ function readGitScalar(repoRoot, args) {
         encoding: "utf8"
     });
     if (result.status !== 0 || typeof result.stdout !== "string") {
-        return undefined;
+        throw new RollbackStateUnavailableError(`Git rollback state unavailable for ${args.join(" ")}: ${gitFailureMessage(result)}`);
     }
     const value = result.stdout.trim();
     return value.length > 0 ? value : undefined;
@@ -188,7 +182,10 @@ async function readRollbackSnapshot(repoRoot, filePath) {
             contentBase64: contents.toString("base64")
         };
     }
-    catch {
+    catch (error) {
+        if (!isFileNotFoundError(error)) {
+            throw new RollbackStateUnavailableError(`Rollback snapshot unavailable for ${normalizeRepoPath(filePath)}: ${toErrorMessage(error)}`);
+        }
         return {
             path: normalizeRepoPath(filePath),
             existed: false,
@@ -214,7 +211,7 @@ function restoreTrackedFileFromHead(repoRoot, filePath) {
         return;
     }
     // Retry once after a short delay (git lock-file contention)
-    spawnSync("sleep", ["0.5"], { encoding: "utf8" });
+    delaySynchronously(500);
     const retry = spawnSync("git", ["restore", "--staged", "--worktree", "--source=HEAD", "--", filePath], { cwd: repoRoot, encoding: "utf8" });
     if (retry.status === 0) {
         return;
@@ -264,3 +261,19 @@ function emptyRepoState() {
 function toErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function gitFailureMessage(result) {
+    if (result.error) {
+        return result.error.message;
+    }
+    if (typeof result.stderr === "string" && result.stderr.trim().length > 0) {
+        return result.stderr.trim();
+    }
+    return `git exited with status ${String(result.status)}`;
+}
+function isFileNotFoundError(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function delaySynchronously(milliseconds) {
+    const signal = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+    Atomics.wait(signal, 0, 0, milliseconds);
+}

package/dist/vendor/core/verified-handoff.js

@@ -33,6 +33,9 @@ export function verifierActuallyPassed(evidence, expected) {
     if (!evidence?.passed || !evidence.binding || !evidence.steps) {
         return false;
     }
+    if (expected.commands.length === 0) {
+        return false;
+    }
     if (evidence.binding.runId !== expected.runId ||
         evidence.binding.workspaceId !== expected.workspaceId ||
         evidence.binding.cwd !== expected.cwd ||
@@ -93,7 +96,6 @@ export function deriveVerifiedHandoffExecutionBoundary(loop) {
     const persistedMode = isExecutionMode(loop.metadata["executionMode"])
         ? loop.metadata["executionMode"]
         : undefined;
-    const groundingEvidenceAvailable = loop.metadata["groundingEvidenceStatus"] !== "unavailable";
     const executionMode = hasSimulatedAdapter
         ? "simulated"
         : hasVerifierOnlyAdapter
@@ -101,7 +103,7 @@ export function deriveVerifiedHandoffExecutionBoundary(loop) {
             : persistedMode ?? (adapterIds.length > 0 ? "governed" : "simulated");
     return {
         executionMode,
-        governanceClaimEligible: executionMode === "governed" && adapterIds.length > 0 && groundingEvidenceAvailable,
+        governanceClaimEligible: executionMode === "governed" && adapterIds.length > 0,
     };
 }
 function toEvidenceStatus(status) {
@@ -157,17 +159,34 @@ export function buildVerifiedHandoff(input) {
             "Test integrity was not evaluated for this run.",
     };
     const executionBoundary = deriveVerifiedHandoffExecutionBoundary(input.loop);
+    const verifierStepsActuallyPassed = input.verification.steps.length > 0 &&
+        input.verification.steps.every((step) => step.launched === true &&
+            step.completed === true &&
+            step.crashed === false &&
+            step.timedOut !== true &&
+            step.exitCode === 0);
+    const effectiveVerificationStatus = input.verification.status === "passed" && !verifierStepsActuallyPassed
+        ? input.verification.steps.length === 0
+            ? "not_run"
+            : "contradicted"
+        : input.verification.status;
+    const verificationWarnings = [
+        ...input.verification.warnings,
+        ...(effectiveVerificationStatus !== input.verification.status
+            ? ["A VERIFIED claim requires at least one launched, completed, exit-zero verifier step."]
+            : []),
+    ];
     const outcome = resolveVerifiedHandoffOutcome({
         lifecycleState: input.loop.lifecycleState,
         executionStatus: input.executionStatus,
-        verificationStatus: input.verification.status,
+        verificationStatus: effectiveVerificationStatus,
         receiptIntegrity: input.receiptIntegrity.state,
         scopeStatus: scope.status,
         testIntegrityStatus: testIntegrity.status,
         mutationRequired: input.mutationRequired ?? input.loop.task.mutationMode === "edit",
         changedFileCount: scope.changedFiles.length,
         definitionOfDonePreSatisfied: input.definitionOfDonePreSatisfied,
-        evidenceContradicted: input.evidenceContradicted ?? input.verification.status === "contradicted",
+        evidenceContradicted: input.evidenceContradicted ?? effectiveVerificationStatus === "contradicted",
         governanceClaimEligible: executionBoundary.governanceClaimEligible,
         unresolvedWorkCount: unresolvedWork.length,
     });
@@ -196,10 +215,10 @@ export function buildVerifiedHandoff(input) {
             lifecycleState: input.loop.lifecycleState,
         },
         verification: {
-            status: toEvidenceStatus(input.verification.status),
+            status: toEvidenceStatus(effectiveVerificationStatus),
             summary: input.verification.summary,
             checks: input.verification.steps.map(toCheck),
-            warnings: input.verification.warnings,
+            warnings: verificationWarnings,
         },
         requirements: input.requirements ?? [],
         scope,

package/dist/vendor/presentation/verified-handoff.js

@@ -22,19 +22,6 @@ function evidenceTone(status) {
 function humanize(value) {
     return value.replaceAll("_", " ").toLowerCase();
 }
-function formatCost(usd, provenance) {
-    if (provenance === "unavailable") {
-        return "unavailable";
-    }
-    const amount = "$" + usd.toFixed(2);
-    if (provenance === "actual") {
-        return amount + " provider-settled actual";
-    }
-    if (provenance === "calculated") {
-        return amount + " calculated from observed usage";
-    }
-    return amount + " estimated";
-}
 function checkSymbol(status) {
     if (status === "PASSED") {
         return "✓";
@@ -44,6 +31,16 @@ function checkSymbol(status) {
     }
     return "•";
 }
+function formatCost(usd, provenance) {
+    if (provenance === "unavailable")
+        return "unavailable";
+    const amount = "$" + usd.toFixed(2);
+    if (provenance === "actual")
+        return amount + " provider-settled actual";
+    if (provenance === "calculated")
+        return amount + " calculated from observed usage";
+    return amount + " estimated";
+}
 /**
  * Single source of truth for the trust-authority outcome calculation.
  * Both terminal and Markdown renderers call this — never duplicate.

package/package.json

@@ -1,81 +1,81 @@
-{
-  "name": "@martinloop/mcp",
-  "version": "0.5.5",
-  "mcpName": "io.github.Keesan12/martin-loop",
-  "private": false,
-  "type": "module",
-  "description": "MCP server for AI coding agents — verifier gates, stop limits, and Verified Handoffs.",
-  "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",
-    "mcpb:build": "node ./mcpb/build-mcpb.mjs",
-    "mcpb:validate": "mcpb validate ./dist-mcpb/martinloop",
-    "mcpb:smoke": "node ./mcpb/smoke-mcpb.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": {
-    "@anthropic-ai/mcpb": "2.1.2",
-    "@martin/contracts": "workspace:*",
-    "@martin/presentation": "workspace:*"
-  }
-}
+{
+  "name": "@martinloop/mcp",
+  "version": "0.5.6",
+  "mcpName": "io.github.Keesan12/martin-loop",
+  "private": false,
+  "type": "module",
+  "description": "MCP server for AI coding agents — verifier gates, stop limits, and Verified Handoffs.",
+  "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",
+    "mcpb:build": "node ./mcpb/build-mcpb.mjs",
+    "mcpb:validate": "mcpb validate ./dist-mcpb/martinloop",
+    "mcpb:smoke": "node ./mcpb/smoke-mcpb.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": {
+    "@anthropic-ai/mcpb": "2.1.2",
+    "@martin/contracts": "workspace:*",
+    "@martin/presentation": "workspace:*"
+  }
+}