@martinloop/mcp 0.2.5 → 0.3.0

package/dist/vendor/core/persistence/store.js

@@ -1,7 +1,8 @@
 /// <reference types="node" />
-import { appendFile, mkdir, writeFile } from "node:fs/promises";
+import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { writeReceiptIntegrityMaterial } from "./integrity.js";
 // ─── FileRunStore implementation ─────────────────────────────────────────────
 export function resolveRunsRoot(env = process.env) {
     return env["MARTIN_RUNS_DIR"]?.trim() ??
@@ -31,6 +32,7 @@ export function artifactDir(runsRoot, runId, attemptIndex) {
 export function createFileRunStore(options = {}) {
     const runsRoot = options.runsRoot ?? resolveRunsRoot();
     return {
+        runsRoot,
         async initRun(contract) {
             const dir = runDir(runsRoot, contract.runId);
             await mkdir(dir, { recursive: true });
@@ -50,6 +52,9 @@ export function createFileRunStore(options = {}) {
             const dir = artifactDir(runsRoot, runId, attemptIndex);
             await mkdir(dir, { recursive: true });
             await writeJsonFile(join(dir, "compiled-context.json"), artifacts.compiledContext);
+            if (artifacts.verification !== undefined) {
+                await writeJsonFile(join(dir, "verification.json"), artifacts.verification);
+            }
             if (artifacts.diff !== undefined) {
                 await writeFile(join(dir, "diff.patch"), artifacts.diff, "utf8");
             }
@@ -79,6 +84,25 @@ export function createFileRunStore(options = {}) {
             const dir = runDir(runsRoot, runId);
             await mkdir(dir, { recursive: true });
             await writeJsonFile(join(dir, "loop-record.json"), loop);
+            const ledgerRaw = await readFile(join(dir, "ledger.jsonl"), "utf8").catch(() => "");
+            const ledgerEntries = ledgerRaw
+                .split(/\r?\n/u)
+                .map((line) => line.trim())
+                .filter(Boolean)
+                .map((line) => JSON.parse(line));
+            await writeReceiptIntegrityMaterial({
+                runId,
+                runsRoot,
+                loopRecord: loop,
+                ledgerEntries,
+                scope: loop.receiptScope ??
+                    {
+                        ...(loop.task.repoRoot ? { repoRoot: loop.task.repoRoot } : {}),
+                        ...(loop.task.repoRoot ? { workingDirectory: loop.task.repoRoot } : {}),
+                        runsRoot
+                    },
+                signedAt: loop.updatedAt
+            });
         }
     };
 }

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

@@ -38,6 +38,15 @@ export interface MartinAdapterResultLike {
     verification: {
         passed: boolean;
         summary: string;
+        steps?: Array<{
+            command: string;
+            launched: boolean;
+            exitCode?: number;
+            timedOut: boolean;
+            fastFail?: boolean;
+            detail?: string;
+        }>;
+        warnings?: string[];
     };
     failure?: {
         message: string;

package/dist/workflow-state.d.ts

@@ -0,0 +1,25 @@
+type McpWorkflowStepName = "doctor" | "plan" | "preflight";
+export interface RecordMcpWorkflowStepInput {
+    runsRoot: string;
+    step: McpWorkflowStepName;
+    workingDirectory: string;
+    objective?: string;
+    engine?: string;
+    verificationPlan?: string[];
+}
+export interface EvaluateMcpRunGateInput {
+    runsRoot: string;
+    workingDirectory: string;
+    objective: string;
+    engine?: string;
+    verificationPlan?: string[];
+}
+export interface McpRunGateResult {
+    allowed: boolean;
+    nextAction: string;
+    summary: string;
+    missingSteps: McpWorkflowStepName[];
+}
+export declare function recordMcpWorkflowStep(input: RecordMcpWorkflowStepInput): Promise<void>;
+export declare function evaluateMcpRunGate(input: EvaluateMcpRunGateInput): Promise<McpRunGateResult>;
+export {};

package/dist/workflow-state.js

@@ -0,0 +1,102 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+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 PLAN_TTL_MS = 24 * 60 * 60 * 1000;
+const PREFLIGHT_TTL_MS = 6 * 60 * 60 * 1000;
+export async function recordMcpWorkflowStep(input) {
+    const state = await readWorkflowState(input.runsRoot);
+    state.mcp ??= {};
+    state.mcp[input.step] = {
+        step: input.step,
+        recordedAt: new Date().toISOString(),
+        workingDirectory: normalizeWorkingDirectory(input.workingDirectory),
+        ...(input.objective ? { objectiveKey: normalizeObjective(input.objective) } : {}),
+        ...(input.engine ? { engine: input.engine } : {}),
+        ...(input.verificationPlan ? { verificationPlanKey: hashVerificationPlan(input.verificationPlan) } : {})
+    };
+    await writeWorkflowState(input.runsRoot, state);
+}
+export async function evaluateMcpRunGate(input) {
+    const state = await readWorkflowState(input.runsRoot);
+    const mcpState = state.mcp ?? {};
+    const workingDirectory = normalizeWorkingDirectory(input.workingDirectory);
+    const objectiveKey = normalizeObjective(input.objective);
+    const engine = input.engine ?? "claude";
+    const verificationPlanKey = hashVerificationPlan(input.verificationPlan ?? []);
+    const missingSteps = [];
+    if (!isFresh(mcpState["doctor"], DOCTOR_TTL_MS, (receipt) => receipt.workingDirectory === workingDirectory)) {
+        missingSteps.push("doctor");
+    }
+    if (!isFresh(mcpState["plan"], PLAN_TTL_MS, (receipt) => receipt.workingDirectory === workingDirectory &&
+        receipt.objectiveKey === objectiveKey)) {
+        missingSteps.push("plan");
+    }
+    if (!isFresh(mcpState["preflight"], PREFLIGHT_TTL_MS, (receipt) => receipt.workingDirectory === workingDirectory &&
+        receipt.objectiveKey === objectiveKey &&
+        receipt.engine === engine &&
+        receipt.verificationPlanKey === verificationPlanKey)) {
+        missingSteps.push("preflight");
+    }
+    if (missingSteps.length === 0) {
+        return {
+            allowed: true,
+            nextAction: "martin_run",
+            summary: "Martin MCP governance receipts are present for this task.",
+            missingSteps
+        };
+    }
+    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.";
+    return {
+        allowed: false,
+        nextAction,
+        summary: `martin_run is blocked until Martin MCP receipts exist for ${missingSteps.join(", ")}.`,
+        missingSteps
+    };
+}
+async function readWorkflowState(runsRoot) {
+    const statePath = resolveWorkflowStatePath(runsRoot);
+    try {
+        const raw = await readFile(statePath, "utf8");
+        const parsed = JSON.parse(raw);
+        return parsed.version === 1 ? parsed : { version: 1 };
+    }
+    catch {
+        return { version: 1 };
+    }
+}
+async function writeWorkflowState(runsRoot, state) {
+    const statePath = resolveWorkflowStatePath(runsRoot);
+    await mkdir(join(resolve(runsRoot), WORKFLOW_STATE_DIRECTORY), { recursive: true });
+    await writeFile(statePath, JSON.stringify(state, null, 2), "utf8");
+}
+function resolveWorkflowStatePath(runsRoot) {
+    return join(resolve(runsRoot), WORKFLOW_STATE_DIRECTORY, WORKFLOW_STATE_FILENAME);
+}
+function isFresh(receipt, ttlMs, predicate) {
+    if (!receipt || !predicate(receipt)) {
+        return false;
+    }
+    const recordedAt = Date.parse(receipt.recordedAt);
+    if (Number.isNaN(recordedAt)) {
+        return false;
+    }
+    return Date.now() - recordedAt <= ttlMs;
+}
+function normalizeWorkingDirectory(workingDirectory) {
+    const resolved = resolve(workingDirectory);
+    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function normalizeObjective(objective) {
+    return objective.trim().replace(/\s+/gu, " ").toLowerCase();
+}
+function hashVerificationPlan(verificationPlan) {
+    const normalized = verificationPlan.map((step) => step.trim()).filter(Boolean);
+    return createHash("sha256").update(JSON.stringify(normalized)).digest("hex").slice(0, 12);
+}

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@martinloop/mcp",
-  "version": "0.2.5",
+  "version": "0.3.0",
   "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": "Vakeesan Mahalingam and Gobi Shanthan",
+  "author": "MartinLoop contributors",
   "homepage": "https://martinloop.com/",
   "repository": {
     "type": "git",
@@ -61,7 +61,7 @@
     "inspect:live": "node ./scripts/inspect-live.mjs"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@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",

package/server.json

@@ -7,12 +7,12 @@
     "url": "https://github.com/Keesan12/martin-loop",
     "source": "github"
   },
-  "version": "0.2.5",
+  "version": "0.3.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@martinloop/mcp",
-      "version": "0.2.5",
+      "version": "0.3.0",
       "transport": {
         "type": "stdio"
       }