@martinloop/mcp 0.3.2 → 0.3.3

package/dist/prompts.d.ts

@@ -1,11 +1,12 @@
 import type { GetPromptResult, Prompt } from "@modelcontextprotocol/sdk/types.js";
+import type { MartinEngine } from "./tools/tool-support.js";
 export declare const MARTIN_PROMPTS: Prompt[];
 export interface MartinGetPromptInput {
     name: string;
     arguments?: Record<string, string>;
     runsDir?: string;
     workingDirectory?: string;
-    engine?: "claude" | "codex" | "gemini";
+    engine?: MartinEngine;
 }
 export declare function listMartinPrompts(): {
     prompts: Prompt[];

package/dist/resources.d.ts

@@ -1,4 +1,5 @@
 import type { ReadResourceResult, Resource, ResourceTemplate } from "@modelcontextprotocol/sdk/types.js";
+import type { MartinEngine } from "./tools/tool-support.js";
 export declare const MARTIN_STATIC_RESOURCE_URIS: {
     readonly serverHealth: "martin://server/health";
     readonly recentRuns: "martin://runs/recent";
@@ -26,7 +27,7 @@ export interface MartinReadResourceInput {
     uri: string;
     runsDir?: string;
     workingDirectory?: string;
-    engine?: "claude" | "codex" | "gemini";
+    engine?: MartinEngine;
 }
 export declare function listMartinResources(): {
     resources: Resource[];

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) {
@@ -156,7 +157,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
@@ -246,7 +247,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";
@@ -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/run-loop.d.ts

@@ -5,7 +5,7 @@ import { buildArtifactSummary, buildVerificationSummary, buildLoopPreview, type
 export interface RunLoopInput {
     objective: string;
     workingDirectory?: string;
-    engine?: "claude" | "codex" | "gemini";
+    engine?: MartinEngine;
     model?: string;
     maxUsd?: number;
     maxIterations?: number;

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)
@@ -17,10 +19,15 @@ async function attachReceiptIntegrity(detail) {
             state: "unsigned",
             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: "unsigned",
+                reason: "Receipt integrity material is incomplete for this canonical run."
+            })
+            : ({
+                state: "unsigned",
+                reason: "Receipt integrity is only available for canonical run directories."
+            });
     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;

package/dist/tools/tool-support.js

@@ -3,6 +3,7 @@ import { readdir, stat } from "node:fs/promises";
 import { join } from "node:path";
 import { evaluateCostGovernor, resolveRunsRoot } from "../vendor/core/index.js";
 import { readAllLoopRecordsSafely } from "./run-store.js";
+export const MARTIN_ENGINE_VALUES = ["claude", "codex", "gemini"];
 const CLI_CACHE_TTL_MS = 60_000;
 const RUN_STORE_CACHE_TTL_MS = 5_000;
 const cliAvailabilityCache = new Map();

package/dist/vendor/adapters/claude-cli.d.ts

@@ -33,7 +33,7 @@ export interface AgentCliAdapterOptions {
     workingDirectory?: string;
     /** Timeout for the agent subprocess in ms. Defaults to 300_000 (5 min). */
     timeoutMs?: number;
-    /** Timeout per verification command in ms. Defaults to 60_000 (1 min). */
+    /** Timeout per verification command in ms. Defaults to 120_000 (2 min). */
     verifyTimeoutMs?: number;
     /** Human-readable label shown in loop records. */
     label?: string;

package/dist/vendor/adapters/claude-cli.js

@@ -349,7 +349,7 @@ function inferStructuralClassHint(agentOutput, verificationSummary, exitCode, ob
 export function createAgentCliAdapter(options) {
     const workingDirectory = options.workingDirectory ?? process.cwd();
     const timeoutMs = options.timeoutMs ?? 300_000;
-    const verifyTimeoutMs = options.verifyTimeoutMs ?? 60_000;
+    const verifyTimeoutMs = options.verifyTimeoutMs ?? 120_000;
     const adapterId = `agent-cli:${options.adapterIdSuffix ?? options.command}`;
     const supportsJsonOutput = options.supportsJsonOutput === true;
     const supportsUsageSettlement = supportsJsonOutput || options.command === "codex" || options.command === "gemini";
@@ -976,6 +976,7 @@ function redactSecretsForPrompt(input) {
         .replace(/\bAIza[0-9A-Za-z_-]{30,}\b/gu, "[REDACTED_SECRET]")
         .replace(/-----BEGIN(?:\s+[A-Z0-9]+)*\s+PRIVATE KEY-----[\s\S]*?-----END(?:\s+[A-Z0-9]+)*\s+PRIVATE KEY-----/gu, "[REDACTED_SECRET]")
         .replace(/\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/gu, "[REDACTED_SECRET]")
+        .replace(/\b(?:api[_-]?key|secret|password|token)\s*[:=]\s*["']?[A-Za-z0-9_\-/+=]{8,}["']?/giu, "[REDACTED_SECRET]")
         .replace(/\B\.env(?!\.example\b)(?:\.[A-Za-z0-9._-]+)?\b/giu, "[REDACTED_PATH]");
 }
 function extractStructuredErrors(stderr, stdout) {

package/dist/vendor/adapters/cli-bridge.js

@@ -9,6 +9,7 @@ export async function runSubprocess(command, args, options) {
         let outputCapped = false;
         let terminationReason;
         let settled = false;
+        let exited = false;
         let outputBytes = 0;
         const stdoutChunks = [];
         const stderrChunks = [];
@@ -35,12 +36,12 @@ export async function runSubprocess(command, args, options) {
             return;
         }
         const trackOutput = (chunks, chunk) => {
+            if (outputCapped || timedOut || terminationReason) {
+                return;
+            }
             chunks.push(chunk);
             outputBytes += chunk.byteLength;
-            if (options.maxOutputBytes !== undefined &&
-                !outputCapped &&
-                !timedOut &&
-                outputBytes > options.maxOutputBytes) {
+            if (options.maxOutputBytes !== undefined && outputBytes > options.maxOutputBytes) {
                 outputCapped = true;
                 proc.kill("SIGTERM");
             }
@@ -53,10 +54,23 @@ export async function runSubprocess(command, args, options) {
             proc.kill("SIGTERM");
         };
         proc.stdout?.on("data", (chunk) => {
+            if (outputCapped || timedOut || terminationReason) {
+                return;
+            }
             trackOutput(stdoutChunks, chunk);
-            options.onStdoutChunk?.(chunk, terminateEarly);
+            if (options.onStdoutChunk) {
+                try {
+                    options.onStdoutChunk(chunk, terminateEarly);
+                }
+                catch (error) {
+                    terminateEarly(`stdout inspector error: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
         });
         proc.stderr?.on("data", (chunk) => {
+            if (outputCapped || timedOut || terminationReason) {
+                return;
+            }
             trackOutput(stderrChunks, chunk);
         });
         proc.stdin?.on("error", (error) => {
@@ -68,9 +82,15 @@ export async function runSubprocess(command, args, options) {
             stderrChunks.push(Buffer.from(`${error.message}\n`, "utf8"));
         });
         const timer = setTimeout(() => {
+            if (settled || exited || proc.exitCode !== null) {
+                return;
+            }
             timedOut = true;
             proc.kill("SIGTERM");
         }, options.timeoutMs);
+        proc.on("exit", () => {
+            exited = true;
+        });
         proc.on("error", (error) => {
             clearTimeout(timer);
             resolveOnce({ exitCode: 1, stdout: "", stderr: error.message, launched: false });
@@ -200,6 +220,10 @@ export function resolveGitRepositoryRoot(workingDirectory) {
     if (cached !== undefined) {
         return cached ?? undefined;
     }
+    if (!existsSync(resolvedWorkingDirectory)) {
+        gitRepositoryRootCache.set(resolvedWorkingDirectory, null);
+        return undefined;
+    }
     const visited = [];
     let current = resolvedWorkingDirectory;
     while (true) {

package/dist/vendor/adapters/openai-compatible.d.ts

@@ -43,7 +43,7 @@ export interface OpenAiCompatibleAdapterOptions {
     systemPrompt?: string;
     /** Request timeout in milliseconds. Default: 300_000 (5 min). */
     timeoutMs?: number;
-    /** Verifier timeout in milliseconds. Default: 60_000. */
+    /** Verifier timeout in milliseconds. Default: 120_000. */
     verifyTimeoutMs?: number;
     /** Working directory for git artifact collection and verification. */
     workingDirectory?: string;

package/dist/vendor/adapters/openai-compatible.js

@@ -120,7 +120,7 @@ function buildPrompt(request) {
 export function createOpenAiCompatibleAdapter(options) {
     const workingDirectory = options.workingDirectory ?? process.cwd();
     const timeoutMs = options.timeoutMs ?? 300_000;
-    const verifyTimeoutMs = options.verifyTimeoutMs ?? 60_000;
+    const verifyTimeoutMs = options.verifyTimeoutMs ?? 120_000;
     const systemPrompt = options.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
     const fetchFn = options.fetchImpl ?? globalThis.fetch;
     const runtimeConfig = resolveOpenAiCompatibleRuntimeConfig();

package/dist/vendor/adapters/verifier-only.js

@@ -2,7 +2,7 @@ import { readGitChangedFiles, runVerification } from "./cli-bridge.js";
 import { createAdapterCapabilities, normalizeUsage } from "./runtime-support.js";
 export function createVerifierOnlyAdapter(options = {}) {
     const workingDirectory = options.workingDirectory ?? process.cwd();
-    const verifyTimeoutMs = options.verifyTimeoutMs ?? 60_000;
+    const verifyTimeoutMs = options.verifyTimeoutMs ?? 120_000;
     return {
         adapterId: "direct:verifier:verify-only",
         kind: "direct-provider",

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

@@ -21,7 +21,7 @@ const POISON_PATTERNS = [
  */
 const IDENTITY_REDEFINITION_PATTERNS = [
     /\byou(?:'re|\s+are)\s+now\s+(?:a|an|the)\b(?!\s+(?:martin\s+loop|ai\s+coding\s+agent))/i,
-    /\byou(?:'re|\s+are)\s+no\s+longer\s+(?!.*\b(?:martin\s+loop|an?\s+ai)\b)/i,
+    /\byou(?:'re|\s+are)\s+no\s+longer\s+(?!(?:martin\s+loop|an?\s+ai)\b)/i,
     /\bforget\s+(?:that\s+)?you(?:'re|\s+are)\s+martin\s+loop\b/i,
     /\b(?:pretend|imagine)\s+(?:that\s+)?you(?:'re|\s+are)\b/i,
     /\bact\s+as\s+(?:if\s+you(?:'re|\s+are)\s+)?(?:a|an)\s+(?:different|new|unrestricted|jailbroken)\b/i,

package/dist/vendor/core/grounding.js

@@ -13,7 +13,7 @@ const IGNORED_DIRS = new Set([
 const MAX_FILE_BYTES = 64_000;
 const MAX_FILES = 500;
 export function resolveGroundingRoot(env = process.env) {
-    return env["MARTIN_GROUNDING_DIR"]?.trim() ??
+    return env["MARTIN_GROUNDING_DIR"]?.trim() ||
         join(homedir(), ".martin", "grounding");
 }
 export async function loadOrBuildRepoGroundingIndex(repoRoot) {

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

@@ -2,10 +2,10 @@ import { type ApprovalPolicy, type CostProvenance, type ExecutionProfile, type F
 import { classifyFailure, computeEvidenceVector, evaluatePatchDecision, evaluateCostGovernor, evaluateBudgetPreflight, inferExit, nextPolicyPhase, policyPhaseToLifecycleState, scorePatchDecision, selectRecoveryRecipe, type ExitDecision } from "./policy.js";
 import { evaluateChangeApprovalLeash, evaluateFilesystemLeash, evaluateSecretLeash, redactSecretsFromText, resolveExecutionProfile, evaluateVerificationLeash } from "./leash.js";
 import { buildRepoGroundingIndex, loadOrBuildRepoGroundingIndex, queryRepoGroundingIndex, scanPatchForGroundingViolations } from "./grounding.js";
-import { captureRollbackBoundary, restoreRollbackBoundary } from "./rollback.js";
+import { captureRollbackBoundary, listAttemptChangedFilesSinceBoundary, restoreRollbackBoundary } from "./rollback.js";
 import { type RunStore } from "./persistence/index.js";
 export type { ApprovalPolicy, BudgetPreflightEstimate, BudgetSettlement, CostProvenance, EvidenceVector, ExecutionProfile, FailureClass, InterventionType, PatchDecision, PatchDecisionArtifact, PatchDecisionReasonCode, PatchScore, MutationMode, RollbackBoundaryArtifact, RollbackBoundaryStrategy, RollbackFileSnapshot, RollbackOutcomeArtifact, RollbackOutcomeStatus, PolicyPhase } from "../contracts/index.js";
-export { classifyFailure, computeEvidenceVector, evaluatePatchDecision, evaluateCostGovernor, evaluateBudgetPreflight, inferExit, nextPolicyPhase, policyPhaseToLifecycleState, scorePatchDecision, selectRecoveryRecipe, evaluateVerificationLeash, evaluateFilesystemLeash, evaluateChangeApprovalLeash, evaluateSecretLeash, resolveExecutionProfile, redactSecretsFromText, buildRepoGroundingIndex, loadOrBuildRepoGroundingIndex, queryRepoGroundingIndex, scanPatchForGroundingViolations, captureRollbackBoundary, restoreRollbackBoundary };
+export { classifyFailure, computeEvidenceVector, evaluatePatchDecision, evaluateCostGovernor, evaluateBudgetPreflight, inferExit, nextPolicyPhase, policyPhaseToLifecycleState, scorePatchDecision, selectRecoveryRecipe, evaluateVerificationLeash, evaluateFilesystemLeash, evaluateChangeApprovalLeash, evaluateSecretLeash, resolveExecutionProfile, redactSecretsFromText, buildRepoGroundingIndex, loadOrBuildRepoGroundingIndex, queryRepoGroundingIndex, scanPatchForGroundingViolations, captureRollbackBoundary, listAttemptChangedFilesSinceBoundary, restoreRollbackBoundary };
 export type { BudgetPreflightDecision, BudgetPreflightInput, CostGovernorState, EvidenceVectorInput, EvaluatedPatchDecision, ExitDecision, FailureAssessment, PatchDecisionInput, RecoveryDecision, RecoveryRecipe } from "./policy.js";
 export type { ResolvedExecutionProfile, SafetyLeashDecision, SafetyViolation } from "./leash.js";
 export type { GroundingScanResult, GroundingViolation, GroundingViolationKind, RepoGroundingHit, RepoGroundingIndex } from "./grounding.js";

package/dist/vendor/core/index.js

@@ -1,13 +1,12 @@
-import { spawnSync } from "node:child_process";
 import { 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";
 import { buildRepoGroundingIndex, loadOrBuildRepoGroundingIndex, queryRepoGroundingIndex, scanPatchForGroundingViolations } from "./grounding.js";
-import { captureRollbackBoundary, restoreRollbackBoundary } from "./rollback.js";
+import { captureRollbackBoundary, listAttemptChangedFilesSinceBoundary, restoreRollbackBoundary } from "./rollback.js";
 import { compilePromptPacket } from "./compiler.js";
 import { makeLedgerEvent, resolveRunsRoot, runDir } from "./persistence/index.js";
 import { runContextIntegrityPrecheck } from "./context-integrity.js";
-export { classifyFailure, computeEvidenceVector, evaluatePatchDecision, evaluateCostGovernor, evaluateBudgetPreflight, inferExit, nextPolicyPhase, policyPhaseToLifecycleState, scorePatchDecision, selectRecoveryRecipe, evaluateVerificationLeash, evaluateFilesystemLeash, evaluateChangeApprovalLeash, evaluateSecretLeash, resolveExecutionProfile, redactSecretsFromText, buildRepoGroundingIndex, loadOrBuildRepoGroundingIndex, queryRepoGroundingIndex, scanPatchForGroundingViolations, captureRollbackBoundary, restoreRollbackBoundary };
+export { classifyFailure, computeEvidenceVector, evaluatePatchDecision, evaluateCostGovernor, evaluateBudgetPreflight, inferExit, nextPolicyPhase, policyPhaseToLifecycleState, scorePatchDecision, selectRecoveryRecipe, evaluateVerificationLeash, evaluateFilesystemLeash, evaluateChangeApprovalLeash, evaluateSecretLeash, resolveExecutionProfile, redactSecretsFromText, buildRepoGroundingIndex, loadOrBuildRepoGroundingIndex, queryRepoGroundingIndex, scanPatchForGroundingViolations, captureRollbackBoundary, listAttemptChangedFilesSinceBoundary, restoreRollbackBoundary };
 // ─── Context Integrity Pre-gate ──────────────────────────────────────────────
 export { runContextIntegrityPrecheck } from "./context-integrity.js";
 // ─── Prompt packet compiler ──────────────────────────────────────────────────
@@ -278,7 +277,7 @@ export async function runMartin(input) {
         // re-enters subsequent prompts, matching the documented "tool output / test output" scope.
         const priorVerifierOutput = loop.events
             .filter((event) => event.type === "verification.completed")
-            .flatMap((event) => event.payload.steps ?? [])
+            .flatMap((event) => event.payload?.steps ?? [])
             .map((step) => step.detail)
             .filter((detail) => Boolean(detail))
             .join("\n---\n");
@@ -468,7 +467,7 @@ export async function runMartin(input) {
                         estimatedUsd: roundUsd((loop.cost.estimatedUsd ?? loop.cost.actualUsd) + result.usage.estimatedUsd)
                     }
                     : {}),
-                provenance: getUsageProvenance(result.usage),
+                provenance: mergeCostProvenance(loop.cost.provenance, getUsageProvenance(result.usage)),
                 ...(result.usage.providerSettlement
                     ? { providerSettlement: result.usage.providerSettlement }
                     : {})
@@ -552,7 +551,7 @@ export async function runMartin(input) {
                 actualUsd: loop.cost.actualUsd,
                 remainingBudgetUsd: costState.remainingBudgetUsd,
                 pressure: costState.pressure,
-                provenance: getUsageProvenance(result.usage)
+                provenance: loop.cost.provenance
             }
         }, { now: now(), idFactory });
         if (input.store) {
@@ -610,7 +609,7 @@ export async function runMartin(input) {
             }));
         }
         const changedFiles = tracksWorkspaceMutations
-            ? resolveChangedFiles(result, request.context.repoRoot)
+            ? resolveChangedFiles(result, request.context.repoRoot, rollbackBoundary)
             : [];
         // Evidence is only reliable when the adapter explicitly reported files OR git actually
         // returned a non-empty list. A repoRoot alone is insufficient — git may fail (e.g. not
@@ -1136,29 +1135,28 @@ function getUsageProvenance(usage) {
     }
     return "actual";
 }
-function resolveChangedFiles(result, repoRoot) {
+const COST_PROVENANCE_RANK = {
+    unavailable: 0,
+    estimated: 1,
+    actual: 2
+};
+/**
+ * Aggregates cost provenance across attempts. The cumulative loop provenance
+ * can only be as trustworthy as its weakest attempt: if any attempt's cost was
+ * estimated or unavailable, the cumulative total must reflect that, even if a
+ * later attempt reports an authoritative actual cost.
+ */
+function mergeCostProvenance(previous, current) {
+    if (previous === undefined) {
+        return current;
+    }
+    return COST_PROVENANCE_RANK[current] < COST_PROVENANCE_RANK[previous] ? current : previous;
+}
+function resolveChangedFiles(result, repoRoot, rollbackBoundary) {
     if (result.execution?.changedFiles !== undefined) {
         return result.execution.changedFiles;
     }
-    if (!repoRoot) {
-        return [];
-    }
-    try {
-        const diff = spawnSync("git", ["diff", "--name-only", "HEAD", "--", "."], {
-            cwd: repoRoot,
-            encoding: "utf8"
-        });
-        if (diff.status !== 0 || typeof diff.stdout !== "string") {
-            return [];
-        }
-        return diff.stdout
-            .split(/\r?\n/u)
-            .map((entry) => entry.trim())
-            .filter(Boolean);
-    }
-    catch {
-        return [];
-    }
+    return listAttemptChangedFilesSinceBoundary({ repoRoot, boundary: rollbackBoundary });
 }
 function buildPatchDiff(result, changedFiles) {
     // Use structured diff stats to build a minimal diff header if no raw diff is available

package/dist/vendor/core/leash.js

@@ -39,7 +39,7 @@ const BLOCKED_PATTERNS = [
  */
 function commandContainsDestructiveRemoval(command) {
     const normalized = command.replace(/\$\{?IFS\}?/giu, " ").toLowerCase();
-    const rmInvocation = /(?:^|[\s;&|`(])(?:\/(?:usr\/(?:local\/)?)?s?bin\/)?rm\s+([^\n;|`]+)/giu;
+    const rmInvocation = /(?:^|[\s;&|`(])(?:[^\s;&|`(]+\/)?rm\s+([^\n;|`]+)/giu;
     let match;
     while ((match = rmInvocation.exec(normalized)) !== null) {
         const args = match[1] ?? "";

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

@@ -21,6 +21,7 @@ export interface StoredReceiptIntegrityMaterial {
     chain: ReceiptIntegrityChainEntry[];
     signatureHmacSha256: string;
 }
+export declare function resolveReceiptIntegrityRoot(env?: NodeJS.ProcessEnv): string;
 export declare function writeReceiptIntegrityMaterial(input: {
     runId: string;
     runsRoot: string;

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

@@ -5,6 +5,10 @@ import { dirname, join } from "node:path";
 const RECEIPT_INTEGRITY_SCHEMA_VERSION = "martin.receipt-integrity.v1";
 const RECEIPT_INTEGRITY_KEY_DIR_MODE = 0o700;
 const RECEIPT_INTEGRITY_KEY_FILE_MODE = 0o600;
+export function resolveReceiptIntegrityRoot(env = process.env) {
+    return env["MARTIN_INTEGRITY_KEY_DIR"]?.trim() ??
+        join(homedir(), ".martin", "receipt-integrity");
+}
 export async function writeReceiptIntegrityMaterial(input) {
     const signedAt = input.signedAt ?? new Date().toISOString();
     const keyMaterial = await ensureReceiptIntegrityKey(input.runsRoot, input.runId);
@@ -232,7 +236,7 @@ async function readReceiptIntegrityKey(runsRoot, runId) {
 }
 function resolveReceiptIntegrityKeyPath(runsRoot, runId) {
     const rootHash = sha256(runsRoot).slice(0, 16);
-    return join(homedir(), ".martin", "receipt-integrity", rootHash, `${runId}.key`);
+    return join(resolveReceiptIntegrityRoot(), rootHash, `${runId}.key`);
 }
 function serializeStoredJson(value) {
     return `${JSON.stringify(value, null, 2)}\n`;

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

@@ -39,6 +39,19 @@ export interface LoopRunRecord {
         objective: string;
     };
 }
+export interface LoopRecordsRollup {
+    generatedAt: string;
+    totalRuns: number;
+    statusBreakdown: Record<string, number>;
+    lifecycleBreakdown: Record<string, number>;
+    latestByLoopId: Record<string, {
+        status: string;
+        lifecycleState: string;
+        updatedAt: string;
+        costUsd: number;
+        attempts: number;
+    }>;
+}
 export declare function readLoopRecordsFromFile(file: string): Promise<LoopRunRecord[]>;
 export declare function readLatestLoopRecordFromFile(file: string): Promise<LoopRunRecord | null>;
 /**
@@ -50,3 +63,4 @@ export declare function readAllLoopRecords(runsDir?: string): Promise<LoopRunRec
  * Returns the most recently updated loop record, or null if none exist.
  */
 export declare function readLatestLoopRecord(runsDir?: string): Promise<LoopRunRecord | null>;
+export declare function buildLoopRecordsRollup(records: LoopRunRecord[]): LoopRecordsRollup;

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

@@ -45,13 +45,16 @@ export async function readAllLoopRecords(runsDir) {
     catch {
         return [];
     }
-    const records = [];
+    const recordsByLoopId = new Map();
     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))));
+            const fromFile = await readLoopRecordsFromFile(join(dir, file));
+            for (const record of fromFile) {
+                ingestRecord(recordsByLoopId, record, "legacy_jsonl");
+            }
         }
         catch {
             // skip malformed files or lines
@@ -60,13 +63,16 @@ export async function readAllLoopRecords(runsDir) {
     const runDirectories = entries.filter((entry) => entry.isDirectory());
     for (const entry of runDirectories) {
         try {
-            records.push(...(await readLoopRecordsFromFile(join(dir, entry.name, "loop-record.json"))));
+            const canonical = await readLoopRecordsFromFile(join(dir, entry.name, "loop-record.json"));
+            for (const record of canonical) {
+                ingestRecord(recordsByLoopId, record, "canonical_tree");
+            }
         }
         catch {
             // skip missing or malformed canonical records
         }
     }
-    return records;
+    return [...recordsByLoopId.values()].map((entry) => entry.record);
 }
 /**
  * Returns the most recently updated loop record, or null if none exist.
@@ -81,3 +87,54 @@ export async function readLatestLoopRecord(runsDir) {
         return a > b ? r : latest;
     }, records[0]);
 }
+export function buildLoopRecordsRollup(records) {
+    const statusBreakdown = {};
+    const lifecycleBreakdown = {};
+    const latestByLoopId = {};
+    for (const record of records) {
+        statusBreakdown[record.status] = (statusBreakdown[record.status] ?? 0) + 1;
+        lifecycleBreakdown[record.lifecycleState] = (lifecycleBreakdown[record.lifecycleState] ?? 0) + 1;
+        latestByLoopId[record.loopId] = {
+            status: record.status,
+            lifecycleState: record.lifecycleState,
+            updatedAt: record.updatedAt,
+            costUsd: record.cost.actualUsd,
+            attempts: record.attempts.length
+        };
+    }
+    return {
+        generatedAt: new Date().toISOString(),
+        totalRuns: records.length,
+        statusBreakdown,
+        lifecycleBreakdown,
+        latestByLoopId
+    };
+}
+function ingestRecord(recordsByLoopId, record, source) {
+    const existing = recordsByLoopId.get(record.loopId);
+    if (!existing) {
+        recordsByLoopId.set(record.loopId, { record, source });
+        return;
+    }
+    const candidateTimestamp = resolveRecordTimestamp(record);
+    const existingTimestamp = resolveRecordTimestamp(existing.record);
+    if (candidateTimestamp > existingTimestamp) {
+        recordsByLoopId.set(record.loopId, { record, source });
+        return;
+    }
+    if (candidateTimestamp === existingTimestamp &&
+        sourcePrecedence(source) > sourcePrecedence(existing.source)) {
+        recordsByLoopId.set(record.loopId, { record, source });
+    }
+}
+function resolveRecordTimestamp(record) {
+    const updated = Date.parse(record.updatedAt ?? "");
+    if (Number.isFinite(updated)) {
+        return updated;
+    }
+    const created = Date.parse(record.createdAt ?? "");
+    return Number.isFinite(created) ? created : 0;
+}
+function sourcePrecedence(source) {
+    return source === "canonical_tree" ? 2 : 1;
+}

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

@@ -4,6 +4,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { writeReceiptIntegrityMaterial } from "./integrity.js";
 // ─── FileRunStore implementation ─────────────────────────────────────────────
+const RUN_INDEX_FILENAME = "run-index.ndjson";
 export function resolveRunsRoot(env = process.env) {
     return env["MARTIN_RUNS_DIR"]?.trim() ??
         join(homedir(), ".martin", "runs");
@@ -84,6 +85,7 @@ export function createFileRunStore(options = {}) {
             const dir = runDir(runsRoot, runId);
             await mkdir(dir, { recursive: true });
             await writeJsonFile(join(dir, "loop-record.json"), loop);
+            await appendRunIndexRecord(runsRoot, loop);
             const ledgerRaw = await readFile(join(dir, "ledger.jsonl"), "utf8").catch(() => "");
             const ledgerEntries = ledgerRaw
                 .split(/\r?\n/u)
@@ -110,3 +112,14 @@ export function createFileRunStore(options = {}) {
 async function writeJsonFile(path, value) {
     await writeFile(path, `${JSON.stringify(value, null, 2)}\n`, "utf8");
 }
+async function appendRunIndexRecord(runsRoot, loop) {
+    const line = JSON.stringify({
+        loopId: loop.loopId,
+        workspaceId: loop.workspaceId,
+        projectId: loop.projectId,
+        status: loop.status,
+        lifecycleState: loop.lifecycleState,
+        updatedAt: loop.updatedAt
+    });
+    await appendFile(join(runsRoot, RUN_INDEX_FILENAME), `${line}\n`, "utf8");
+}

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

@@ -1,4 +1,8 @@
 import type { PatchDecision, RollbackBoundaryArtifact, RollbackOutcomeArtifact } from "../contracts/index.js";
+export declare function listAttemptChangedFilesSinceBoundary(input: {
+    repoRoot?: string;
+    boundary?: RollbackBoundaryArtifact;
+}): string[];
 export declare function captureRollbackBoundary(input: {
     repoRoot?: string;
     capturedAt: string;

package/dist/vendor/core/rollback.js

@@ -1,6 +1,21 @@
 import { spawnSync } from "node:child_process";
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { dirname, relative, resolve } from "node:path";
+export function listAttemptChangedFilesSinceBoundary(input) {
+    if (!input.repoRoot) {
+        return [];
+    }
+    const repoState = readRepoState(input.repoRoot);
+    if (!input.boundary) {
+        return uniqueSorted([...repoState.trackedDirtyFiles, ...repoState.untrackedFiles]);
+    }
+    const baselineTracked = new Set(input.boundary.trackedDirtyFiles);
+    const baselineUntracked = new Set(input.boundary.untrackedFiles);
+    return uniqueSorted([
+        ...repoState.trackedDirtyFiles.filter((filePath) => !baselineTracked.has(filePath)),
+        ...repoState.untrackedFiles.filter((filePath) => !baselineUntracked.has(filePath))
+    ]);
+}
 export async function captureRollbackBoundary(input) {
     if (!input.repoRoot) {
         return undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@martinloop/mcp",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "mcpName": "io.github.Keesan12/martin-loop",
   "private": false,
   "type": "module",

package/server.json

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