@martinloop/mcp 0.1.1 → 0.1.2

package/dist/vendor/core/persistence/index.d.ts

@@ -2,5 +2,7 @@ export { makeLedgerEvent } from "./ledger.js";
 export type { LedgerEvent, LedgerEventDraft, LedgerEventKind } from "./ledger.js";
 export { artifactDir, createFileRunStore, resolveRunsRoot, runDir } from "./store.js";
 export type { AttemptArtifacts, RunContract, RunStore } from "./store.js";
+export { readAllLoopRecords, readLatestLoopRecord, readLatestLoopRecordFromFile, readLoopRecordsFromFile } from "./runs-reader.js";
+export type { LoopAttemptRecord, LoopRunRecord } from "./runs-reader.js";
 export { compileAndPersistContext } from "./compiler.js";
 export type { CompileResult } from "./compiler.js";

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

@@ -1,4 +1,5 @@
 export { makeLedgerEvent } from "./ledger.js";
 export { artifactDir, createFileRunStore, resolveRunsRoot, runDir } from "./store.js";
+export { readAllLoopRecords, readLatestLoopRecord, readLatestLoopRecordFromFile, readLoopRecordsFromFile } from "./runs-reader.js";
 export { compileAndPersistContext } from "./compiler.js";
 //# sourceMappingURL=index.js.map

package/dist/vendor/core/persistence/runs-reader.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Reads completed loop records from ~/.martin/runs/ for analysis.
+ * Used by the Trust Calibration Engine and other offline analytics.
+ *
+ * Supports both storage layouts:
+ * - legacy root JSONL files: <runsRoot>/*.jsonl
+ * - canonical run trees: <runsRoot>/<loopId>/loop-record.json
+ */
+export interface LoopAttemptRecord {
+    index: number;
+    model?: string;
+    adapterId?: string;
+    failureClass?: string;
+    intervention?: string;
+    startedAt?: string;
+    completedAt?: string;
+}
+export interface LoopRunRecord {
+    loopId: string;
+    status: string;
+    lifecycleState: string;
+    createdAt: string;
+    updatedAt: string;
+    budget: {
+        maxUsd: number;
+        softLimitUsd: number;
+        maxIterations: number;
+        maxTokens: number;
+    };
+    cost: {
+        actualUsd: number;
+        tokensIn: number;
+        tokensOut: number;
+        avoidedUsd?: number;
+    };
+    attempts: LoopAttemptRecord[];
+    task: {
+        title: string;
+        objective: string;
+    };
+}
+export declare function readLoopRecordsFromFile(file: string): Promise<LoopRunRecord[]>;
+export declare function readLatestLoopRecordFromFile(file: string): Promise<LoopRunRecord | null>;
+/**
+ * Reads all loop records from the given directory (default: ~/.martin/runs/).
+ * Returns an empty array if the directory doesn't exist or has no records.
+ */
+export declare function readAllLoopRecords(runsDir?: string): Promise<LoopRunRecord[]>;
+/**
+ * Returns the most recently updated loop record, or null if none exist.
+ */
+export declare function readLatestLoopRecord(runsDir?: string): Promise<LoopRunRecord | null>;

package/dist/vendor/core/persistence/runs-reader.js

@@ -0,0 +1,84 @@
+/**
+ * Reads completed loop records from ~/.martin/runs/ for analysis.
+ * Used by the Trust Calibration Engine and other offline analytics.
+ *
+ * Supports both storage layouts:
+ * - legacy root JSONL files: <runsRoot>/*.jsonl
+ * - canonical run trees: <runsRoot>/<loopId>/loop-record.json
+ */
+import { readFile, readdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { extname, join } from "node:path";
+export async function readLoopRecordsFromFile(file) {
+    const text = await readFile(file, "utf8");
+    const extension = extname(file).toLowerCase();
+    if (extension === ".jsonl") {
+        return text
+            .split(/\r?\n/u)
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map((line) => JSON.parse(line));
+    }
+    const parsed = JSON.parse(text);
+    return Array.isArray(parsed) ? parsed : [parsed];
+}
+export async function readLatestLoopRecordFromFile(file) {
+    const records = await readLoopRecordsFromFile(file);
+    if (records.length === 0)
+        return null;
+    return records.reduce((latest, record) => {
+        const currentTimestamp = new Date(record.updatedAt ?? record.createdAt).getTime();
+        const latestTimestamp = new Date(latest.updatedAt ?? latest.createdAt).getTime();
+        return currentTimestamp > latestTimestamp ? record : latest;
+    }, records[0]);
+}
+/**
+ * Reads all loop records from the given directory (default: ~/.martin/runs/).
+ * Returns an empty array if the directory doesn't exist or has no records.
+ */
+export async function readAllLoopRecords(runsDir) {
+    const dir = runsDir ?? join(homedir(), ".martin", "runs");
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const records = [];
+    const jsonlFiles = entries
+        .filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl"))
+        .map((entry) => entry.name);
+    for (const file of jsonlFiles) {
+        try {
+            records.push(...(await readLoopRecordsFromFile(join(dir, file))));
+        }
+        catch {
+            // skip malformed files or lines
+        }
+    }
+    const runDirectories = entries.filter((entry) => entry.isDirectory());
+    for (const entry of runDirectories) {
+        try {
+            records.push(...(await readLoopRecordsFromFile(join(dir, entry.name, "loop-record.json"))));
+        }
+        catch {
+            // skip missing or malformed canonical records
+        }
+    }
+    return records;
+}
+/**
+ * Returns the most recently updated loop record, or null if none exist.
+ */
+export async function readLatestLoopRecord(runsDir) {
+    const records = await readAllLoopRecords(runsDir);
+    if (records.length === 0)
+        return null;
+    return records.reduce((latest, r) => {
+        const a = new Date(r.updatedAt ?? r.createdAt).getTime();
+        const b = new Date(latest.updatedAt ?? latest.createdAt).getTime();
+        return a > b ? r : latest;
+    }, records[0]);
+}
+//# sourceMappingURL=runs-reader.js.map

package/dist/vendor/core/persistence/store.d.ts

@@ -1,4 +1,4 @@
-import type { LoopBudget, LoopTask, MachineState } from "../../contracts/index.js";
+import type { LoopBudget, LoopRecord, LoopTask, MachineState } from "../../contracts/index.js";
 import { type LedgerEvent } from "./ledger.js";
 export interface RunContract {
     runId: string;
@@ -53,6 +53,11 @@ export interface RunStore {
      * Write artifacts for a completed attempt to artifacts/attempt-<n>/.
      */
     writeAttemptArtifacts(runId: string, attemptIndex: number, artifacts: AttemptArtifacts): Promise<void>;
+    /**
+     * Persist the latest canonical loop record snapshot when the caller has one.
+     * Optional to avoid breaking custom RunStore implementations.
+     */
+    writeLoopRecord?(runId: string, loop: LoopRecord): Promise<void>;
 }
 export declare function resolveRunsRoot(env?: NodeJS.ProcessEnv): string;
 export declare function runDir(runsRoot: string, runId: string): string;

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

@@ -74,6 +74,11 @@ export function createFileRunStore(options = {}) {
             if (artifacts.rollbackOutcome !== undefined) {
                 await writeJsonFile(join(dir, "rollback-outcome.json"), artifacts.rollbackOutcome);
             }
+        },
+        async writeLoopRecord(runId, loop) {
+            const dir = runDir(runsRoot, runId);
+            await mkdir(dir, { recursive: true });
+            await writeJsonFile(join(dir, "loop-record.json"), loop);
         }
     };
 }

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

@@ -18,6 +18,12 @@ export interface ExitDecision {
     lifecycleState: LoopLifecycleState;
     status: LoopStatus;
     reason: string;
+    /** Machine-readable stop classifier for non-attempt exits such as preflight safety blocks. */
+    failureClass?: FailureClass;
+    /** Machine-readable safety surface, when the stop came from a safety leash. */
+    safetySurface?: string;
+    /** Stable reason code for dashboards, MCP, and downstream automation. */
+    reasonCode?: string;
 }
 export interface MartinAdapterResultLike {
     status: "completed" | "failed";

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@martinloop/mcp",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "mcpName": "io.github.keesan12/martin-loop",
   "private": false,
   "type": "module",
-  "description": "Martin Loop MCP server — installable stdio server for martin_run, martin_inspect, and martin_status.",
+  "description": "Governed MCP server for AI coding agents with budgets, verifier gates, policy checks, and audit trails.",
   "license": "MIT",
   "author": "Vakeesan Mahalingam and Gobi Shanthan",
   "homepage": "https://martinloop.com/",
@@ -27,7 +27,8 @@
   "main": "./dist/server.js",
   "types": "./dist/server.d.ts",
   "bin": {
-    "mcp": "dist/server.js"
+    "mcp": "./dist/server.js",
+    "martin-loop-mcp": "./dist/server.js"
   },
   "exports": {
     ".": {
@@ -41,7 +42,7 @@
     "README.md"
   ],
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.0.0"
   },
   "publishConfig": {
     "access": "public"
@@ -50,11 +51,18 @@
     "build": "node ./scripts/build-package.mjs",
     "prepack": "pnpm build",
     "smoke:pack": "node ./scripts/smoke-package.mjs",
+    "smoke:published": "node ./scripts/smoke-published-package.mjs",
     "test": "vitest run",
     "lint": "tsc -p tsconfig.json --noEmit",
     "start": "node dist/server.js"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0"
+    "@modelcontextprotocol/sdk": "^1.0.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"
   }
 }