@martinloop/mcp 0.1.4 → 0.2.0

package/README.md

@@ -2,20 +2,25 @@
 
 Governed MCP server for AI coding agents that need hard spend limits, verifier gates, scoped file edits, and inspectable run records.
 
-`@martinloop/mcp@0.1.4` exposes five stdio tools:
+`@martinloop/mcp@0.2.0` exposes ten stdio tools plus read-only MCP resources, resource templates, and prompts:
 
 - `martin_doctor`
 - `martin_preflight`
 - `martin_run`
 - `martin_inspect`
 - `martin_status`
+- `martin_list_runs`
+- `martin_get_run`
+- `martin_get_attempt`
+- `martin_get_verification_results`
+- `martin_run_dossier`
 
 Recommended flow:
 
 1. `martin_doctor`
 2. `martin_preflight`
 3. `martin_run`
-4. `martin_inspect` or `martin_status`
+4. `martin_list_runs`, `martin_run_dossier`, `martin_inspect`, or `martin_status`
 
 ## What This Server Is For
 
@@ -95,6 +100,31 @@ MARTIN_LIVE=false npx -y @martinloop/mcp
 | `martin_run` | Run a governed coding loop | `objective` | `workingDirectory`, `engine`, `model`, `maxUsd`, `maxIterations`, `maxTokens`, `verificationPlan`, `allowedPaths`, `deniedPaths`, `workspaceId`, `projectId` | Unknown arguments are rejected. |
 | `martin_inspect` | Read a saved run record or run folder | none | `file`, `runsDir` | `file` may point to a `loop-record.json`, legacy `.jsonl`, or a run directory under the runs root. |
 | `martin_status` | Report budget pressure and stop conditions | exactly one of `loopJson`, `file`, `loopId`, or `latest` | `runsDir` | `latest` must be `true` when used. |
+| `martin_list_runs` | List recent run summaries | none | `runsDir`, `limit` | Read-only cockpit view over local run records. |
+| `martin_get_run` | Load a run dossier | exactly one of `loopId` or `latest` | `runsDir` | Read-only task, budget, cost, and attempt details. |
+| `martin_get_attempt` | Load one attempt | `loopId`, `attemptIndex` | `runsDir` | Read-only attempt evidence. |
+| `martin_get_verification_results` | Extract verifier events | exactly one of `loopId` or `latest` | `runsDir` | Read-only verifier completion summaries. |
+| `martin_run_dossier` | Build a compact review dossier | exactly one of `loopId` or `latest` | `runsDir` | Summary, budget, attempts, and verification evidence. |
+
+## Discovery Surface
+
+`0.2.0` adds read-only cockpit discovery for MCP hosts that support resources and prompts.
+
+Resources:
+
+- `martin://runs/summary`
+- `martin://runs/latest`
+
+Resource templates:
+
+- `martin://runs/{loopId}`
+- `martin://runs/{loopId}/attempts/{attemptIndex}`
+- `martin://runs/{loopId}/verification`
+
+Prompts:
+
+- `martin_review_run`
+- `martin_triage_failures`
 
 ## Safe-Root Path Model
 

package/dist/prompts.d.ts

@@ -0,0 +1,3 @@
+import type { GetPromptResult, ListPromptsResult } from "@modelcontextprotocol/sdk/types.js";
+export declare function listMartinPrompts(): ListPromptsResult["prompts"];
+export declare function getMartinPrompt(name: string, args?: Record<string, unknown>): GetPromptResult;

package/dist/prompts.js

@@ -0,0 +1,84 @@
+export function listMartinPrompts() {
+    return [
+        {
+            name: "martin_review_run",
+            description: "Review a Martin Loop run for governance, verification, and release-readiness evidence.",
+            arguments: [
+                {
+                    name: "loopId",
+                    description: "Run loopId to review.",
+                    required: true
+                },
+                {
+                    name: "objective",
+                    description: "Review objective or release question.",
+                    required: false
+                }
+            ]
+        },
+        {
+            name: "martin_triage_failures",
+            description: "Triage failed Martin runs and propose the next safest bounded action.",
+            arguments: [
+                {
+                    name: "loopId",
+                    description: "Optional run loopId to triage. If omitted, use latest run resources.",
+                    required: false
+                }
+            ]
+        }
+    ];
+}
+export function getMartinPrompt(name, args = {}) {
+    if (name === "martin_review_run") {
+        const loopId = requireOptionalText(args.loopId, "loopId") ?? "latest";
+        const objective = requireOptionalText(args.objective, "objective") ?? "Assess whether the run is safe to ship.";
+        return {
+            description: "Review Martin Loop run evidence.",
+            messages: [
+                {
+                    role: "user",
+                    content: {
+                        type: "text",
+                        text: [
+                            `Review Martin Loop run ${loopId}.`,
+                            `Objective: ${objective}`,
+                            "Use martin://runs/{loopId}, martin://runs/{loopId}/verification, and the read-only tools before making a shipping recommendation.",
+                            "Call out missing verifier proof, budget pressure, safety-leash violations, and whether human review is required."
+                        ].join("\n")
+                    }
+                }
+            ]
+        };
+    }
+    if (name === "martin_triage_failures") {
+        const loopId = requireOptionalText(args.loopId, "loopId") ?? "latest";
+        return {
+            description: "Triage failed Martin Loop evidence.",
+            messages: [
+                {
+                    role: "user",
+                    content: {
+                        type: "text",
+                        text: [
+                            `Triage Martin Loop run ${loopId}.`,
+                            "Use the run dossier, attempt evidence, and verification results.",
+                            "Return the smallest safe next action and do not suggest re-running until the failure class and verifier evidence are clear."
+                        ].join("\n")
+                    }
+                }
+            ]
+        };
+    }
+    throw new Error("Unknown prompt.");
+}
+function requireOptionalText(value, name) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`Invalid ${name}.`);
+    }
+    return value.trim();
+}
+//# sourceMappingURL=prompts.js.map

package/dist/resources.d.ts

@@ -0,0 +1,7 @@
+import type { ListResourceTemplatesResult, ListResourcesResult, ReadResourceResult } from "@modelcontextprotocol/sdk/types.js";
+export interface ResourceReadOptions {
+    runsDir?: string;
+}
+export declare function listMartinResources(): ListResourcesResult["resources"];
+export declare function listMartinResourceTemplates(): ListResourceTemplatesResult["resourceTemplates"];
+export declare function readMartinResource(uri: string, options?: ResourceReadOptions): Promise<ReadResourceResult>;

package/dist/resources.js

@@ -0,0 +1,89 @@
+import { buildRunDossier, getAttempt, listRunSummaries, loadSelectedRun } from "./tools/cockpit-support.js";
+import { getVerificationResultsTool } from "./tools/get-verification-results.js";
+export function listMartinResources() {
+    return [
+        {
+            uri: "martin://runs/summary",
+            name: "Martin run summary",
+            description: "Read-only summary of recent governed Martin Loop runs.",
+            mimeType: "application/json"
+        },
+        {
+            uri: "martin://runs/latest",
+            name: "Latest Martin run",
+            description: "Read-only dossier for the newest run in the local run store.",
+            mimeType: "application/json"
+        }
+    ];
+}
+export function listMartinResourceTemplates() {
+    return [
+        {
+            uriTemplate: "martin://runs/{loopId}",
+            name: "Martin run dossier",
+            description: "Read-only run dossier by loopId.",
+            mimeType: "application/json"
+        },
+        {
+            uriTemplate: "martin://runs/{loopId}/attempts/{attemptIndex}",
+            name: "Martin run attempt",
+            description: "Read-only attempt evidence for a run.",
+            mimeType: "application/json"
+        },
+        {
+            uriTemplate: "martin://runs/{loopId}/verification",
+            name: "Martin verification results",
+            description: "Verifier results extracted from a run ledger.",
+            mimeType: "application/json"
+        }
+    ];
+}
+export async function readMartinResource(uri, options = {}) {
+    const parsed = new URL(uri);
+    if (parsed.protocol !== "martin:") {
+        throw new Error("Unsupported resource URI.");
+    }
+    const segments = parsed.pathname.split("/").filter(Boolean);
+    if (parsed.hostname === "runs" && segments.length === 1 && segments[0] === "summary") {
+        return asJsonResource(uri, await listRunSummaries({ runsDir: options.runsDir }));
+    }
+    if (parsed.hostname === "runs" && segments.length === 1 && segments[0] === "latest") {
+        const loop = await loadSelectedRun({ latest: true, runsDir: options.runsDir });
+        return asJsonResource(uri, buildRunDossier(loop));
+    }
+    if (parsed.hostname !== "runs" || segments.length < 1) {
+        throw new Error("Unknown resource URI.");
+    }
+    const [loopId, child, attemptIndex] = segments;
+    if (!loopId || !/^[A-Za-z0-9._-]+$/u.test(loopId)) {
+        throw new Error("Invalid loopId.");
+    }
+    if (!child) {
+        const loop = await loadSelectedRun({ loopId, runsDir: options.runsDir });
+        return asJsonResource(uri, buildRunDossier(loop));
+    }
+    if (child === "attempts") {
+        const parsedAttempt = Number(attemptIndex);
+        if (!Number.isInteger(parsedAttempt) || parsedAttempt <= 0) {
+            throw new Error("Invalid attemptIndex.");
+        }
+        const loop = await loadSelectedRun({ loopId, runsDir: options.runsDir });
+        return asJsonResource(uri, getAttempt(loop, parsedAttempt));
+    }
+    if (child === "verification") {
+        return asJsonResource(uri, await getVerificationResultsTool({ loopId, runsDir: options.runsDir }));
+    }
+    throw new Error("Unknown resource URI.");
+}
+function asJsonResource(uri, value) {
+    return {
+        contents: [
+            {
+                uri,
+                mimeType: "application/json",
+                text: JSON.stringify(value, null, 2)
+            }
+        ]
+    };
+}
+//# sourceMappingURL=resources.js.map

package/dist/server-validation.d.ts

@@ -1,4 +1,4 @@
-type ToolName = "martin_doctor" | "martin_preflight" | "martin_run" | "martin_inspect" | "martin_status";
+type ToolName = "martin_doctor" | "martin_preflight" | "martin_run" | "martin_inspect" | "martin_status" | "martin_list_runs" | "martin_get_run" | "martin_get_attempt" | "martin_get_verification_results" | "martin_run_dossier";
 export declare function validateToolInput(name: ToolName, args: unknown): unknown;
 export declare function sanitizeToolErrorMessage(error: unknown): string;
 export declare function resolveSafeRepoRoot(repoRoot?: string, workspaceRoot?: string): string;

package/dist/server-validation.js

@@ -12,6 +12,16 @@ export function validateToolInput(name, args) {
             return validateInspectInput(args);
         case "martin_status":
             return validateStatusInput(args);
+        case "martin_list_runs":
+            return validateListRunsInput(args);
+        case "martin_get_run":
+            return validateGetRunInput(args);
+        case "martin_get_attempt":
+            return validateGetAttemptInput(args);
+        case "martin_get_verification_results":
+            return validateGetVerificationResultsInput(args);
+        case "martin_run_dossier":
+            return validateRunDossierInput(args);
         default:
             throw new Error(`Unknown tool: ${name}`);
     }
@@ -199,6 +209,61 @@ function validateStatusInput(args) {
         ...(record.latest === true ? { latest: true } : {})
     };
 }
+function validateListRunsInput(args) {
+    const record = requireObject(args);
+    assertAllowedKeys(record, ["runsDir", "limit"]);
+    return {
+        ...(record.runsDir !== undefined
+            ? { runsDir: resolveSafeRunsRootPath(requireString(record.runsDir, "runsDir")) }
+            : {}),
+        ...(record.limit !== undefined ? { limit: requirePositiveInteger(record.limit, "limit") } : {})
+    };
+}
+function validateGetRunInput(args) {
+    const record = requireObject(args);
+    assertAllowedKeys(record, ["loopId", "runsDir", "latest"]);
+    return validateRunSelector(record);
+}
+function validateGetVerificationResultsInput(args) {
+    const record = requireObject(args);
+    assertAllowedKeys(record, ["loopId", "runsDir", "latest"]);
+    return validateRunSelector(record);
+}
+function validateRunDossierInput(args) {
+    const record = requireObject(args);
+    assertAllowedKeys(record, ["loopId", "runsDir", "latest"]);
+    return validateRunSelector(record);
+}
+function validateGetAttemptInput(args) {
+    const record = requireObject(args);
+    assertAllowedKeys(record, ["loopId", "attemptIndex", "runsDir"]);
+    return {
+        loopId: requireLoopId(record.loopId, "loopId"),
+        attemptIndex: requirePositiveInteger(record.attemptIndex, "attemptIndex"),
+        ...(record.runsDir !== undefined
+            ? { runsDir: resolveSafeRunsRootPath(requireString(record.runsDir, "runsDir")) }
+            : {})
+    };
+}
+function validateRunSelector(record) {
+    const selectors = [
+        record.loopId !== undefined ? "loopId" : null,
+        record.latest !== undefined ? "latest" : null
+    ].filter((value) => value !== null);
+    if (selectors.length !== 1) {
+        throw new Error("Provide exactly one of loopId or latest.");
+    }
+    if (record.latest !== undefined && record.latest !== true) {
+        throw new Error("Invalid latest.");
+    }
+    return {
+        ...(record.loopId !== undefined ? { loopId: requireLoopId(record.loopId, "loopId") } : {}),
+        ...(record.latest === true ? { latest: true } : {}),
+        ...(record.runsDir !== undefined
+            ? { runsDir: resolveSafeRunsRootPath(requireString(record.runsDir, "runsDir")) }
+            : {})
+    };
+}
 function requireObject(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         throw new Error("Tool arguments must be an object.");
@@ -252,10 +317,13 @@ function optionalPositiveInteger(value, name) {
     if (value === undefined) {
         return {};
     }
+    return { [name]: requirePositiveInteger(value, name) };
+}
+function requirePositiveInteger(value, name) {
     if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
         throw new Error(`Invalid ${name}.`);
     }
-    return { [name]: value };
+    return value;
 }
 function optionalStringArray(value, name) {
     if (value === undefined) {

package/dist/server.d.ts

@@ -2,7 +2,7 @@
 /**
  * Martin Loop MCP Server
  *
- * Exposes five tools over the Model Context Protocol (stdio transport):
+ * Exposes a governed local MCP cockpit over stdio:
  *   martin_doctor     — inspect local readiness and run-store health
  *   martin_preflight  — normalize a proposed run contract before execution
  *   martin_run        — execute a full Martin loop on a coding task

package/dist/server.js

@@ -2,7 +2,7 @@
 /**
  * Martin Loop MCP Server
  *
- * Exposes five tools over the Model Context Protocol (stdio transport):
+ * Exposes a governed local MCP cockpit over stdio:
  *   martin_doctor     — inspect local readiness and run-store health
  *   martin_preflight  — normalize a proposed run contract before execution
  *   martin_run        — execute a full Martin loop on a coding task
@@ -22,16 +22,23 @@
 import { createRequire } from "node:module";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { martinDoctorTool } from "./tools/doctor.js";
+import { getAttemptTool } from "./tools/get-attempt.js";
+import { getRunTool } from "./tools/get-run.js";
 import { getStatusTool } from "./tools/get-status.js";
+import { getVerificationResultsTool } from "./tools/get-verification-results.js";
 import { inspectLoopTool } from "./tools/inspect-loop.js";
+import { listRunsTool } from "./tools/list-runs.js";
 import { martinPreflightTool } from "./tools/preflight.js";
+import { getMartinPrompt, listMartinPrompts } from "./prompts.js";
+import { listMartinResourceTemplates, listMartinResources, readMartinResource } from "./resources.js";
 import { runLoopTool } from "./tools/run-loop.js";
+import { runDossierTool } from "./tools/run-dossier.js";
 import { sanitizeToolErrorMessage, validateToolInput } from "./server-validation.js";
 const require = createRequire(import.meta.url);
 const packageJson = require("../package.json");
-const server = new Server({ name: "martin-loop", version: packageJson.version }, { capabilities: { tools: {} } });
+const server = new Server({ name: "martin-loop", version: packageJson.version }, { capabilities: { tools: {}, resources: {}, prompts: {} } });
 // ---------------------------------------------------------------------------
 // Tool manifest
 // ---------------------------------------------------------------------------
@@ -245,10 +252,140 @@ server.setRequestHandler(ListToolsRequestSchema, () => ({
                     { required: ["latest"] }
                 ]
             }
+        },
+        {
+            name: "martin_list_runs",
+            description: "List recent Martin Loop runs from the local run store with budget, verifier, and lifecycle summaries. Read-only.",
+            inputSchema: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    runsDir: {
+                        type: "string",
+                        description: "Optional runs-root override resolved under the default Martin runs root. Defaults to MARTIN_RUNS_DIR or ~/.martin/runs."
+                    },
+                    limit: {
+                        type: "integer",
+                        exclusiveMinimum: 0,
+                        description: "Maximum number of runs to return. Defaults to 20."
+                    }
+                }
+            }
+        },
+        {
+            name: "martin_get_run",
+            description: "Load a read-only run dossier by loopId or latest run selector, including task, budget, cost, and attempts.",
+            inputSchema: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    loopId: {
+                        type: "string",
+                        description: "Martin loop ID under the run store."
+                    },
+                    runsDir: {
+                        type: "string",
+                        description: "Optional runs-root override resolved under the default Martin runs root. Defaults to MARTIN_RUNS_DIR or ~/.martin/runs."
+                    },
+                    latest: {
+                        const: true,
+                        description: "When true, loads the most recently updated loop record in the runs directory."
+                    }
+                },
+                oneOf: [{ required: ["loopId"] }, { required: ["latest"] }]
+            }
+        },
+        {
+            name: "martin_get_attempt",
+            description: "Load read-only attempt evidence for a single Martin Loop attempt by loopId and attempt index.",
+            inputSchema: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    loopId: {
+                        type: "string",
+                        description: "Martin loop ID under the run store."
+                    },
+                    attemptIndex: {
+                        type: "integer",
+                        exclusiveMinimum: 0,
+                        description: "1-based attempt index to inspect."
+                    },
+                    runsDir: {
+                        type: "string",
+                        description: "Optional runs-root override resolved under the default Martin runs root. Defaults to MARTIN_RUNS_DIR or ~/.martin/runs."
+                    }
+                },
+                required: ["loopId", "attemptIndex"]
+            }
+        },
+        {
+            name: "martin_get_verification_results",
+            description: "Extract verifier completion events for a run by loopId or latest selector. Read-only.",
+            inputSchema: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    loopId: {
+                        type: "string",
+                        description: "Martin loop ID under the run store."
+                    },
+                    runsDir: {
+                        type: "string",
+                        description: "Optional runs-root override resolved under the default Martin runs root. Defaults to MARTIN_RUNS_DIR or ~/.martin/runs."
+                    },
+                    latest: {
+                        const: true,
+                        description: "When true, loads the most recently updated loop record in the runs directory."
+                    }
+                },
+                oneOf: [{ required: ["loopId"] }, { required: ["latest"] }]
+            }
+        },
+        {
+            name: "martin_run_dossier",
+            description: "Build a compact read-only dossier for review: summary, budget, attempts, and verification evidence.",
+            inputSchema: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    loopId: {
+                        type: "string",
+                        description: "Martin loop ID under the run store."
+                    },
+                    runsDir: {
+                        type: "string",
+                        description: "Optional runs-root override resolved under the default Martin runs root. Defaults to MARTIN_RUNS_DIR or ~/.martin/runs."
+                    },
+                    latest: {
+                        const: true,
+                        description: "When true, loads the most recently updated loop record in the runs directory."
+                    }
+                },
+                oneOf: [{ required: ["loopId"] }, { required: ["latest"] }]
+            }
         }
     ]
 }));
 // ---------------------------------------------------------------------------
+// Resources and prompts
+// ---------------------------------------------------------------------------
+server.setRequestHandler(ListResourcesRequestSchema, () => ({
+    resources: listMartinResources()
+}));
+server.setRequestHandler(ListResourceTemplatesRequestSchema, () => ({
+    resourceTemplates: listMartinResourceTemplates()
+}));
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    return readMartinResource(request.params.uri);
+});
+server.setRequestHandler(ListPromptsRequestSchema, () => ({
+    prompts: listMartinPrompts()
+}));
+server.setRequestHandler(GetPromptRequestSchema, (request) => {
+    return getMartinPrompt(request.params.name, request.params.arguments ?? {});
+});
+// ---------------------------------------------------------------------------
 // Tool dispatch
 // ---------------------------------------------------------------------------
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
@@ -279,6 +416,31 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const output = await getStatusTool(input);
             return { content: [{ type: "text", text: JSON.stringify(output, null, 2) }] };
         }
+        if (name === "martin_list_runs") {
+            const input = validateToolInput("martin_list_runs", args);
+            const output = await listRunsTool(input);
+            return { content: [{ type: "text", text: JSON.stringify(output, null, 2) }] };
+        }
+        if (name === "martin_get_run") {
+            const input = validateToolInput("martin_get_run", args);
+            const output = await getRunTool(input);
+            return { content: [{ type: "text", text: JSON.stringify(output, null, 2) }] };
+        }
+        if (name === "martin_get_attempt") {
+            const input = validateToolInput("martin_get_attempt", args);
+            const output = await getAttemptTool(input);
+            return { content: [{ type: "text", text: JSON.stringify(output, null, 2) }] };
+        }
+        if (name === "martin_get_verification_results") {
+            const input = validateToolInput("martin_get_verification_results", args);
+            const output = await getVerificationResultsTool(input);
+            return { content: [{ type: "text", text: JSON.stringify(output, null, 2) }] };
+        }
+        if (name === "martin_run_dossier") {
+            const input = validateToolInput("martin_run_dossier", args);
+            const output = await runDossierTool(input);
+            return { content: [{ type: "text", text: JSON.stringify(output, null, 2) }] };
+        }
         return {
             content: [{ type: "text", text: `Unknown tool: ${name}` }],
             isError: true

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

@@ -0,0 +1,69 @@
+import { type LoopRunRecord } from "../vendor/core/index.js";
+export interface RunSelectorInput {
+    loopId?: string;
+    runsDir?: string;
+    latest?: boolean;
+}
+export interface RunSummary {
+    loopId: string;
+    title: string;
+    objective: string;
+    status: string;
+    lifecycleState: string;
+    createdAt: string;
+    updatedAt: string;
+    attempts: number;
+    costUsd: number;
+    avoidedUsd: number;
+    pressure: string;
+    shouldStop: boolean;
+    verificationCount: number;
+}
+export interface VerificationResultSummary {
+    eventId?: string;
+    timestamp?: string;
+    lifecycleState?: string;
+    passed?: boolean;
+    summary?: string;
+}
+export declare function summarizeRun(loop: LoopRunRecord): RunSummary;
+export declare function listRunSummaries(input?: {
+    runsDir?: string;
+    limit?: number;
+}): Promise<RunSummary[]>;
+export declare function loadSelectedRun(input: RunSelectorInput): Promise<LoopRunRecord>;
+export declare function extractVerificationResults(loop: LoopRunRecord): VerificationResultSummary[];
+export declare function getAttempt(loop: LoopRunRecord, attemptIndex: number): import("../vendor/core/index.js").LoopAttemptRecord;
+export declare function buildRunDossier(loop: LoopRunRecord): {
+    loopId: string;
+    generatedAt: string;
+    sections: ({
+        kind: string;
+        content: {
+            title: string;
+            objective: string;
+        };
+    } | {
+        kind: string;
+        content: {
+            budget: {
+                maxUsd: number;
+                softLimitUsd: number;
+                maxIterations: number;
+                maxTokens: number;
+            };
+            cost: {
+                actualUsd: number;
+                tokensIn: number;
+                tokensOut: number;
+                avoidedUsd?: number;
+            };
+        };
+    } | {
+        kind: string;
+        content: import("../vendor/core/index.js").LoopAttemptRecord[];
+    } | {
+        kind: string;
+        content: VerificationResultSummary[];
+    })[];
+};

package/dist/tools/cockpit-support.js

@@ -0,0 +1,108 @@
+import { evaluateCostGovernor } from "../vendor/core/index.js";
+import { loadLoopRecordForStatus, loadLoopRecordsForInspect } from "./run-store.js";
+export function summarizeRun(loop) {
+    const costState = evaluateCostGovernor({
+        budget: loop.budget,
+        cost: {
+            actualUsd: loop.cost.actualUsd,
+            avoidedUsd: loop.cost.avoidedUsd ?? 0,
+            tokensIn: loop.cost.tokensIn,
+            tokensOut: loop.cost.tokensOut
+        },
+        attemptsUsed: loop.attempts.length
+    });
+    return {
+        loopId: loop.loopId,
+        title: loop.task.title,
+        objective: loop.task.objective,
+        status: loop.status,
+        lifecycleState: loop.lifecycleState,
+        createdAt: loop.createdAt,
+        updatedAt: loop.updatedAt,
+        attempts: loop.attempts.length,
+        costUsd: loop.cost.actualUsd,
+        avoidedUsd: loop.cost.avoidedUsd ?? 0,
+        pressure: costState.pressure,
+        shouldStop: costState.shouldStop,
+        verificationCount: extractVerificationResults(loop).length
+    };
+}
+export async function listRunSummaries(input = {}) {
+    const inspection = await loadLoopRecordsForInspect({ runsDir: input.runsDir });
+    const summaries = inspection.loops.map((loop) => summarizeRun(loop));
+    summaries.sort((left, right) => {
+        const leftTime = Date.parse(left.updatedAt ?? left.createdAt);
+        const rightTime = Date.parse(right.updatedAt ?? right.createdAt);
+        return (Number.isFinite(rightTime) ? rightTime : 0) - (Number.isFinite(leftTime) ? leftTime : 0);
+    });
+    return summaries.slice(0, input.limit ?? 20);
+}
+export async function loadSelectedRun(input) {
+    const selectors = [input.loopId ? "loopId" : null, input.latest ? "latest" : null].filter(Boolean);
+    if (selectors.length !== 1) {
+        throw new Error("Provide exactly one of loopId or latest.");
+    }
+    const source = await loadLoopRecordForStatus({
+        ...(input.loopId ? { loopId: input.loopId } : {}),
+        ...(input.latest ? { latest: true } : {}),
+        ...(input.runsDir ? { runsDir: input.runsDir } : {})
+    });
+    return source.loop;
+}
+export function extractVerificationResults(loop) {
+    const events = "events" in loop && Array.isArray(loop.events) ? loop.events : [];
+    return events
+        .filter((event) => event?.type === "verification.completed")
+        .map((event) => {
+        const payload = isRecord(event.payload) ? event.payload : {};
+        return {
+            ...(typeof event.eventId === "string" ? { eventId: event.eventId } : {}),
+            ...(typeof event.timestamp === "string" ? { timestamp: event.timestamp } : {}),
+            ...(typeof event.lifecycleState === "string" ? { lifecycleState: event.lifecycleState } : {}),
+            ...(typeof payload.passed === "boolean" ? { passed: payload.passed } : {}),
+            ...(typeof payload.summary === "string" ? { summary: payload.summary } : {})
+        };
+    });
+}
+export function getAttempt(loop, attemptIndex) {
+    const attempt = loop.attempts.find((candidate) => candidate.index === attemptIndex);
+    if (!attempt) {
+        throw new Error("Attempt not found.");
+    }
+    return attempt;
+}
+export function buildRunDossier(loop) {
+    return {
+        loopId: loop.loopId,
+        generatedAt: new Date().toISOString(),
+        sections: [
+            {
+                kind: "summary",
+                content: summarizeRun(loop)
+            },
+            {
+                kind: "task",
+                content: loop.task
+            },
+            {
+                kind: "budget",
+                content: {
+                    budget: loop.budget,
+                    cost: loop.cost
+                }
+            },
+            {
+                kind: "attempts",
+                content: loop.attempts
+            },
+            {
+                kind: "verification",
+                content: extractVerificationResults(loop)
+            }
+        ]
+    };
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+//# sourceMappingURL=cockpit-support.js.map

package/dist/tools/get-attempt.d.ts

@@ -0,0 +1,8 @@
+import { getAttempt } from "./cockpit-support.js";
+export interface GetAttemptInput {
+    loopId: string;
+    attemptIndex: number;
+    runsDir?: string;
+}
+export type GetAttemptOutput = ReturnType<typeof getAttempt>;
+export declare function getAttemptTool(input: GetAttemptInput): Promise<GetAttemptOutput>;

package/dist/tools/get-attempt.js

@@ -0,0 +1,6 @@
+import { getAttempt, loadSelectedRun } from "./cockpit-support.js";
+export async function getAttemptTool(input) {
+    const loop = await loadSelectedRun({ loopId: input.loopId, runsDir: input.runsDir });
+    return getAttempt(loop, input.attemptIndex);
+}
+//# sourceMappingURL=get-attempt.js.map

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

@@ -0,0 +1,17 @@
+import type { LoopRunRecord } from "../vendor/core/index.js";
+import { summarizeRun } from "./cockpit-support.js";
+export interface GetRunInput {
+    loopId?: string;
+    runsDir?: string;
+    latest?: boolean;
+}
+export interface GetRunOutput {
+    summary: ReturnType<typeof summarizeRun>;
+    task: LoopRunRecord["task"];
+    budget: LoopRunRecord["budget"];
+    cost: LoopRunRecord["cost"];
+    attempts: LoopRunRecord["attempts"];
+    createdAt: string;
+    updatedAt: string;
+}
+export declare function getRunTool(input: GetRunInput): Promise<GetRunOutput>;

package/dist/tools/get-run.js

@@ -0,0 +1,14 @@
+import { loadSelectedRun, summarizeRun } from "./cockpit-support.js";
+export async function getRunTool(input) {
+    const loop = await loadSelectedRun(input);
+    return {
+        summary: summarizeRun(loop),
+        task: loop.task,
+        budget: loop.budget,
+        cost: loop.cost,
+        attempts: loop.attempts,
+        createdAt: loop.createdAt,
+        updatedAt: loop.updatedAt
+    };
+}
+//# sourceMappingURL=get-run.js.map

package/dist/tools/get-verification-results.d.ts

@@ -0,0 +1,11 @@
+import { type VerificationResultSummary } from "./cockpit-support.js";
+export interface GetVerificationResultsInput {
+    loopId?: string;
+    runsDir?: string;
+    latest?: boolean;
+}
+export interface GetVerificationResultsOutput {
+    loopId: string;
+    results: VerificationResultSummary[];
+}
+export declare function getVerificationResultsTool(input: GetVerificationResultsInput): Promise<GetVerificationResultsOutput>;

package/dist/tools/get-verification-results.js

@@ -0,0 +1,9 @@
+import { extractVerificationResults, loadSelectedRun } from "./cockpit-support.js";
+export async function getVerificationResultsTool(input) {
+    const loop = await loadSelectedRun(input);
+    return {
+        loopId: loop.loopId,
+        results: extractVerificationResults(loop)
+    };
+}
+//# sourceMappingURL=get-verification-results.js.map

package/dist/tools/list-runs.d.ts

@@ -0,0 +1,9 @@
+import { type RunSummary } from "./cockpit-support.js";
+export interface ListRunsInput {
+    runsDir?: string;
+    limit?: number;
+}
+export interface ListRunsOutput {
+    runs: RunSummary[];
+}
+export declare function listRunsTool(input: ListRunsInput): Promise<ListRunsOutput>;

package/dist/tools/list-runs.js

@@ -0,0 +1,7 @@
+import { listRunSummaries } from "./cockpit-support.js";
+export async function listRunsTool(input) {
+    return {
+        runs: await listRunSummaries(input)
+    };
+}
+//# sourceMappingURL=list-runs.js.map

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

@@ -0,0 +1,8 @@
+import { buildRunDossier } from "./cockpit-support.js";
+export interface RunDossierInput {
+    loopId?: string;
+    runsDir?: string;
+    latest?: boolean;
+}
+export type RunDossierOutput = ReturnType<typeof buildRunDossier>;
+export declare function runDossierTool(input: RunDossierInput): Promise<RunDossierOutput>;

package/dist/tools/run-dossier.js

@@ -0,0 +1,6 @@
+import { buildRunDossier, loadSelectedRun } from "./cockpit-support.js";
+export async function runDossierTool(input) {
+    const loop = await loadSelectedRun(input);
+    return buildRunDossier(loop);
+}
+//# sourceMappingURL=run-dossier.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@martinloop/mcp",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "mcpName": "io.github.Keesan12/martin-loop",
   "private": false,
   "type": "module",
@@ -24,7 +24,9 @@
     "claude",
     "codex",
     "martin_doctor",
-    "martin_preflight"
+    "martin_preflight",
+    "martin_list_runs",
+    "martin_run_dossier"
   ],
   "bin": {
     "mcp": "./dist/server.js",

package/server.json

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