@martinloop/mcp 0.3.2 → 0.3.4

package/dist/server-validation.js

@@ -2,6 +2,7 @@ import { existsSync, lstatSync, realpathSync } from "node:fs";
 import { dirname, extname, isAbsolute, relative, resolve } from "node:path";
 import { resolveRunsRoot } from "./vendor/core/index.js";
 import { invalidArgumentsError, invalidPathError, invalidSelectorError } from "./tools/tool-errors.js";
+import { MARTIN_ENGINE_VALUES } from "./tools/tool-support.js";
 export { sanitizeToolErrorMessage } from "./tools/tool-errors.js";
 export function validateToolInput(name, args) {
     switch (name) {
@@ -147,6 +148,7 @@ function validateRunInput(args) {
         "maxUsd",
         "maxIterations",
         "maxTokens",
+        "verifyTimeoutMs",
         "maxMinutes",
         "maxFilesChanged",
         "maxCommands",
@@ -156,7 +158,7 @@ function validateRunInput(args) {
         "workspaceId",
         "projectId"
     ]);
-    const engine = optionalEnum(record.engine, "engine", ["claude", "codex", "gemini"]);
+    const engine = optionalEnum(record.engine, "engine", MARTIN_ENGINE_VALUES);
     return {
         objective: requireString(record.objective, "objective"),
         ...(record.workingDirectory !== undefined
@@ -175,6 +177,7 @@ function validateRunInput(args) {
         ...optionalPositiveNumber(record.maxUsd, "maxUsd"),
         ...optionalPositiveInteger(record.maxIterations, "maxIterations"),
         ...optionalPositiveInteger(record.maxTokens, "maxTokens"),
+        ...optionalPositiveInteger(record.verifyTimeoutMs, "verifyTimeoutMs"),
         ...optionalPositiveInteger(record.maxMinutes, "maxMinutes"),
         ...optionalPositiveInteger(record.maxFilesChanged, "maxFilesChanged"),
         ...optionalPositiveInteger(record.maxCommands, "maxCommands"),
@@ -246,7 +249,7 @@ function validateDoctorInput(args) {
         ...(record.runsDir !== undefined
             ? { runsDir: resolveSafeRunsRootPath(requireString(record.runsDir, "runsDir")) }
             : {}),
-        ...optionalEnumAsObject(record.engine, "engine", ["claude", "codex", "gemini"])
+        ...optionalEnumAsObject(record.engine, "engine", MARTIN_ENGINE_VALUES)
     };
 }
 function validatePreflightInput(args) {

package/dist/server.js

@@ -42,6 +42,7 @@ import { martinRunDossierTool } from "./tools/run-dossier.js";
 import { createRunControlReceipt } from "./tools/run-controls.js";
 import { martinTriageRunsTool } from "./tools/triage-runs.js";
 import { runLoopTool } from "./tools/run-loop.js";
+import { MARTIN_ENGINE_VALUES } from "./tools/tool-support.js";
 import { createToolErrorResult, createToolSuccessResult } from "./tools/tool-response.js";
 import { MartinToolError, toToolFailure } from "./tools/tool-errors.js";
 import { normalizeLoopBudget } from "./tools/workflow-governance.js";
@@ -117,7 +118,7 @@ const verificationSchema = {
     type: "object",
     additionalProperties: true,
     properties: {
-        status: { type: "string", enum: ["passed", "failed", "unavailable"] },
+        status: { type: "string", enum: ["passed", "failed", "contradicted", "not_run"] },
         eventCount: { type: "integer" },
         ledgerEventCount: { type: "integer" },
         latestAttemptIndex: { type: "integer" },
@@ -739,7 +740,7 @@ export function createMartinMcpServer(serverInfo) {
                         },
                         engine: {
                             type: "string",
-                            enum: ["claude", "codex", "gemini"],
+                            enum: [...MARTIN_ENGINE_VALUES],
                             description: "Which agent CLI to use. Defaults to claude."
                         },
                         model: {
@@ -871,7 +872,7 @@ export function createMartinMcpServer(serverInfo) {
                         },
                         engine: {
                             type: "string",
-                            enum: ["claude", "codex", "gemini"],
+                            enum: [...MARTIN_ENGINE_VALUES],
                             description: "Optional engine to highlight in diagnostics."
                         }
                     }
@@ -934,7 +935,7 @@ export function createMartinMcpServer(serverInfo) {
                         },
                         engine: {
                             type: "string",
-                            enum: ["claude", "codex", "gemini"],
+                            enum: [...MARTIN_ENGINE_VALUES],
                             description: "Which agent CLI would be used. Defaults to claude."
                         },
                         model: {

package/dist/tools/eval.js

@@ -15,15 +15,20 @@ export async function martinEvalTool(input) {
         verifiers: detail.loop.task?.verificationPlan ?? [],
         signals
     });
+    const observationMismatch = hasObservationMismatch(detail.loop.events ?? []);
     const checks = {
         taskCompletion: detail.loop.status === "completed" ? "passed" : detail.loop.status === "exited" ? "warning" : "failed",
         verifier: verification.status === "passed"
             ? "passed"
-            : verification.status === "failed"
+            : verification.status === "failed" || verification.status === "contradicted"
                 ? "failed"
                 : "warning",
-        diffDiscipline: (detail.loop.task?.allowedPaths?.length ?? 0) > 0 ? "passed" : "warning",
-        regressionRisk: verification.status === "passed" ? "passed" : "warning",
+        diffDiscipline: observationMismatch
+            ? "failed"
+            : (detail.loop.task?.allowedPaths?.length ?? 0) > 0
+                ? "passed"
+                : "warning",
+        regressionRisk: verification.status === "passed" && !observationMismatch ? "passed" : "warning",
         securityRisk: risk.level === "high" ? "failed" : risk.level === "medium" ? "warning" : "passed",
         reviewability: detail.loop.attempts.length > 0 && (detail.loop.events?.length ?? 0) > 0 ? "passed" : "warning"
     };
@@ -35,7 +40,7 @@ export async function martinEvalTool(input) {
     score -= checks.securityRisk === "failed" ? 20 : checks.securityRisk === "warning" ? 10 : 0;
     score -= checks.reviewability === "warning" ? 8 : 0;
     score = Math.max(0, score);
-    const grade = verification.status === "unavailable"
+    const grade = verification.status === "not_run" || observationMismatch
         ? "insufficient_evidence"
         : score >= 90
             ? "mergeable"
@@ -44,7 +49,14 @@ export async function martinEvalTool(input) {
                 : score >= 55
                     ? "needs_review"
                     : "blocked";
-    const warnings = [...detail.warnings, ...verification.warnings, ...risk.reasons];
+    const warnings = [
+        ...detail.warnings,
+        ...verification.warnings,
+        ...risk.reasons,
+        ...(observationMismatch
+            ? ["Change observation mismatch: adapter-reported files differ from repo-observed files."]
+            : [])
+    ];
     return {
         source: detail.source,
         sourceKind: detail.sourceKind,
@@ -64,3 +76,15 @@ export async function martinEvalTool(input) {
                         : `Run ${detail.loop.loopId} is blocked from promotion by verification or risk gaps.`
     };
 }
+function hasObservationMismatch(events) {
+    return events.some((event) => {
+        if (event.type !== "observation.reconciled") {
+            return false;
+        }
+        const observation = isRecord(event.payload?.["observation"]) ? event.payload?.["observation"] : undefined;
+        return observation?.["status"] === "mismatch";
+    });
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/dist/tools/execution-policy.d.ts

@@ -0,0 +1,11 @@
+import { type ExecutionPolicy } from "../vendor/contracts/index.js";
+export interface CompileMcpExecutionPolicyInput {
+    workingDirectory: string;
+    maxUsd?: number;
+    maxIterations?: number;
+    maxTokens?: number;
+    verificationPlan?: string[];
+    allowedPaths?: string[];
+    deniedPaths?: string[];
+}
+export declare function compileMcpExecutionPolicy(input: CompileMcpExecutionPolicyInput): ExecutionPolicy;

package/dist/tools/execution-policy.js

@@ -0,0 +1,47 @@
+import { DEFAULT_BUDGET } from "../vendor/contracts/index.js";
+import { compileExecutionPolicy } from "../vendor/core/index.js";
+export function compileMcpExecutionPolicy(input) {
+    const normalizedBudget = {
+        maxUsd: input.maxUsd ?? DEFAULT_BUDGET.maxUsd,
+        softLimitUsd: Math.min(DEFAULT_BUDGET.softLimitUsd, input.maxUsd ?? DEFAULT_BUDGET.maxUsd),
+        maxIterations: input.maxIterations ?? DEFAULT_BUDGET.maxIterations,
+        maxTokens: input.maxTokens ?? DEFAULT_BUDGET.maxTokens
+    };
+    const policy = compileExecutionPolicy({
+        configPath: "mcp://inline",
+        defaults: {
+            budget: DEFAULT_BUDGET,
+            policyProfile: "balanced",
+            telemetryDestination: "local-only",
+            destructiveActionPolicy: "approval",
+            verifierRules: []
+        },
+        request: {
+            budget: normalizedBudget,
+            budgetOverrides: {
+                ...(input.maxUsd !== undefined ? { maxUsd: true } : {}),
+                ...(input.maxIterations !== undefined ? { maxIterations: true } : {}),
+                ...(input.maxTokens !== undefined ? { maxTokens: true } : {})
+            },
+            verificationPlan: input.verificationPlan,
+            repoRoot: input.workingDirectory,
+            allowedPaths: input.allowedPaths,
+            deniedPaths: input.deniedPaths
+        }
+    });
+    const softLimitSource = input.maxUsd !== undefined && normalizedBudget.softLimitUsd !== DEFAULT_BUDGET.softLimitUsd
+        ? "request"
+        : "default";
+    return {
+        ...policy,
+        budget: normalizedBudget,
+        provenance: [
+            ...policy.provenance.filter((entry) => entry.field !== "budget.softLimitUsd"),
+            {
+                field: "budget.softLimitUsd",
+                source: softLimitSource,
+                value: String(normalizedBudget.softLimitUsd)
+            }
+        ]
+    };
+}

package/dist/tools/run-dossier.js

@@ -37,12 +37,12 @@ export async function martinRunDossierTool(input) {
         risk,
         outcome: verification.status === "passed"
             ? "passed"
-            : verification.status === "failed"
+            : verification.status === "failed" || verification.status === "contradicted"
                 ? "failed"
                 : "needs_review",
         nextAction: verification.status === "passed"
             ? "Review the dossier and evaluation, then decide whether to merge or promote."
-            : verification.status === "failed"
+            : verification.status === "failed" || verification.status === "contradicted"
                 ? "Investigate the latest verifier failure before retrying or promoting."
                 : "Collect more evidence before claiming completion."
     };

package/dist/tools/run-loop.d.ts

@@ -5,11 +5,12 @@ import { buildArtifactSummary, buildVerificationSummary, buildLoopPreview, type
 export interface RunLoopInput {
     objective: string;
     workingDirectory?: string;
-    engine?: "claude" | "codex" | "gemini";
+    engine?: MartinEngine;
     model?: string;
     maxUsd?: number;
     maxIterations?: number;
     maxTokens?: number;
+    verifyTimeoutMs?: number;
     verificationPlan?: string[];
     allowedPaths?: string[];
     deniedPaths?: string[];

package/dist/tools/run-loop.js

@@ -66,17 +66,27 @@ export async function runLoopTool(input) {
         ? createVerifierOnlyAdapter({
             workingDirectory,
             label: "Proof mode adapter (MARTIN_LIVE=false)",
+            ...(input.verifyTimeoutMs !== undefined ? { verifyTimeoutMs: input.verifyTimeoutMs } : {}),
             ...(proofModeVerifierSpawnImpl ? { spawnImpl: proofModeVerifierSpawnImpl } : {})
         })
         : engine === "codex"
             ? createCodexCliAdapter({
                 workingDirectory,
+                ...(input.verifyTimeoutMs !== undefined ? { verifyTimeoutMs: input.verifyTimeoutMs } : {}),
                 ...(model ? { model } : {}),
                 ...(codexCommandOverride ? { command: codexCommandOverride } : {})
             })
             : engine === "gemini"
-                ? createGeminiCliAdapter({ workingDirectory, ...(model ? { model } : {}) })
-                : createClaudeCliAdapter({ workingDirectory, ...(model ? { model } : {}) });
+                ? createGeminiCliAdapter({
+                    workingDirectory,
+                    ...(input.verifyTimeoutMs !== undefined ? { verifyTimeoutMs: input.verifyTimeoutMs } : {}),
+                    ...(model ? { model } : {})
+                })
+                : createClaudeCliAdapter({
+                    workingDirectory,
+                    ...(input.verifyTimeoutMs !== undefined ? { verifyTimeoutMs: input.verifyTimeoutMs } : {}),
+                    ...(model ? { model } : {})
+                });
     const partialBudget = {};
     if (input.maxUsd !== undefined) {
         partialBudget.maxUsd = input.maxUsd;
@@ -97,6 +107,9 @@ export async function runLoopTool(input) {
             title: input.objective.slice(0, 100),
             objective: input.objective,
             verificationPlan: input.verificationPlan ?? [],
+            ...(input.verifyTimeoutMs !== undefined
+                ? { verificationTimeoutMs: input.verifyTimeoutMs }
+                : {}),
             repoRoot: workingDirectory,
             ...(allowedPaths ? { allowedPaths } : {}),
             ...(deniedPaths ? { deniedPaths } : {})

package/dist/tools/run-store.js

@@ -1,8 +1,10 @@
-import { readFile, readdir, stat } from "node:fs/promises";
+import { open, readFile, readdir, stat } from "node:fs/promises";
 import path from "node:path";
 import { readLatestLoopRecordFromFile, readLoopRecordsFromFile, resolveRunsRoot, verifyReceiptIntegrityFromFiles } from "../vendor/core/index.js";
 import { resolveSafeLoopRecordPath, resolveSafeRunsJsonPath, resolveSafeRunsPath, resolveSafeRunsRootPath } from "../server-validation.js";
 import { attemptNotFoundError, invalidSelectorError, noLoopRecordsError, storeUnreadableError } from "./tool-errors.js";
+const RUN_INDEX_FILENAME = "run-index.ndjson";
+const RUN_INDEX_READ_MAX_BYTES = 2 * 1024 * 1024;
 async function attachReceiptIntegrity(detail) {
     const ledgerPath = detail.canonicalRunDirectory
         ? await resolveReceiptEvidencePath(detail.canonicalRunDirectory)
@@ -14,13 +16,18 @@ async function attachReceiptIntegrity(detail) {
             loopRecordPath: detail.canonicalLoopRecordPath,
             ledgerPath
         }).catch(() => ({
-            state: "unsigned",
+            state: "material_missing",
             reason: "Receipt integrity verification could not be completed."
         }))
-        : ({
-            state: "unsigned",
-            reason: "Receipt integrity is only available for canonical run directories."
-        });
+        : detail.canonicalLoopRecordPath && detail.canonicalRunDirectory
+            ? ({
+                state: "material_missing",
+                reason: "Receipt integrity material is incomplete for this canonical run."
+            })
+            : ({
+                state: "selector_noncanonical",
+                reason: "Receipt integrity is only available for canonical run selectors."
+            });
     const receiptScope = resolveReceiptScope(detail.loop, detail.runsRoot);
     return {
         ...detail,
@@ -107,6 +114,20 @@ export async function loadLoopRecordForStatus(input) {
 }
 export async function listLoopRecords(input) {
     const runsRoot = resolveSafeRunsRootPath(input.runsDir, resolveRunsRoot(process.env));
+    const indexed = await listLoopsFromRunIndex(runsRoot, input);
+    if (indexed.loops.length > 0) {
+        const loops = indexed.loops;
+        const warnings = [...indexed.warnings];
+        if (loops.length === 0) {
+            warnings.push("No loop records matched the current filters.");
+        }
+        return {
+            source: runsRoot,
+            runsRoot,
+            loops,
+            warnings
+        };
+    }
     const inspected = await readAllLoopRecordsSafely(runsRoot);
     const warnings = [...inspected.warnings];
     const updatedAfterTimestamp = input.updatedAfter !== undefined ? new Date(input.updatedAfter).getTime() : undefined;
@@ -248,6 +269,15 @@ export async function loadDetailedLoopRecord(input) {
             warnings: [...detail.warnings, ...inspected.warnings]
         });
     }
+    const indexedLatest = await loadLatestLoopFromRunIndex(runsRoot);
+    if (indexedLatest) {
+        return await attachReceiptIntegrity(await buildDetailedLoopSourceFromDiscoveredLoop({
+            source: runsRoot,
+            sourceKind: "latest",
+            runsRoot,
+            loop: indexedLatest.loop
+        }));
+    }
     const inspected = await readAllLoopRecordsSafely(runsRoot);
     const loop = inspected.loops[0];
     if (!loop) {
@@ -264,6 +294,129 @@ export async function loadDetailedLoopRecord(input) {
         warnings: [...detail.warnings, ...inspected.warnings]
     });
 }
+async function listLoopsFromRunIndex(runsRoot, input) {
+    const indexed = await readRunIndexEntries(runsRoot);
+    if (indexed.entries.length === 0) {
+        return { loops: [], warnings: [] };
+    }
+    const warnings = [];
+    const updatedAfterTimestamp = input.updatedAfter !== undefined ? new Date(input.updatedAfter).getTime() : undefined;
+    if (input.updatedAfter !== undefined &&
+        (!Number.isFinite(updatedAfterTimestamp) || Number.isNaN(updatedAfterTimestamp))) {
+        throw invalidSelectorError("Invalid updatedAfter.", "Provide updatedAfter as an ISO-8601 timestamp.");
+    }
+    const deduped = dedupeRunIndexEntries(indexed.entries);
+    const loops = [];
+    const limit = input.limit ?? 20;
+    const maxLookups = Math.max(limit * 5, 100);
+    for (const entry of deduped) {
+        if (loops.length >= limit || loops.length >= maxLookups) {
+            break;
+        }
+        if (input.status && entry.status !== input.status) {
+            continue;
+        }
+        if (input.lifecycleState && entry.lifecycleState !== input.lifecycleState) {
+            continue;
+        }
+        if (updatedAfterTimestamp !== undefined) {
+            const timestamp = Date.parse(entry.updatedAt);
+            if (!Number.isFinite(timestamp) || timestamp <= updatedAfterTimestamp) {
+                continue;
+            }
+        }
+        const loop = await loadLoopFromIndexEntry(runsRoot, entry.loopId).catch(() => null);
+        if (!loop) {
+            continue;
+        }
+        if (input.adapterId && !loop.attempts.some((attempt) => attempt.adapterId === input.adapterId)) {
+            continue;
+        }
+        if (input.model && !loop.attempts.some((attempt) => attempt.model === input.model)) {
+            continue;
+        }
+        loops.push(loop);
+    }
+    return {
+        loops: loops
+            .sort((left, right) => timestampForLoop(right) - timestampForLoop(left))
+            .slice(0, limit),
+        warnings
+    };
+}
+async function loadLatestLoopFromRunIndex(runsRoot) {
+    const indexed = await readRunIndexEntries(runsRoot);
+    if (indexed.entries.length === 0) {
+        return undefined;
+    }
+    for (const entry of dedupeRunIndexEntries(indexed.entries)) {
+        const loop = await loadLoopFromIndexEntry(runsRoot, entry.loopId).catch(() => null);
+        if (loop) {
+            return { loop };
+        }
+    }
+    return undefined;
+}
+async function loadLoopFromIndexEntry(runsRoot, loopId) {
+    const canonicalLoopRecordPath = resolvePotentialLoopRecordPath(loopId, runsRoot);
+    const canonicalStats = await safeStat(canonicalLoopRecordPath);
+    if (!canonicalStats?.isFile()) {
+        throw noLoopRecordsError();
+    }
+    return await readCanonicalLoopRecord(canonicalLoopRecordPath);
+}
+async function readRunIndexEntries(runsRoot) {
+    const indexPath = path.join(runsRoot, RUN_INDEX_FILENAME);
+    const stats = await safeStat(indexPath);
+    if (!stats?.isFile()) {
+        return { entries: [], truncated: false };
+    }
+    const size = Number(stats.size);
+    const readBytes = Math.min(size, RUN_INDEX_READ_MAX_BYTES);
+    const start = Math.max(0, size - readBytes);
+    const handle = await open(indexPath, "r");
+    try {
+        const buffer = Buffer.alloc(readBytes);
+        if (readBytes > 0) {
+            await handle.read(buffer, 0, readBytes, start);
+        }
+        const lines = buffer
+            .toString("utf8")
+            .split(/\r?\n/u)
+            .map((line) => line.trim())
+            .filter(Boolean);
+        const entries = [];
+        for (const line of lines) {
+            try {
+                const parsed = JSON.parse(line);
+                if (isRunIndexEntry(parsed)) {
+                    entries.push(parsed);
+                }
+            }
+            catch {
+                // Ignore partial tail lines.
+            }
+        }
+        entries.sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt));
+        return {
+            entries,
+            truncated: size > RUN_INDEX_READ_MAX_BYTES
+        };
+    }
+    finally {
+        await handle.close();
+    }
+}
+function dedupeRunIndexEntries(entries) {
+    const byLoopId = new Map();
+    for (const entry of entries) {
+        const existing = byLoopId.get(entry.loopId);
+        if (!existing || Date.parse(entry.updatedAt) >= Date.parse(existing.updatedAt)) {
+            byLoopId.set(entry.loopId, entry);
+        }
+    }
+    return [...byLoopId.values()].sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt));
+}
 export async function loadAttemptFromLoop(input) {
     const detail = await loadDetailedLoopRecord(input);
     const attempt = input.attemptIndex !== undefined
@@ -510,3 +663,10 @@ function isRecord(value) {
 function isFiniteNumber(value) {
     return typeof value === "number" && Number.isFinite(value);
 }
+function isRunIndexEntry(value) {
+    return (isRecord(value) &&
+        typeof value["loopId"] === "string" &&
+        value["loopId"].trim().length > 0 &&
+        typeof value["updatedAt"] === "string" &&
+        value["updatedAt"].trim().length > 0);
+}

package/dist/tools/tool-support.d.ts

@@ -1,6 +1,7 @@
 import type { LoopArtifact, LoopBudget, LoopCost, LoopEvent, LoopTask, ReceiptIntegritySummary, ReceiptScope } from "../vendor/contracts/index.js";
 import { type LedgerEvent, type LoopAttemptRecord, type LoopRunRecord } from "../vendor/core/index.js";
-export type MartinEngine = "claude" | "codex" | "gemini";
+export declare const MARTIN_ENGINE_VALUES: readonly ["claude", "codex", "gemini"];
+export type MartinEngine = (typeof MARTIN_ENGINE_VALUES)[number];
 export interface InspectableLoopAttempt extends LoopAttemptRecord {
     attemptId?: string;
     summary?: string;
@@ -60,7 +61,7 @@ export interface ArtifactSummary {
     }>;
 }
 export interface VerificationSummary {
-    status: "passed" | "failed" | "unavailable";
+    status: "passed" | "failed" | "contradicted" | "not_run";
     eventCount: number;
     ledgerEventCount: number;
     latestAttemptIndex?: number;