@martinloop/mcp 0.2.0 → 0.2.5

package/dist/tools/doctor.js

@@ -23,11 +23,12 @@ export async function martinDoctorTool(input) {
     }
     warnings.push(...runStore.warnings);
     const status = warnings.length === 0 ? "ok" : "degraded";
+    const summary = status === "ok"
+        ? `Doctor passed: ${runStore.loopCount} run(s) visible in ${runsRoot}.`
+        : `Doctor found ${warnings.length} issue(s); review warnings before live execution.`;
     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.`,
+        summary,
         server: {
             name: "martin-loop",
             nodeVersion: process.version,
@@ -41,8 +42,16 @@ export async function martinDoctorTool(input) {
             liveMode: executionMode.liveMode
         },
         engines: {
-            claude,
-            codex
+            claude: {
+                available: claude.available,
+                detail: claude.detail,
+                ...(claude.resolvedPath ? { resolvedPath: claude.resolvedPath } : {})
+            },
+            codex: {
+                available: codex.available,
+                detail: codex.detail,
+                ...(codex.resolvedPath ? { resolvedPath: codex.resolvedPath } : {})
+            }
         },
         ...(input.engine ? { requestedEngine: input.engine } : {}),
         runStore: {
@@ -53,4 +62,3 @@ export async function martinDoctorTool(input) {
         warnings
     };
 }
-//# sourceMappingURL=doctor.js.map

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

@@ -1,8 +1,15 @@
-import { getAttempt } from "./cockpit-support.js";
-export interface GetAttemptInput {
-    loopId: string;
-    attemptIndex: number;
+import { buildAttemptSummary, buildLoopPreview } from "./tool-support.js";
+export interface MartinGetAttemptInput {
+    file?: string;
+    loopId?: string;
     runsDir?: string;
+    attemptIndex?: number;
 }
-export type GetAttemptOutput = ReturnType<typeof getAttempt>;
-export declare function getAttemptTool(input: GetAttemptInput): Promise<GetAttemptOutput>;
+export interface MartinGetAttemptOutput {
+    source: string;
+    sourceKind: "file" | "loop_id" | "latest" | "runs_root";
+    loop: ReturnType<typeof buildLoopPreview>;
+    attempt: ReturnType<typeof buildAttemptSummary>;
+    warnings: string[];
+}
+export declare function martinGetAttemptTool(input: MartinGetAttemptInput): Promise<MartinGetAttemptOutput>;

package/dist/tools/get-attempt.js

@@ -1,6 +1,15 @@
-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);
+import { buildAttemptArtifactsReference, buildAttemptSummary, buildLoopPreview } from "./tool-support.js";
+import { loadAttemptFromLoop } from "./run-store.js";
+export async function martinGetAttemptTool(input) {
+    const { detail, attempt } = await loadAttemptFromLoop(input);
+    const artifacts = detail.canonicalRunDirectory
+        ? await buildAttemptArtifactsReference(detail.runsRoot, detail.loop.loopId, attempt.index)
+        : undefined;
+    return {
+        source: detail.source,
+        sourceKind: detail.sourceKind,
+        loop: buildLoopPreview(detail.loop),
+        attempt: buildAttemptSummary(attempt, artifacts),
+        warnings: detail.warnings
+    };
 }
-//# sourceMappingURL=get-attempt.js.map

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

@@ -1,17 +1,24 @@
-import type { LoopRunRecord } from "../vendor/core/index.js";
-import { summarizeRun } from "./cockpit-support.js";
-export interface GetRunInput {
+import { buildArtifactSummary, buildBudgetSnapshot, buildCostSnapshot, buildLoopPreview, buildVerificationSummary } from "./tool-support.js";
+export interface MartinGetRunInput {
+    file?: string;
     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 interface MartinGetRunOutput {
+    source: string;
+    sourceKind: "file" | "loop_id" | "latest" | "runs_root";
+    loop: ReturnType<typeof buildLoopPreview>;
+    budget: ReturnType<typeof buildBudgetSnapshot>;
+    cost: ReturnType<typeof buildCostSnapshot>;
+    verification: ReturnType<typeof buildVerificationSummary>;
+    artifacts: ReturnType<typeof buildArtifactSummary>;
+    inspection: {
+        runsRoot: string;
+        canonicalRunDirectory?: string;
+        canonicalLoopRecordPath?: string;
+        ledgerPath?: string;
+    };
+    warnings: string[];
 }
-export declare function getRunTool(input: GetRunInput): Promise<GetRunOutput>;
+export declare function martinGetRunTool(input: MartinGetRunInput): Promise<MartinGetRunOutput>;

package/dist/tools/get-run.js

@@ -1,14 +1,23 @@
-import { loadSelectedRun, summarizeRun } from "./cockpit-support.js";
-export async function getRunTool(input) {
-    const loop = await loadSelectedRun(input);
+import { buildArtifactSummary, buildBudgetSnapshot, buildCostSnapshot, buildLoopPreview, buildVerificationSummary } from "./tool-support.js";
+import { loadDetailedLoopRecord, readLedgerEvents } from "./run-store.js";
+export async function martinGetRunTool(input) {
+    const detail = await loadDetailedLoopRecord(input);
+    const ledgerEvents = await readLedgerEvents(detail);
+    const verification = buildVerificationSummary(detail.loop, ledgerEvents);
     return {
-        summary: summarizeRun(loop),
-        task: loop.task,
-        budget: loop.budget,
-        cost: loop.cost,
-        attempts: loop.attempts,
-        createdAt: loop.createdAt,
-        updatedAt: loop.updatedAt
+        source: detail.source,
+        sourceKind: detail.sourceKind,
+        loop: buildLoopPreview(detail.loop),
+        budget: buildBudgetSnapshot(detail.loop.budget),
+        cost: buildCostSnapshot(detail.loop.cost),
+        verification,
+        artifacts: buildArtifactSummary(detail.loop),
+        inspection: {
+            runsRoot: detail.runsRoot,
+            ...(detail.canonicalRunDirectory ? { canonicalRunDirectory: detail.canonicalRunDirectory } : {}),
+            ...(detail.canonicalLoopRecordPath ? { canonicalLoopRecordPath: detail.canonicalLoopRecordPath } : {}),
+            ...(detail.ledgerPath ? { ledgerPath: detail.ledgerPath } : {})
+        },
+        warnings: [...detail.warnings, ...verification.warnings]
     };
 }
-//# sourceMappingURL=get-run.js.map

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

@@ -1,3 +1,4 @@
+import { type LoopPreview } from "./tool-support.js";
 export interface GetStatusInput {
     /** JSON-serialized LoopRecord. */
     loopJson?: string;
@@ -11,6 +12,7 @@ export interface GetStatusInput {
     latest?: boolean;
 }
 export interface GetStatusOutput {
+    source: string;
     loopId: string;
     status: string;
     lifecycleState: string;
@@ -22,5 +24,14 @@ export interface GetStatusOutput {
     remainingBudgetUsd: number;
     remainingIterations: number;
     remainingTokens: number;
+    budget: {
+        maxUsd: number;
+        softLimitUsd: number;
+        maxIterations: number;
+        maxTokens: number;
+    };
+    inspection: {
+        loop: LoopPreview;
+    };
 }
 export declare function getStatusTool(input: GetStatusInput): Promise<GetStatusOutput>;

package/dist/tools/get-status.js

@@ -1,5 +1,6 @@
 import { evaluateCostGovernor } from "../vendor/core/index.js";
 import { loadLoopRecordForStatus } from "./run-store.js";
+import { buildLoopPreview } from "./tool-support.js";
 export async function getStatusTool(input) {
     const resolved = await loadLoopRecordForStatus(input);
     const loop = resolved.loop;
@@ -14,6 +15,7 @@ export async function getStatusTool(input) {
         attemptsUsed: loop.attempts.length
     });
     return {
+        source: resolved.source,
         loopId: loop.loopId,
         status: loop.status,
         lifecycleState: loop.lifecycleState,
@@ -24,7 +26,15 @@ export async function getStatusTool(input) {
         shouldStop: costState.shouldStop,
         remainingBudgetUsd: costState.remainingBudgetUsd,
         remainingIterations: costState.remainingIterations,
-        remainingTokens: costState.remainingTokens
+        remainingTokens: costState.remainingTokens,
+        budget: {
+            maxUsd: loop.budget.maxUsd,
+            softLimitUsd: loop.budget.softLimitUsd,
+            maxIterations: loop.budget.maxIterations,
+            maxTokens: loop.budget.maxTokens
+        },
+        inspection: {
+            loop: buildLoopPreview(loop)
+        }
     };
 }
-//# sourceMappingURL=get-status.js.map

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

@@ -1,11 +1,14 @@
-import { type VerificationResultSummary } from "./cockpit-support.js";
-export interface GetVerificationResultsInput {
+import { buildLoopPreview, buildVerificationSummary } from "./tool-support.js";
+export interface MartinGetVerificationResultsInput {
+    file?: string;
     loopId?: string;
     runsDir?: string;
-    latest?: boolean;
 }
-export interface GetVerificationResultsOutput {
-    loopId: string;
-    results: VerificationResultSummary[];
+export interface MartinGetVerificationResultsOutput {
+    source: string;
+    sourceKind: "file" | "loop_id" | "latest" | "runs_root";
+    loop: ReturnType<typeof buildLoopPreview>;
+    verification: ReturnType<typeof buildVerificationSummary>;
+    warnings: string[];
 }
-export declare function getVerificationResultsTool(input: GetVerificationResultsInput): Promise<GetVerificationResultsOutput>;
+export declare function martinGetVerificationResultsTool(input: MartinGetVerificationResultsInput): Promise<MartinGetVerificationResultsOutput>;

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

@@ -1,9 +1,14 @@
-import { extractVerificationResults, loadSelectedRun } from "./cockpit-support.js";
-export async function getVerificationResultsTool(input) {
-    const loop = await loadSelectedRun(input);
+import { buildLoopPreview, buildVerificationSummary } from "./tool-support.js";
+import { loadDetailedLoopRecord, readLedgerEvents } from "./run-store.js";
+export async function martinGetVerificationResultsTool(input) {
+    const detail = await loadDetailedLoopRecord(input);
+    const ledgerEvents = await readLedgerEvents(detail);
+    const verification = buildVerificationSummary(detail.loop, ledgerEvents);
     return {
-        loopId: loop.loopId,
-        results: extractVerificationResults(loop)
+        source: detail.source,
+        sourceKind: detail.sourceKind,
+        loop: buildLoopPreview(detail.loop),
+        verification,
+        warnings: [...detail.warnings, ...verification.warnings]
     };
 }
-//# sourceMappingURL=get-verification-results.js.map

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

@@ -1,4 +1,5 @@
 import { type PortfolioSnapshot } from "../vendor/contracts/index.js";
+import { type LoopPreview } from "./tool-support.js";
 export interface InspectLoopInput {
     /** Optional path to a JSON, JSONL, or run-store directory under the Martin runs root. */
     file?: string;
@@ -9,5 +10,13 @@ export interface InspectLoopOutput {
     source: string;
     loopCount: number;
     portfolio: PortfolioSnapshot;
+    latestRun?: LoopPreview;
+    recentRuns: LoopPreview[];
+    statusBreakdown: Record<string, number>;
+    lifecycleBreakdown: Record<string, number>;
+    inspection: {
+        sourceKind: "file" | "runs_root";
+    };
+    warnings: string[];
 }
 export declare function inspectLoopTool(input: InspectLoopInput): Promise<InspectLoopOutput>;

package/dist/tools/inspect-loop.js

@@ -1,12 +1,21 @@
 import { buildPortfolioSnapshot } from "../vendor/contracts/index.js";
 import { loadLoopRecordsForInspect } from "./run-store.js";
+import { buildLoopCollectionSummary } from "./tool-support.js";
 export async function inspectLoopTool(input) {
     const inspection = await loadLoopRecordsForInspect(input);
     const loops = inspection.loops;
+    const summary = buildLoopCollectionSummary(inspection.loops);
     return {
         source: inspection.source,
         loopCount: loops.length,
-        portfolio: buildPortfolioSnapshot(loops)
+        portfolio: buildPortfolioSnapshot(loops),
+        ...(summary.latestRun ? { latestRun: summary.latestRun } : {}),
+        recentRuns: summary.recentRuns,
+        statusBreakdown: summary.statusBreakdown,
+        lifecycleBreakdown: summary.lifecycleBreakdown,
+        inspection: {
+            sourceKind: input.file ? "file" : "runs_root"
+        },
+        warnings: inspection.warnings
     };
 }
-//# sourceMappingURL=inspect-loop.js.map

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

@@ -1,9 +1,29 @@
-import { type RunSummary } from "./cockpit-support.js";
-export interface ListRunsInput {
+import { buildLoopPreview } from "./tool-support.js";
+export interface MartinListRunsInput {
     runsDir?: string;
     limit?: number;
+    status?: string;
+    lifecycleState?: string;
+    adapterId?: string;
+    model?: string;
+    updatedAfter?: string;
 }
-export interface ListRunsOutput {
-    runs: RunSummary[];
+export interface MartinListRunsOutput {
+    source: string;
+    runsRoot: string;
+    filters: {
+        limit: number;
+        status?: string;
+        lifecycleState?: string;
+        adapterId?: string;
+        model?: string;
+        updatedAfter?: string;
+    };
+    loopCount: number;
+    latestRun?: ReturnType<typeof buildLoopPreview>;
+    recentRuns: Array<ReturnType<typeof buildLoopPreview>>;
+    statusBreakdown: Record<string, number>;
+    lifecycleBreakdown: Record<string, number>;
+    warnings: string[];
 }
-export declare function listRunsTool(input: ListRunsInput): Promise<ListRunsOutput>;
+export declare function martinListRunsTool(input: MartinListRunsInput): Promise<MartinListRunsOutput>;

package/dist/tools/list-runs.js

@@ -1,7 +1,24 @@
-import { listRunSummaries } from "./cockpit-support.js";
-export async function listRunsTool(input) {
+import { buildLoopCollectionSummary, buildLoopPreview } from "./tool-support.js";
+import { listLoopRecords } from "./run-store.js";
+export async function martinListRunsTool(input) {
+    const result = await listLoopRecords(input);
+    const summary = buildLoopCollectionSummary(result.loops);
     return {
-        runs: await listRunSummaries(input)
+        source: result.source,
+        runsRoot: result.runsRoot,
+        filters: {
+            limit: input.limit ?? 20,
+            ...(input.status ? { status: input.status } : {}),
+            ...(input.lifecycleState ? { lifecycleState: input.lifecycleState } : {}),
+            ...(input.adapterId ? { adapterId: input.adapterId } : {}),
+            ...(input.model ? { model: input.model } : {}),
+            ...(input.updatedAfter ? { updatedAfter: input.updatedAfter } : {})
+        },
+        loopCount: result.loops.length,
+        ...(summary.latestRun ? { latestRun: summary.latestRun } : {}),
+        recentRuns: result.loops.map((loop) => buildLoopPreview(loop)),
+        statusBreakdown: summary.statusBreakdown,
+        lifecycleBreakdown: summary.lifecycleBreakdown,
+        warnings: result.warnings
     };
 }
-//# sourceMappingURL=list-runs.js.map

package/dist/tools/preflight.js

@@ -58,7 +58,13 @@ export async function martinPreflightTool(input) {
         },
         execution: {
             requestedEngine: engine,
-            engineAvailability,
+            engineAvailability: {
+                available: engineAvailability.available,
+                detail: engineAvailability.detail,
+                ...(engineAvailability.resolvedPath
+                    ? { resolvedPath: engineAvailability.resolvedPath }
+                    : {})
+            },
             runsRoot: resolveRunsRoot(process.env),
             pathScope: {
                 repoRoot: workingDirectory,
@@ -73,4 +79,3 @@ export async function martinPreflightTool(input) {
         }
     };
 }
-//# sourceMappingURL=preflight.js.map

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

@@ -1,8 +1,41 @@
-import { buildRunDossier } from "./cockpit-support.js";
-export interface RunDossierInput {
+import { buildArtifactSummary, buildBudgetSnapshot, buildCostSnapshot, buildEventSummaries, buildLoopPreview, buildVerificationSummary } from "./tool-support.js";
+export interface MartinRunDossierInput {
+    file?: string;
     loopId?: string;
     runsDir?: string;
     latest?: boolean;
 }
-export type RunDossierOutput = ReturnType<typeof buildRunDossier>;
-export declare function runDossierTool(input: RunDossierInput): Promise<RunDossierOutput>;
+export interface MartinRunDossierOutput {
+    source: string;
+    sourceKind: "file" | "loop_id" | "latest" | "runs_root";
+    loop: ReturnType<typeof buildLoopPreview>;
+    budget: ReturnType<typeof buildBudgetSnapshot>;
+    cost: ReturnType<typeof buildCostSnapshot>;
+    attempts: Array<{
+        index: number;
+        attemptId?: string;
+        adapterId?: string;
+        model?: string;
+        failureClass?: string;
+        intervention?: string;
+        startedAt?: string;
+        completedAt?: string;
+        summary?: string;
+        artifactFiles: string[];
+    }>;
+    verification: ReturnType<typeof buildVerificationSummary>;
+    artifacts: ReturnType<typeof buildArtifactSummary>;
+    recentEvents: ReturnType<typeof buildEventSummaries>;
+    related: {
+        resources: string[];
+        prompts: string[];
+    };
+    inspection: {
+        runsRoot: string;
+        canonicalRunDirectory?: string;
+        canonicalLoopRecordPath?: string;
+        ledgerPath?: string;
+    };
+    warnings: string[];
+}
+export declare function martinRunDossierTool(input: MartinRunDossierInput): Promise<MartinRunDossierOutput>;

package/dist/tools/run-dossier.js

@@ -1,6 +1,41 @@
-import { buildRunDossier, loadSelectedRun } from "./cockpit-support.js";
-export async function runDossierTool(input) {
-    const loop = await loadSelectedRun(input);
-    return buildRunDossier(loop);
+import { buildArtifactSummary, buildBudgetSnapshot, buildCostSnapshot, buildEventSummaries, buildLoopPreview, buildSuggestedPromptNames, buildSuggestedResourceUris, buildVerificationSummary } from "./tool-support.js";
+import { loadDetailedLoopRecord, readAttemptArtifactFiles, readLedgerEvents } from "./run-store.js";
+export async function martinRunDossierTool(input) {
+    const detail = await loadDetailedLoopRecord(input);
+    const ledgerEvents = await readLedgerEvents(detail);
+    const verification = buildVerificationSummary(detail.loop, ledgerEvents);
+    const attempts = await Promise.all(detail.loop.attempts.map(async (attempt) => ({
+        index: attempt.index,
+        ...(attempt.attemptId ? { attemptId: attempt.attemptId } : {}),
+        ...(attempt.adapterId ? { adapterId: attempt.adapterId } : {}),
+        ...(attempt.model ? { model: attempt.model } : {}),
+        ...(attempt.failureClass ? { failureClass: attempt.failureClass } : {}),
+        ...(attempt.intervention ? { intervention: attempt.intervention } : {}),
+        ...(attempt.startedAt ? { startedAt: attempt.startedAt } : {}),
+        ...(attempt.completedAt ? { completedAt: attempt.completedAt } : {}),
+        ...(attempt.summary ? { summary: attempt.summary } : {}),
+        artifactFiles: await readAttemptArtifactFiles(detail, attempt.index)
+    })));
+    return {
+        source: detail.source,
+        sourceKind: detail.sourceKind,
+        loop: buildLoopPreview(detail.loop),
+        budget: buildBudgetSnapshot(detail.loop.budget),
+        cost: buildCostSnapshot(detail.loop.cost),
+        attempts,
+        verification,
+        artifacts: buildArtifactSummary(detail.loop),
+        recentEvents: buildEventSummaries(detail.loop, 8),
+        related: {
+            resources: buildSuggestedResourceUris(detail.loop.loopId),
+            prompts: buildSuggestedPromptNames()
+        },
+        inspection: {
+            runsRoot: detail.runsRoot,
+            ...(detail.canonicalRunDirectory ? { canonicalRunDirectory: detail.canonicalRunDirectory } : {}),
+            ...(detail.canonicalLoopRecordPath ? { canonicalLoopRecordPath: detail.canonicalLoopRecordPath } : {}),
+            ...(detail.ledgerPath ? { ledgerPath: detail.ledgerPath } : {})
+        },
+        warnings: [...detail.warnings, ...verification.warnings]
+    };
 }
-//# sourceMappingURL=run-dossier.js.map

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

@@ -1,3 +1,5 @@
+import { type LoopBudget } from "../vendor/contracts/index.js";
+import { buildArtifactSummary, buildVerificationSummary, buildLoopPreview, type MartinEngine } from "./tool-support.js";
 export interface RunLoopInput {
     objective: string;
     workingDirectory?: string;
@@ -20,5 +22,22 @@ export interface RunLoopOutput {
     costUsd: number;
     verificationPassed: boolean;
     loopId: string;
+    pressure: string;
+    shouldStop: boolean;
+    remainingBudgetUsd: number;
+    remainingIterations: number;
+    remainingTokens: number;
+    engine: MartinEngine;
+    workingDirectory: string;
+    budget: LoopBudget;
+    inspection: {
+        runsRoot: string;
+        runDirectory: string;
+        loopRecordPath: string;
+        ledgerPath: string;
+        loop: ReturnType<typeof buildLoopPreview>;
+        verification: ReturnType<typeof buildVerificationSummary>;
+        artifacts: ReturnType<typeof buildArtifactSummary>;
+    };
 }
 export declare function runLoopTool(input: RunLoopInput): Promise<RunLoopOutput>;

package/dist/tools/run-loop.js

@@ -1,13 +1,24 @@
 import { createClaudeCliAdapter, createCodexCliAdapter, createStubDirectProviderAdapter } from "../vendor/adapters/index.js";
-import { createFileRunStore, resolveRunsRoot, runMartin } from "../vendor/core/index.js";
+import { createFileRunStore, evaluateCostGovernor, resolveRunsRoot, runMartin } from "../vendor/core/index.js";
 import { DEFAULT_BUDGET } from "../vendor/contracts/index.js";
 import { normalizeSafePathPatterns, resolveSafeRepoRoot } from "../server-validation.js";
+import { MartinToolError } from "./tool-errors.js";
+import { buildArtifactSummary, buildVerificationSummary, buildLoopPreview, buildRunRecordPaths, getEngineAvailability, resolveExecutionMode } from "./tool-support.js";
 export async function runLoopTool(input) {
     const workingDirectory = resolveSafeRepoRoot(input.workingDirectory);
     const engine = input.engine ?? "claude";
     const model = input.model;
     const allowedPaths = normalizeSafePathPatterns(input.allowedPaths, "allowedPaths");
     const deniedPaths = normalizeSafePathPatterns(input.deniedPaths, "deniedPaths");
+    const executionMode = resolveExecutionMode();
+    const engineAvailability = getEngineAvailability(engine);
+    if (executionMode.liveMode && !engineAvailability.available) {
+        throw new MartinToolError("engine_unavailable", `Engine '${engine}' is not available on PATH.`, {
+            category: "environment",
+            suggestion: "Install the requested CLI or set MARTIN_LIVE=false for stub execution.",
+            retryable: false
+        });
+    }
     const adapter = process.env.MARTIN_LIVE === "false"
         ? createStubDirectProviderAdapter({ label: "Stub adapter (MARTIN_LIVE=false)", providerId: "stub", model: "stub" })
         : engine === "codex"
@@ -44,6 +55,20 @@ export async function runLoopTool(input) {
     });
     const lastAttempt = result.loop.attempts.at(-1);
     const verificationPassed = lastAttempt !== undefined && result.decision.lifecycleState === "completed";
+    const costState = evaluateCostGovernor({
+        budget: result.loop.budget,
+        cost: {
+            actualUsd: result.loop.cost.actualUsd,
+            avoidedUsd: result.loop.cost.avoidedUsd ?? 0,
+            tokensIn: result.loop.cost.tokensIn,
+            tokensOut: result.loop.cost.tokensOut
+        },
+        attemptsUsed: result.loop.attempts.length
+    });
+    const runsRoot = resolveRunsRoot(process.env);
+    const recordPaths = buildRunRecordPaths(runsRoot, result.loop.loopId);
+    const verification = buildVerificationSummary(result.loop);
+    const artifacts = buildArtifactSummary(result.loop);
     return {
         status: result.loop.status,
         lifecycleState: result.decision.lifecycleState,
@@ -51,7 +76,20 @@ export async function runLoopTool(input) {
         attempts: result.loop.attempts.length,
         costUsd: result.loop.cost.actualUsd,
         verificationPassed,
-        loopId: result.loop.loopId
+        loopId: result.loop.loopId,
+        pressure: costState.pressure,
+        shouldStop: costState.shouldStop,
+        remainingBudgetUsd: costState.remainingBudgetUsd,
+        remainingIterations: costState.remainingIterations,
+        remainingTokens: costState.remainingTokens,
+        engine,
+        workingDirectory,
+        budget,
+        inspection: {
+            ...recordPaths,
+            loop: buildLoopPreview(result.loop),
+            verification,
+            artifacts
+        }
     };
 }
-//# sourceMappingURL=run-loop.js.map