@martinloop/mcp 0.1.3 → 0.2.0

package/dist/server.js

@@ -2,10 +2,12 @@
 /**
  * Martin Loop MCP Server
  *
- * Exposes three tools over the Model Context Protocol (stdio transport):
- *   martin_run      — execute a full Martin loop on a coding task
- *   martin_inspect  — summarise a saved loop record file
- *   martin_status   — return cost and pressure state from a loop record
+ * 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
+ *   martin_inspect    — summarise a saved loop record file
+ *   martin_status     — return cost and pressure state from a loop record
  *
  * Setup (Claude Code):
  *   macOS/Linux: claude mcp add --scope user martin-loop -- npx @martinloop/mcp
@@ -20,19 +22,117 @@
 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
 // ---------------------------------------------------------------------------
 server.setRequestHandler(ListToolsRequestSchema, () => ({
     tools: [
+        {
+            name: "martin_doctor",
+            description: "Inspect Martin MCP readiness without changing code. Reports workspace roots, run-store visibility, execution mode, and whether claude or codex is available on PATH.",
+            inputSchema: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    workingDirectory: {
+                        type: "string",
+                        description: "Optional repo-root override resolved under the MCP workspace root (or current working directory). Must stay within that safe root."
+                    },
+                    runsDir: {
+                        type: "string",
+                        description: "Optional runs-root override resolved under the default Martin runs root. Defaults to MARTIN_RUNS_DIR or ~/.martin/runs."
+                    },
+                    engine: {
+                        type: "string",
+                        enum: ["claude", "codex"],
+                        description: "Optional engine to emphasize in the readiness report."
+                    }
+                }
+            }
+        },
+        {
+            name: "martin_preflight",
+            description: "Validate and normalize a proposed martin_run contract before execution. Reports the effective budget, path scope, engine readiness, and expected run-store layout.",
+            inputSchema: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    objective: {
+                        type: "string",
+                        description: "The coding task to complete. Be specific about what needs to change."
+                    },
+                    workingDirectory: {
+                        type: "string",
+                        description: "Optional repo-root override resolved under the MCP workspace root (or current working directory). Must stay within that safe root."
+                    },
+                    engine: {
+                        type: "string",
+                        enum: ["claude", "codex"],
+                        description: "Which agent CLI to use. Defaults to 'claude'."
+                    },
+                    model: {
+                        type: "string",
+                        description: "Model override passed to the CLI (e.g. 'claude-opus-4-6', 'o3')."
+                    },
+                    maxUsd: {
+                        type: "number",
+                        exclusiveMinimum: 0,
+                        description: "Hard budget ceiling in USD. Defaults to 25."
+                    },
+                    maxIterations: {
+                        type: "integer",
+                        exclusiveMinimum: 0,
+                        description: "Maximum number of loop attempts. Defaults to 8."
+                    },
+                    maxTokens: {
+                        type: "integer",
+                        exclusiveMinimum: 0,
+                        description: "Maximum total tokens across all attempts. Defaults to 80000."
+                    },
+                    verificationPlan: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Shell commands that must all exit 0 for the task to be considered complete (e.g. ['pnpm test', 'pnpm build'])."
+                    },
+                    allowedPaths: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Repo-relative path globs Martin may modify, such as ['src/**', 'tests/**']. Absolute paths and '..' traversal are rejected."
+                    },
+                    deniedPaths: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Repo-relative path globs Martin must never modify, such as ['.env', 'docs/security/**']. Absolute paths and '..' traversal are rejected."
+                    },
+                    workspaceId: {
+                        type: "string",
+                        description: "Workspace identifier for telemetry. Defaults to 'ws_mcp'."
+                    },
+                    projectId: {
+                        type: "string",
+                        description: "Project identifier for telemetry. Defaults to 'proj_mcp'."
+                    }
+                },
+                required: ["objective"]
+            }
+        },
         {
             name: "martin_run",
             description: "Execute a full Martin Loop on a coding task. Martin spawns the selected agent CLI (claude or codex), runs the task, classifies failures, and retries within the specified budget. Returns the loop outcome including lifecycle state, attempt count, and spend.",
@@ -152,15 +252,155 @@ 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) => {
     const { name, arguments: args } = request.params;
     try {
+        if (name === "martin_doctor") {
+            const input = validateToolInput("martin_doctor", args);
+            const output = await martinDoctorTool(input);
+            return { content: [{ type: "text", text: JSON.stringify(output, null, 2) }] };
+        }
+        if (name === "martin_preflight") {
+            const input = validateToolInput("martin_preflight", args);
+            const output = await martinPreflightTool(input);
+            return { content: [{ type: "text", text: JSON.stringify(output, null, 2) }] };
+        }
         if (name === "martin_run") {
             const input = validateToolInput("martin_run", args);
             const output = await runLoopTool(input);
@@ -176,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/doctor.d.ts

@@ -0,0 +1,35 @@
+import { type LoopPreview, type MartinEngine } from "./tool-support.js";
+export interface MartinDoctorInput {
+    workingDirectory?: string;
+    runsDir?: string;
+    engine?: MartinEngine;
+}
+export interface MartinDoctorOutput {
+    status: "ok" | "degraded";
+    summary: string;
+    server: {
+        name: "martin-loop";
+        nodeVersion: string;
+        platform: NodeJS.Platform;
+    };
+    environment: {
+        workspaceRoot: string;
+        workingDirectory: string;
+        runsRoot: string;
+        mode: "live" | "stub";
+        liveMode: boolean;
+    };
+    engines: Record<MartinEngine, {
+        available: boolean;
+        detail: string;
+        resolvedPath?: string;
+    }>;
+    requestedEngine?: MartinEngine;
+    runStore: {
+        exists: boolean;
+        loopCount: number;
+        latestRun?: LoopPreview;
+    };
+    warnings: string[];
+}
+export declare function martinDoctorTool(input: MartinDoctorInput): Promise<MartinDoctorOutput>;

package/dist/tools/doctor.js

@@ -0,0 +1,56 @@
+import { resolveRunsRoot } from "../vendor/core/index.js";
+import { resolveSafeRepoRoot, resolveSafeRunsRootPath } from "../server-validation.js";
+import { getEngineAvailability, inspectRunsRoot, resolveExecutionMode } from "./tool-support.js";
+export async function martinDoctorTool(input) {
+    const workingDirectory = resolveSafeRepoRoot(input.workingDirectory);
+    const runsRoot = resolveSafeRunsRootPath(input.runsDir, resolveRunsRoot(process.env));
+    const executionMode = resolveExecutionMode();
+    const claude = getEngineAvailability("claude");
+    const codex = getEngineAvailability("codex");
+    const runStore = await inspectRunsRoot(runsRoot);
+    const warnings = [];
+    if (!runStore.exists) {
+        warnings.push("Configured Martin runs root does not exist yet.");
+    }
+    if (executionMode.liveMode && !claude.available && !codex.available) {
+        warnings.push("Neither claude nor codex is currently available on PATH for live runs.");
+    }
+    if (input.engine && executionMode.liveMode) {
+        const selected = input.engine === "claude" ? claude : codex;
+        if (!selected.available) {
+            warnings.push(`Requested engine '${input.engine}' is not available on PATH.`);
+        }
+    }
+    warnings.push(...runStore.warnings);
+    const status = warnings.length === 0 ? "ok" : "degraded";
+    return {
+        status,
+        summary: status === "ok"
+            ? `Doctor passed: ${runStore.loopCount} run(s) visible in ${runsRoot}.`
+            : `Doctor found ${warnings.length} issue(s); review warnings before live execution.`,
+        server: {
+            name: "martin-loop",
+            nodeVersion: process.version,
+            platform: process.platform
+        },
+        environment: {
+            workspaceRoot: resolveSafeRepoRoot(),
+            workingDirectory,
+            runsRoot,
+            mode: executionMode.mode,
+            liveMode: executionMode.liveMode
+        },
+        engines: {
+            claude,
+            codex
+        },
+        ...(input.engine ? { requestedEngine: input.engine } : {}),
+        runStore: {
+            exists: runStore.exists,
+            loopCount: runStore.loopCount,
+            ...(runStore.latestRun ? { latestRun: runStore.latestRun } : {})
+        },
+        warnings
+    };
+}
+//# sourceMappingURL=doctor.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