@martinloop/mcp 0.3.9 → 0.5.1

package/dist/server.js

@@ -16,12 +16,14 @@
  * Manual start:
  *   node dist/server.js
  */
+import { createServer as createHttpServer } from "node:http";
 import { fileURLToPath } from "node:url";
 import { realpathSync } from "node:fs";
 import path from "node:path";
 import { resolveRunsRoot } from "./vendor/core/index.js";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { MARTIN_MCP_PACKAGE_VERSION } from "./package-version.js";
 import { getMartinPrompt, listMartinPrompts } from "./prompts.js";
@@ -53,6 +55,15 @@ const stringArraySchema = {
     type: "array",
     items: { type: "string" }
 };
+function describeCostProvenance(provenance) {
+    if (provenance === "actual")
+        return "provider-settled actual";
+    if (provenance === "calculated")
+        return "calculated from observed usage";
+    if (provenance === "estimated")
+        return "estimated";
+    return "unavailable";
+}
 const loopPreviewSchema = {
     type: "object",
     additionalProperties: true,
@@ -66,6 +77,10 @@ const loopPreviewSchema = {
         updatedAt: { type: "string" },
         attempts: { type: "integer" },
         costUsd: { type: "number" },
+        costProvenance: {
+            type: "string",
+            enum: ["actual", "calculated", "estimated", "unavailable"]
+        },
         avoidedUsd: { type: "number" },
         pressure: { type: "string" },
         shouldStop: { type: "boolean" },
@@ -85,6 +100,7 @@ const loopPreviewSchema = {
         "lifecycleState",
         "attempts",
         "costUsd",
+        "costProvenance",
         "avoidedUsd",
         "pressure",
         "shouldStop",
@@ -111,9 +127,13 @@ const costSchema = {
         actualUsd: { type: "number" },
         avoidedUsd: { type: "number" },
         tokensIn: { type: "integer" },
-        tokensOut: { type: "integer" }
+        tokensOut: { type: "integer" },
+        provenance: {
+            type: "string",
+            enum: ["actual", "calculated", "estimated", "unavailable"]
+        }
     },
-    required: ["actualUsd", "avoidedUsd", "tokensIn", "tokensOut"]
+    required: ["actualUsd", "avoidedUsd", "tokensIn", "tokensOut", "provenance"]
 };
 const verificationSchema = {
     type: "object",
@@ -246,6 +266,10 @@ const runOutputSchema = {
         reason: { type: "string" },
         attempts: { type: "integer" },
         costUsd: { type: "number" },
+        costProvenance: {
+            type: "string",
+            enum: ["actual", "calculated", "estimated", "unavailable"]
+        },
         verificationPassed: { type: "boolean" },
         loopId: { type: "string" },
         pressure: { type: "string" },
@@ -277,6 +301,7 @@ const runOutputSchema = {
         "reason",
         "attempts",
         "costUsd",
+        "costProvenance",
         "verificationPassed",
         "loopId",
         "pressure",
@@ -344,6 +369,10 @@ const statusOutputSchema = {
         lifecycleState: { type: "string" },
         attempts: { type: "integer" },
         costUsd: { type: "number" },
+        costProvenance: {
+            type: "string",
+            enum: ["actual", "calculated", "estimated", "unavailable"]
+        },
         avoidedUsd: { type: "number" },
         pressure: { type: "string" },
         shouldStop: { type: "boolean" },
@@ -367,6 +396,7 @@ const statusOutputSchema = {
         "lifecycleState",
         "attempts",
         "costUsd",
+        "costProvenance",
         "avoidedUsd",
         "pressure",
         "shouldStop",
@@ -1401,6 +1431,10 @@ export function createMartinMcpServer(serverInfo) {
                             type: "array",
                             items: { type: "string" },
                             description: "Optional file paths to scope the estimate."
+                        },
+                        workingDirectory: {
+                            type: "string",
+                            description: "Optional workspace path for recording the estimate receipt against the same task root you plan to run."
                         }
                     },
                     required: ["objective"]
@@ -1497,17 +1531,22 @@ export function createMartinMcpServer(serverInfo) {
                     });
                 }
                 const output = await runLoopTool(input);
-                return createToolSuccessResult(output, `Run ${output.loopId} is ${output.status}/${output.lifecycleState} after ${output.attempts} attempt(s); spend ${output.costUsd.toFixed(2)} USD.`);
+                return createToolSuccessResult(output, [
+                    `Run ${output.loopId} is ${output.status}/${output.lifecycleState}`,
+                    `after ${output.attempts} attempt(s); recorded cost ${output.costUsd.toFixed(2)} USD (${describeCostProvenance(output.costProvenance)}).`,
+                    `Execution mode: ${output.executionMode}; governance claim eligible:`,
+                    `${output.governanceClaimEligible ? "yes" : "no"}.`
+                ].join(" "));
             }
             if (name === "martin_inspect") {
                 const input = validateToolInput("martin_inspect", args);
                 const output = await inspectLoopTool(input);
-                return createToolSuccessResult(output, `Inspected ${output.loopCount} run(s) from ${output.source}; total actual spend ${output.portfolio.totalActualUsd.toFixed(2)} USD.`);
+                return createToolSuccessResult(output, `Inspected ${output.loopCount} run(s) from ${output.source}; total recorded cost ${output.portfolio.totalActualUsd.toFixed(2)} USD.`);
             }
             if (name === "martin_status") {
                 const input = validateToolInput("martin_status", args);
                 const output = await getStatusTool(input);
-                return createToolSuccessResult(output, `Loop ${output.loopId} is ${output.status}/${output.lifecycleState}; pressure is ${output.pressure} with ${output.remainingBudgetUsd.toFixed(2)} USD remaining.`);
+                return createToolSuccessResult(output, `Loop ${output.loopId} is ${output.status}/${output.lifecycleState}; recorded cost is ${output.costUsd.toFixed(2)} USD (${describeCostProvenance(output.costProvenance)}), and pressure is ${output.pressure} with ${output.remainingBudgetUsd.toFixed(2)} USD remaining.`);
             }
             if (name === "martin_doctor") {
                 const input = validateToolInput("martin_doctor", args);
@@ -1518,7 +1557,7 @@ export function createMartinMcpServer(serverInfo) {
                     workingDirectory: output.environment.workingDirectory,
                     engine: input.engine,
                     receiptScope: output.receiptScope
-                });
+                }).catch(() => { });
                 return createToolSuccessResult(output, output.summary);
             }
             if (name === "martin_plan") {
@@ -1535,7 +1574,7 @@ export function createMartinMcpServer(serverInfo) {
                         repoRoot: output.workingDirectory,
                         runsRoot: resolveRunsRoot(process.env)
                     }
-                });
+                }).catch(() => { });
                 return createToolSuccessResult(output, `Plan ready for ${output.objective} with ${output.risk.level} risk and ${output.approvalRecommendation.replace(/_/gu, " ")} approval.`);
             }
             if (name === "martin_preflight") {
@@ -1553,7 +1592,7 @@ export function createMartinMcpServer(serverInfo) {
                         allowedPaths: output.normalized.allowedPaths,
                         deniedPaths: output.normalized.deniedPaths,
                         budget: output.normalized.budget
-                    });
+                    }).catch(() => { });
                 }
                 return createToolSuccessResult(output, output.summary);
             }
@@ -1640,8 +1679,8 @@ export function createMartinMcpServer(serverInfo) {
                 const engine = input.engine ?? "claude";
                 const budgetUsd = input.budgetUsd ?? 5;
                 const fileScope = input.fileScope ?? [];
-                const workingDirectory = resolveSafeRepoRoot();
                 const runsRoot = resolveRunsRoot(process.env);
+                const workingDirectory = input.workingDirectory ?? resolveSafeRepoRoot();
                 const route = classifyRoute({
                     objective,
                     verificationPlan: [],
@@ -1665,17 +1704,22 @@ export function createMartinMcpServer(serverInfo) {
                     compressed: route.compressed,
                     ...(route.compressionSummary ? { compressionSummary: route.compressionSummary } : {}),
                     recommendedBudgetUsd,
-                    recommendedModelTier: route.recommendedModelTier,
-                    estimatedSavingVsSonnetUsd: route.estimatedSavingVsSonnetUsd
+                    modelAuthority: "agent_or_provider_default"
                 };
                 await recordMcpWorkflowStep({
                     runsRoot,
                     step: "estimate",
                     workingDirectory,
                     objective,
-                    engine
-                });
-                return createToolSuccessResult(output, `Estimate: ${route.selectedMode} route (${route.recommendedModelTier}), ~$${route.expectedCostUsd.toFixed(2)} expected cost, ${route.expectedPreworkBurnPct}% pre-work burn. Recommended budget: $${recommendedBudgetUsd.toFixed(2)}.`);
+                    engine,
+                    receiptScope: {
+                        invocationRoot: resolveSafeRepoRoot(),
+                        workingDirectory,
+                        repoRoot: workingDirectory,
+                        runsRoot
+                    }
+                }).catch(() => { });
+                return createToolSuccessResult(output, `Estimate: ${route.selectedMode} route, ~$${route.expectedCostUsd.toFixed(2)} expected cost, ${route.expectedPreworkBurnPct}% pre-work burn. Model authority remains with the agent/provider. Recommended budget: $${recommendedBudgetUsd.toFixed(2)}.`);
             }
             return createToolErrorResult(toToolFailure(new Error(`Unknown tool: ${name}`)));
         }
@@ -1698,6 +1742,114 @@ export async function connectMartinMcpStdioServer() {
     await server.connect(transport);
     return server;
 }
+export function parseMartinMcpServerArgs(argv) {
+    let transport = "stdio";
+    let host = "127.0.0.1";
+    let port = 3033;
+    let path = "/mcp";
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "--http") {
+            transport = "http";
+            continue;
+        }
+        if (token === "--port") {
+            const next = argv[index + 1];
+            const parsed = Number(next);
+            if (!Number.isInteger(parsed) || parsed < 0 || parsed > 65535) {
+                throw new Error(`Invalid --port value '${next ?? ""}'.`);
+            }
+            port = parsed;
+            index += 1;
+            continue;
+        }
+        if (token === "--host") {
+            const next = argv[index + 1];
+            if (!next) {
+                throw new Error("Missing value for --host.");
+            }
+            host = next;
+            index += 1;
+            continue;
+        }
+        if (token === "--path") {
+            const next = argv[index + 1];
+            if (!next || !next.startsWith("/")) {
+                throw new Error("MCP HTTP path must start with '/'.");
+            }
+            path = next;
+            index += 1;
+        }
+    }
+    return transport === "http"
+        ? { transport, host, port, path }
+        : { transport };
+}
+export async function connectMartinMcpHttpServer(options = {}) {
+    const host = options.host ?? "127.0.0.1";
+    const port = options.port ?? 3033;
+    const path = options.path ?? "/mcp";
+    const mcpServer = createMartinMcpServer();
+    const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: undefined
+    });
+    await mcpServer.connect(transport);
+    const httpServer = createHttpServer(async (req, res) => {
+        try {
+            const requestUrl = new URL(req.url ?? "/", `http://${req.headers.host ?? `${host}:${port}`}`);
+            if (requestUrl.pathname !== path) {
+                res.statusCode = 404;
+                res.setHeader("content-type", "application/json");
+                res.end(JSON.stringify({ error: "not_found", path: requestUrl.pathname }));
+                return;
+            }
+            if (req.method === "POST") {
+                const parsedBody = await readJsonBody(req, res);
+                if (res.writableEnded) {
+                    return;
+                }
+                await transport.handleRequest(req, res, parsedBody);
+                return;
+            }
+            if (req.method === "GET" || req.method === "DELETE") {
+                await transport.handleRequest(req, res);
+                return;
+            }
+            res.statusCode = 405;
+            res.setHeader("allow", "GET, POST, DELETE");
+            res.end();
+        }
+        catch (error) {
+            if (!res.headersSent) {
+                res.statusCode = 500;
+                res.setHeader("content-type", "application/json");
+                res.end(JSON.stringify({ error: "internal_error", message: error.message }));
+            }
+        }
+    });
+    await new Promise((resolve, reject) => {
+        httpServer.once("error", reject);
+        httpServer.listen(port, host, () => {
+            httpServer.off("error", reject);
+            resolve();
+        });
+    });
+    const address = httpServer.address();
+    const resolvedPort = typeof address === "object" && address ? address.port : port;
+    return {
+        server: httpServer,
+        host,
+        port: resolvedPort,
+        path,
+        endpoint: `http://${host}:${resolvedPort}${path}`,
+        close: async () => {
+            await transport.close();
+            await new Promise((resolve) => {
+                httpServer.close(() => resolve());
+            });
+        }
+    };
+}
 export function isDirectExecutionEntry(entryPath, moduleUrl = import.meta.url) {
     if (typeof entryPath !== "string" || entryPath.length === 0) {
         return false;
@@ -1718,5 +1870,30 @@ function realPathOrResolved(filePath) {
     }
 }
 if (isDirectExecution()) {
-    await connectMartinMcpStdioServer();
+    const startup = parseMartinMcpServerArgs(process.argv.slice(2));
+    if (startup.transport === "http") {
+        await connectMartinMcpHttpServer(startup);
+    }
+    else {
+        await connectMartinMcpStdioServer();
+    }
+}
+async function readJsonBody(req, res) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const raw = Buffer.concat(chunks).toString("utf8").trim();
+    if (!raw) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        res.statusCode = 400;
+        res.setHeader("content-type", "application/json");
+        res.end(JSON.stringify({ error: "invalid_json" }));
+        return undefined;
+    }
 }

package/dist/tools/doctor.js

@@ -115,10 +115,11 @@ export async function martinDoctorTool(input) {
                 ...(gemini.resolvedPath ? { resolvedPath: gemini.resolvedPath } : {})
             },
             openai: {
-                available: Boolean(process.env.MARTIN_OPENAI_API_KEY),
-                detail: process.env.MARTIN_OPENAI_API_KEY
-                    ? `OpenAI-compatible endpoint configured (model: ${process.env.MARTIN_OPENAI_MODEL ?? "gpt-4.1-mini"})`
-                    : "Set MARTIN_OPENAI_API_KEY and optionally MARTIN_OPENAI_BASE_URL + MARTIN_OPENAI_MODEL to enable."
+                available: Boolean(process.env.MARTIN_OPENAI_MODEL &&
+                    (process.env.MARTIN_OPENAI_API_KEY || process.env.MARTIN_OPENAI_BASE_URL)),
+                detail: process.env.MARTIN_OPENAI_MODEL
+                    ? `OpenAI-compatible model configured: ${process.env.MARTIN_OPENAI_MODEL}.`
+                    : "MODEL_CONFIGURATION_REQUIRED: set MARTIN_OPENAI_MODEL and the endpoint/auth required by your provider."
             }
         },
         ...(input.engine ? { requestedEngine: input.engine } : {}),

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

@@ -1,3 +1,4 @@
+import type { CostProvenance } from "../vendor/contracts/index.js";
 import { type LoopPreview } from "./tool-support.js";
 export interface GetStatusInput {
     /** JSON-serialized LoopRecord. */
@@ -18,6 +19,7 @@ export interface GetStatusOutput {
     lifecycleState: string;
     attempts: number;
     costUsd: number;
+    costProvenance: CostProvenance;
     avoidedUsd: number;
     pressure: string;
     shouldStop: boolean;

package/dist/tools/get-status.js

@@ -31,6 +31,7 @@ export async function getStatusTool(input) {
         lifecycleState: loop.lifecycleState,
         attempts: loop.attempts.length,
         costUsd: loop.cost.actualUsd,
+        costProvenance: loop.cost.provenance ?? "unavailable",
         avoidedUsd: loop.cost.avoidedUsd ?? 0,
         pressure: costState.pressure,
         shouldStop: costState.shouldStop,

package/dist/tools/preflight.d.ts

@@ -1,4 +1,5 @@
 import { type CodexHostPlatform } from "../vendor/adapters/index.js";
+import type { UpdateAvailableField } from "../vendor/contracts/index.js";
 import { type MartinEngine } from "./tool-support.js";
 import { buildPolicyPackDefinition, type MartinPlanProposal, type MartinPolicyPack, type MartinRiskAssessment, type MartinRunContract } from "./workflow-governance.js";
 export interface MartinPreflightInput {
@@ -108,5 +109,6 @@ export interface MartinPreflightOutput {
     risk: MartinRiskAssessment;
     runContract: MartinRunContract;
     plan: MartinPlanProposal;
+    updateAvailable?: UpdateAvailableField;
 }
 export declare function martinPreflightTool(input: MartinPreflightInput): Promise<MartinPreflightOutput>;

package/dist/tools/preflight.js

@@ -1,9 +1,13 @@
 import { probeCodexLaunch, resolveCliCommandAvailability } from "../vendor/adapters/index.js";
-import { resolveRunsRoot } from "../vendor/core/index.js";
+import { fetchSelectedMessage, getMcpInstalledVersion, isCooldownExpired, isDismissed, isNewerVersion, loadDeliveryRecord, recordShown, resolveDefaultLedgerPath, resolveRunsRoot, saveDeliveryRecord, } from "../vendor/core/index.js";
+import { MARTIN_MCP_PACKAGE_VERSION } from "../package-version.js";
 import { resolveSafeRepoRoot } from "../server-validation.js";
 import { createSkippedCliAvailability, formatUsd, getEngineAvailability, resolveExecutionMode } from "./tool-support.js";
 import { buildPlanProposal, normalizeLoopBudget, buildRunContract, buildPolicyPackDefinition, inspectRepoSignals } from "./workflow-governance.js";
 export async function martinPreflightTool(input) {
+    // Fire delivery fetch early so it races with the rest of preflight work.
+    const mcpVersion = getMcpInstalledVersion() ?? MARTIN_MCP_PACKAGE_VERSION;
+    const deliveryFetchPromise = fetchSelectedMessage({ clientVersion: mcpVersion, clientKind: "mcp", trigger: "version_check" }, { timeoutMs: 3_000 }).catch(() => null);
     const executionMode = resolveExecutionMode();
     const workspaceRoot = resolveSafeRepoRoot();
     const workingDirectory = resolveSafeRepoRoot(input.workingDirectory);
@@ -32,7 +36,7 @@ export async function martinPreflightTool(input) {
         maxTokens: input.maxTokens
     });
     if (!executionMode.liveMode) {
-        warnings.push("Proof mode is active; preflight only proves configuration shape, not live CLI readiness.");
+        warnings.push("Verification-only mode is active; it cannot emit governed VERIFIED or prove live CLI readiness.");
     }
     else if (!engineAvailability.available) {
         warnings.push(`Requested engine '${engine}' is not available on PATH.`);
@@ -140,6 +144,42 @@ export async function martinPreflightTool(input) {
         policy,
         risk: runContract.risk,
         runContract,
-        plan
+        plan,
+        ...await resolvePreflightUpdateAvailable(deliveryFetchPromise, mcpVersion)
     };
 }
+async function resolvePreflightUpdateAvailable(fetchPromise, currentVersion) {
+    try {
+        const message = await fetchPromise;
+        if (!message)
+            return {};
+        if (message.action.type !== "upgrade_mcp")
+            return {};
+        const targetVersion = message.action.targetVersion;
+        if (!targetVersion)
+            return {};
+        if (!isNewerVersion(currentVersion, targetVersion))
+            return {};
+        const ledgerPath = resolveDefaultLedgerPath();
+        const record = loadDeliveryRecord(ledgerPath);
+        const nowMs = Date.now();
+        if (!isCooldownExpired(record, nowMs))
+            return {};
+        if (isDismissed(record, message.id))
+            return {};
+        try {
+            saveDeliveryRecord(ledgerPath, recordShown(record, message, nowMs));
+        }
+        catch { /* ledger write failure must not surface */ }
+        return {
+            updateAvailable: {
+                targetVersion,
+                kind: "mcp",
+                message: message.body
+            }
+        };
+    }
+    catch {
+        return {};
+    }
+}

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

@@ -2,7 +2,7 @@ import { buildArtifactSummary, buildBudgetSnapshot, buildCostSnapshot, buildEven
 import { readRunControlState } from "./run-controls.js";
 import { martinEvalTool } from "./eval.js";
 import { assessRunRisk } from "./workflow-governance.js";
-import type { ReceiptIntegritySummary, ReceiptScope } from "../vendor/contracts/index.js";
+import type { ReceiptIntegritySummary, ReceiptScope, TerminationEnvelopeV1, VerifiedHandoffV1 } from "../vendor/contracts/index.js";
 export interface MartinRunDossierInput {
     file?: string;
     loopId?: string;
@@ -45,6 +45,8 @@ export interface MartinRunDossierOutput {
     };
     evaluation: Awaited<ReturnType<typeof martinEvalTool>>;
     control: Awaited<ReturnType<typeof readRunControlState>>;
+    terminationEnvelope?: TerminationEnvelopeV1;
+    verifiedHandoff: VerifiedHandoffV1;
     format: "json" | "md" | "github-pr";
     rendered?: string;
     inspection: {

package/dist/tools/run-dossier.js

@@ -4,6 +4,7 @@ import { loadDetailedLoopRecord, readAttemptArtifactFiles, readLedgerEvents } fr
 import { readRunControlState } from "./run-controls.js";
 import { martinEvalTool } from "./eval.js";
 import { assessRunRisk, inspectRepoSignals } from "./workflow-governance.js";
+import { buildVerifiedHandoff } from "../vendor/core/index.js";
 export async function martinRunDossierTool(input) {
     const detail = await loadDetailedLoopRecord(input);
     const ledgerEvents = await readLedgerEvents(detail);
@@ -54,6 +55,7 @@ export async function martinRunDossierTool(input) {
         cost: buildCostSnapshot(detail.loop.cost),
         receiptIntegrity: resolveReceiptIntegrity(detail.loop),
         ...(detail.loop.receiptScope ? { receiptScope: detail.loop.receiptScope } : {}),
+        ...(detail.loop.terminationEnvelope ? { terminationEnvelope: detail.loop.terminationEnvelope } : {}),
         attempts,
         verification,
         artifacts: buildArtifactSummary(detail.loop),
@@ -72,7 +74,37 @@ export async function martinRunDossierTool(input) {
             ...(detail.canonicalLoopRecordPath ? { canonicalLoopRecordPath: detail.canonicalLoopRecordPath } : {}),
             ...(detail.ledgerPath ? { ledgerPath: detail.ledgerPath } : {})
         },
-        warnings: [...detail.warnings, ...verification.warnings]
+        warnings: [...detail.warnings, ...verification.warnings],
+        verifiedHandoff: buildVerifiedHandoff({
+            loop: detail.loop,
+            receiptIntegrity: resolveReceiptIntegrity(detail.loop),
+            verification: {
+                status: verification.status,
+                summary: verification.summary ?? "No verification summary recorded.",
+                steps: [],
+                warnings: verification.warnings,
+            },
+            scope: {
+                status: detail.loop.task?.allowedPaths?.length ||
+                    detail.loop.task?.deniedPaths?.length
+                    ? "WITHIN_SCOPE"
+                    : "NOT_EVALUATED",
+                allowedPaths: detail.loop.task?.allowedPaths ?? [],
+                deniedPaths: detail.loop.task?.deniedPaths ?? [],
+                changedFiles: [],
+                violations: [],
+            },
+            testIntegrity: {
+                status: "NOT_EVALUATED",
+                verdict: "NOT_EVALUATED",
+                protectedPaths: [],
+                changedProtectedPaths: [],
+                findings: [],
+                summary: "Automatic test-integrity evidence was not recorded for this run.",
+            },
+            unresolvedWork: verification.status === "passed" ? [] : [verification.summary ?? "Verification did not pass."],
+            nextAction: review.nextAction,
+        }),
     };
     if (output.format !== "json") {
         output.rendered = renderDossier(output);
@@ -81,7 +113,13 @@ export async function martinRunDossierTool(input) {
 }
 function renderDossier(output) {
     const lines = [
-        output.format === "github-pr" ? "## MartinLoop Run Dossier" : "# MartinLoop Run Dossier",
+        output.format === "github-pr" ? "## MartinLoop Verified Handoff" : "# MartinLoop Verified Handoff",
+        "",
+        `Outcome: ${output.verifiedHandoff.outcome}`,
+        `Definition of Done: ${output.verifiedHandoff.definitionOfDone.acceptanceCriteria.length} acceptance criterion/criteria`,
+        `Verification: ${output.verifiedHandoff.verification.status}`,
+        `Scope: ${output.verifiedHandoff.scope.status}`,
+        `Test Integrity: ${output.verifiedHandoff.testIntegrity.verdict}`,
         "",
         `Objective: ${output.loop.objective}`,
         `Run: ${output.loop.loopId}`,

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

@@ -1,6 +1,6 @@
 import { type SpawnLike } from "../vendor/adapters/index.js";
-import { type RunStore, type RunMartinInput, type RunMartinResult } from "../vendor/core/index.js";
-import type { LoopBudget, ReceiptScope } from "../vendor/contracts/index.js";
+import { type RunStore } from "../vendor/core/index.js";
+import type { CostProvenance, ExecutionMode, LoopBudget, ReceiptScope } from "../vendor/contracts/index.js";
 import { buildArtifactSummary, buildVerificationSummary, buildLoopPreview, type MartinEngine } from "./tool-support.js";
 export interface RunLoopInput {
     objective: string;
@@ -23,7 +23,10 @@ export interface RunLoopOutput {
     reason: string;
     attempts: number;
     costUsd: number;
+    costProvenance: CostProvenance;
     verificationPassed: boolean;
+    executionMode: ExecutionMode;
+    governanceClaimEligible: boolean;
     loopId: string;
     pressure: string;
     shouldStop: boolean;
@@ -46,5 +49,4 @@ export interface RunLoopOutput {
 }
 export declare function __setProofModeVerifierSpawnImplForTests(spawnImpl?: SpawnLike): void;
 export declare function __setRunStoreOverrideForTests(store?: RunStore): void;
-export declare function __setRunMartinImplForTests(impl?: (input: RunMartinInput) => Promise<RunMartinResult>): void;
 export declare function runLoopTool(input: RunLoopInput): Promise<RunLoopOutput>;