@martinloop/mcp 0.5.5 → 0.5.7

package/dist/server.js

@@ -26,6 +26,9 @@ 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 { MARTIN_ARCADE_FALLBACK_TEXT, MARTIN_ARCADE_MIME_TYPE, MARTIN_ARCADE_RESOURCE_URI, MARTIN_ARCADE_UI_EXTENSION_ID, buildArcadeToolDefinitions, supportsMartinArcadeApp } from "./arcade/capabilities.js";
+import { listArcadeResources, readArcadeResource } from "./arcade/resource.js";
+import { readArcadeStatus } from "./arcade/status.js";
 import { getMartinPrompt, listMartinPrompts } from "./prompts.js";
 import { listMartinResources, listMartinResourceTemplates, readMartinResource } from "./resources.js";
 import { martinDoctorTool } from "./tools/doctor.js";
@@ -56,15 +59,6 @@ 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,
@@ -78,10 +72,6 @@ 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" },
@@ -101,13 +91,11 @@ const loopPreviewSchema = {
         "lifecycleState",
         "attempts",
         "costUsd",
-        "costProvenance",
         "avoidedUsd",
         "pressure",
         "shouldStop",
         "remainingBudgetUsd",
-        "remainingIterations",
-        "remainingTokens"
+        "remainingIterations"
     ]
 };
 const budgetSchema = {
@@ -119,7 +107,7 @@ const budgetSchema = {
         maxIterations: { type: "integer" },
         maxTokens: { type: "integer" }
     },
-    required: ["maxUsd", "softLimitUsd", "maxIterations", "maxTokens"]
+    required: ["maxUsd", "softLimitUsd", "maxIterations"]
 };
 const costSchema = {
     type: "object",
@@ -267,10 +255,6 @@ 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" },
@@ -302,14 +286,12 @@ const runOutputSchema = {
         "reason",
         "attempts",
         "costUsd",
-        "costProvenance",
         "verificationPassed",
         "loopId",
         "pressure",
         "shouldStop",
         "remainingBudgetUsd",
         "remainingIterations",
-        "remainingTokens",
         "engine",
         "workingDirectory",
         "budget",
@@ -370,10 +352,6 @@ 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" },
@@ -397,13 +375,11 @@ const statusOutputSchema = {
         "lifecycleState",
         "attempts",
         "costUsd",
-        "costProvenance",
         "avoidedUsd",
         "pressure",
         "shouldStop",
         "remainingBudgetUsd",
         "remainingIterations",
-        "remainingTokens",
         "budget",
         "inspection"
     ]
@@ -725,29 +701,157 @@ const planOutputSchema = {
 };
 const logsOutputSchema = {
     type: "object",
-    additionalProperties: true
+    additionalProperties: false,
+    properties: {
+        source: { type: "string", description: "Resolved path to the loop-record source file." },
+        sourceKind: {
+            type: "string",
+            enum: ["file", "loop_id", "latest", "runs_root"],
+            description: "How the run was identified: by file path, loop ID, latest flag, or runs directory."
+        },
+        loopId: { type: "string", description: "Unique MartinLoop run identifier." },
+        logCount: { type: "integer", description: "Number of log entries returned after applying the limit." },
+        live: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                lifecycleState: { type: "string", description: "Current run lifecycle state (e.g. running, completed, cancelled)." },
+                pauseState: {
+                    type: "string",
+                    enum: ["active", "paused", "cancellation_requested"],
+                    description: "Whether the run is active, paused, or has a pending cancellation."
+                },
+                approvalState: {
+                    type: "string",
+                    enum: ["not_required", "resume_requested"],
+                    description: "Whether the run is waiting at a human-approval checkpoint."
+                }
+            },
+            required: ["lifecycleState", "pauseState", "approvalState"]
+        },
+        entries: {
+            type: "array",
+            description: "Log entries sorted by timestamp descending, capped at limit.",
+            items: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    timestamp: { type: "string", description: "ISO 8601 timestamp of the event, if present." },
+                    source: {
+                        type: "string",
+                        enum: ["event", "ledger", "control"],
+                        description: "Origin stream: loop event bus, governance ledger, or operator control receipts."
+                    },
+                    kind: { type: "string", description: "Event type or control action name." },
+                    payload: { type: "object", additionalProperties: true, description: "Event-specific payload data." }
+                },
+                required: ["source", "kind", "payload"]
+            }
+        }
+    },
+    required: ["source", "sourceKind", "loopId", "logCount", "live", "entries"]
 };
 const controlOutputSchema = {
     type: "object",
-    additionalProperties: true
+    additionalProperties: false,
+    properties: {
+        loopId: { type: "string", description: "MartinLoop run identifier the control was applied to." },
+        action: {
+            type: "string",
+            enum: ["pause", "cancel", "continue"],
+            description: "The control action that was recorded."
+        },
+        controlId: { type: "string", description: "Unique receipt ID for this control action." },
+        requestedAt: { type: "string", description: "ISO 8601 timestamp when the control was recorded." },
+        requestedBy: { type: "string", description: "Identity that requested the control, if provided." },
+        reason: { type: "string", description: "Human-readable reason for the control, if provided." }
+    },
+    required: ["loopId", "action", "controlId", "requestedAt"]
 };
 const evalOutputSchema = {
     type: "object",
-    additionalProperties: true
+    additionalProperties: false,
+    properties: {
+        source: { type: "string", description: "Resolved path to the loop-record source file." },
+        sourceKind: {
+            type: "string",
+            enum: ["file", "loop_id", "latest", "runs_root"],
+            description: "How the run was identified."
+        },
+        loopId: { type: "string", description: "Unique MartinLoop run identifier." },
+        score: { type: "number", description: "Numeric evaluation score from 0–100." },
+        grade: {
+            type: "string",
+            enum: ["mergeable", "mergeable_with_review", "needs_review", "blocked", "insufficient_evidence"],
+            description: "Overall merge readiness grade derived from the six check dimensions."
+        },
+        checks: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                taskCompletion: { type: "string", enum: ["passed", "warning", "failed"], description: "Whether the run reached a completed status." },
+                verifier: { type: "string", enum: ["passed", "warning", "failed"], description: "Whether automated verifiers passed." },
+                diffDiscipline: { type: "string", enum: ["passed", "warning", "failed"], description: "Whether file-scope discipline was maintained." },
+                regressionRisk: { type: "string", enum: ["passed", "warning", "failed"], description: "Whether regression risk signals were detected." },
+                securityRisk: { type: "string", enum: ["passed", "warning", "failed"], description: "Whether security risk signals were detected." },
+                reviewability: { type: "string", enum: ["passed", "warning", "failed"], description: "Whether the PR body and dossier are reviewer-ready." }
+            },
+            required: ["taskCompletion", "verifier", "diffDiscipline", "regressionRisk", "securityRisk", "reviewability"]
+        },
+        warnings: { type: "array", items: { type: "string" }, description: "Non-blocking advisory warnings from the evaluation." },
+        summary: { type: "string", description: "One-paragraph plain-English evaluation summary." }
+    },
+    required: ["source", "sourceKind", "loopId", "score", "grade", "checks", "warnings", "summary"]
 };
 const prSummaryOutputSchema = {
     type: "object",
-    additionalProperties: true
+    additionalProperties: false,
+    properties: {
+        loopId: { type: "string", description: "MartinLoop run identifier used to generate the summary." },
+        title: { type: "string", description: "Suggested GitHub pull-request title." },
+        body: { type: "string", description: "GitHub-flavoured Markdown PR body containing the run dossier." },
+        grade: {
+            type: "string",
+            enum: ["mergeable", "mergeable_with_review", "needs_review", "blocked", "insufficient_evidence"],
+            description: "Verification grade assigned to the run."
+        },
+        score: { type: "number", description: "Numeric verification score from 0–100." }
+    },
+    required: ["loopId", "title", "body", "grade", "score"]
 };
 const prReviewOutputSchema = {
     type: "object",
-    additionalProperties: true
+    additionalProperties: false,
+    properties: {
+        loopId: { type: "string", description: "MartinLoop run identifier the review was performed against." },
+        verdict: {
+            type: "string",
+            enum: ["approve_with_review", "needs_changes", "blocked"],
+            description: "Merge verdict: approve_with_review means safe to merge with human review; needs_changes requires fixes; blocked means do not merge."
+        },
+        findings: {
+            type: "array",
+            items: { type: "string" },
+            description: "Specific findings that informed the verdict."
+        },
+        summary: { type: "string", description: "Plain-English review summary." }
+    },
+    required: ["loopId", "verdict", "findings", "summary"]
 };
 export function createMartinMcpServer(serverInfo) {
     const server = new Server({
         name: serverInfo?.name ?? "martin-loop",
         version: serverInfo?.version ?? MARTIN_MCP_PACKAGE_VERSION
-    }, { capabilities: { tools: {}, resources: {}, prompts: {} } });
+    }, {
+        capabilities: {
+            tools: {},
+            resources: {},
+            prompts: {},
+            extensions: {
+                [MARTIN_ARCADE_UI_EXTENSION_ID]: { mimeTypes: [MARTIN_ARCADE_MIME_TYPE] }
+            }
+        }
+    });
     server.setRequestHandler(ListToolsRequestSchema, () => ({
         tools: [
             {
@@ -1046,20 +1150,26 @@ export function createMartinMcpServer(serverInfo) {
             },
             {
                 name: "martin_logs",
-                description: "Read recent Martin loop events, ledger entries, and operator control receipts for live observability.",
+                description: "Read recent MartinLoop events, ledger entries, and operator control receipts for a single run. " +
+                    "Use to observe live or completed run activity, diagnose stuck or failed runs, or audit operator actions. " +
+                    "Do not use to check run completion status — use martin_get_status instead. " +
+                    "Do not use to retrieve verification evidence — use martin_get_verification_results instead. " +
+                    "This tool only reads persisted run files and does not execute commands, modify state, or contact GitHub.",
                 annotations: {
                     readOnlyHint: true,
-                    idempotentHint: true
+                    destructiveHint: false,
+                    idempotentHint: true,
+                    openWorldHint: false
                 },
                 inputSchema: {
                     type: "object",
                     additionalProperties: false,
                     properties: {
-                        file: { type: "string" },
-                        loopId: { type: "string" },
-                        runsDir: { type: "string" },
-                        latest: { const: true },
-                        limit: { type: "integer", minimum: 1 }
+                        file: { type: "string", description: "Absolute or relative path to a loop-record.json file or run directory. Mutually exclusive with loopId and latest." },
+                        loopId: { type: "string", description: "MartinLoop run identifier from the run store. Mutually exclusive with file and latest." },
+                        runsDir: { type: "string", description: "Override the default run-store root directory. Optional; defaults to the MartinLoop runs directory." },
+                        latest: { const: true, description: "When true, loads the most recently updated run in the run store. Mutually exclusive with file and loopId." },
+                        limit: { type: "integer", minimum: 1, description: "Maximum number of log entries to return, sorted by timestamp descending. Defaults to 20." }
                     },
                     oneOf: [{ required: ["file"] }, { required: ["loopId"] }, { required: ["latest"] }]
                 },
@@ -1255,10 +1365,16 @@ export function createMartinMcpServer(serverInfo) {
             },
             {
                 name: "martin_get_verification_results",
-                description: "Load verification evidence for a Martin run from stored loop events and ledger entries.",
+                description: "Load structured verification evidence for a MartinLoop run — verifier commands, pass/fail outcomes, and contradiction signals — from stored loop events and ledger entries. " +
+                    "Use after a run completes to confirm whether automated verifiers passed before merging or promoting the result. " +
+                    "Do not use to get a merge-readiness grade — use martin_eval for a scored grade with six check dimensions. " +
+                    "Do not use for live run status — use martin_get_status instead. " +
+                    "This tool only reads persisted run files and does not execute commands, modify state, or contact GitHub.",
                 annotations: {
                     readOnlyHint: true,
-                    idempotentHint: true
+                    destructiveHint: false,
+                    idempotentHint: true,
+                    openWorldHint: false
                 },
                 inputSchema: {
                     type: "object",
@@ -1266,10 +1382,10 @@ export function createMartinMcpServer(serverInfo) {
                     properties: {
                         file: {
                             type: "string",
-                            description: "Path to a canonical loop-record.json file or run directory."
+                            description: "Absolute or relative path to a loop-record.json file or run directory. Mutually exclusive with loopId."
                         },
-                        loopId: { type: "string", description: "Loop ID under the run store." },
-                        runsDir: { type: "string", description: "Optional runs-root override." }
+                        loopId: { type: "string", description: "MartinLoop run identifier from the run store. Mutually exclusive with file." },
+                        runsDir: { type: "string", description: "Override the default run-store root directory. Optional." }
                     },
                     oneOf: [{ required: ["file"] }, { required: ["loopId"] }]
                 },
@@ -1328,19 +1444,26 @@ export function createMartinMcpServer(serverInfo) {
             },
             {
                 name: "martin_eval",
-                description: "Grade a Martin run for task completion, verifier health, diff discipline, risk, and reviewability.",
+                description: "Grade a MartinLoop run across six dimensions — task completion, verifier health, diff discipline, regression risk, security risk, and reviewability — and return a scored merge-readiness verdict. " +
+                    "Use after a governed run completes to decide whether the result is safe to merge or promote. " +
+                    "Use before martin_pr_summary or martin_create_pr to confirm the run is merge-ready. " +
+                    "Do not use to retrieve raw verification command output — use martin_get_verification_results for that. " +
+                    "Do not use to review an existing PR body — use martin_review_pr instead. " +
+                    "This tool reads saved run evidence and inspects local git signals; it does not modify state or contact GitHub.",
                 annotations: {
                     readOnlyHint: true,
-                    idempotentHint: true
+                    destructiveHint: false,
+                    idempotentHint: true,
+                    openWorldHint: false
                 },
                 inputSchema: {
                     type: "object",
                     additionalProperties: false,
                     properties: {
-                        file: { type: "string" },
-                        loopId: { type: "string" },
-                        runsDir: { type: "string" },
-                        latest: { const: true }
+                        file: { type: "string", description: "Absolute or relative path to a loop-record.json file or run directory. Mutually exclusive with loopId and latest." },
+                        loopId: { type: "string", description: "MartinLoop run identifier from the run store. Mutually exclusive with file and latest." },
+                        runsDir: { type: "string", description: "Override the default run-store root directory. Optional." },
+                        latest: { const: true, description: "When true, evaluates the most recently updated run in the run store. Mutually exclusive with file and loopId." }
                     },
                     oneOf: [{ required: ["file"] }, { required: ["loopId"] }, { required: ["latest"] }]
                 },
@@ -1348,20 +1471,27 @@ export function createMartinMcpServer(serverInfo) {
             },
             {
                 name: "martin_pr_summary",
-                description: "Generate a PR title and body with a MartinLoop dossier block for a completed run.",
+                description: "Generate a GitHub-ready pull-request title and Markdown body from a completed MartinLoop run dossier, including its verification grade and score. " +
+                    "Use after a governed run completes when you need PR copy without creating the PR. " +
+                    "Use martin_create_pr instead to actually open the PR on GitHub. " +
+                    "Use martin_review_pr to evaluate an existing PR body against run evidence. " +
+                    "Use martin_eval first if you need a merge-readiness grade before generating the PR body. " +
+                    "This tool only reads saved run evidence and does not modify the repository or contact GitHub.",
                 annotations: {
                     readOnlyHint: true,
-                    idempotentHint: true
+                    destructiveHint: false,
+                    idempotentHint: true,
+                    openWorldHint: false
                 },
                 inputSchema: {
                     type: "object",
                     additionalProperties: false,
                     properties: {
-                        file: { type: "string" },
-                        loopId: { type: "string" },
-                        runsDir: { type: "string" },
-                        latest: { const: true },
-                        format: { type: "string", enum: ["json", "md", "github-pr"] }
+                        file: { type: "string", description: "Absolute or relative path to a loop-record.json file or run directory. Mutually exclusive with loopId and latest." },
+                        loopId: { type: "string", description: "MartinLoop run identifier from the run store. Mutually exclusive with file and latest." },
+                        runsDir: { type: "string", description: "Override the default run-store root directory. Optional." },
+                        latest: { const: true, description: "When true, generates the summary for the most recently updated run. Mutually exclusive with file and loopId." },
+                        format: { type: "string", enum: ["json", "md", "github-pr"], description: "Dossier rendering format. Defaults to github-pr for PR body generation. Use md for plain Markdown or json for structured output." }
                     },
                     oneOf: [{ required: ["file"] }, { required: ["loopId"] }, { required: ["latest"] }]
                 },
@@ -1393,21 +1523,28 @@ export function createMartinMcpServer(serverInfo) {
             },
             {
                 name: "martin_review_pr",
-                description: "Review a PR or PR draft against the Martin dossier and evaluation evidence.",
+                description: "Review a PR body or draft against the MartinLoop run dossier and evaluation evidence, and return a verdict with specific findings. " +
+                    "Use when you have an existing PR body and want to check whether it accurately represents the governed run evidence. " +
+                    "Supply prBody to review a specific body string; omit it to evaluate the auto-generated dossier body. " +
+                    "Do not use to generate a PR body from scratch — use martin_pr_summary instead. " +
+                    "Do not use to open or create a PR — use martin_create_pr instead. " +
+                    "This tool only reads saved run evidence and does not modify the repository or contact GitHub.",
                 annotations: {
                     readOnlyHint: true,
-                    idempotentHint: true
+                    destructiveHint: false,
+                    idempotentHint: true,
+                    openWorldHint: false
                 },
                 inputSchema: {
                     type: "object",
                     additionalProperties: false,
                     properties: {
-                        file: { type: "string" },
-                        loopId: { type: "string" },
-                        runsDir: { type: "string" },
-                        latest: { const: true },
-                        format: { type: "string", enum: ["json", "md", "github-pr"] },
-                        prBody: { type: "string" }
+                        file: { type: "string", description: "Absolute or relative path to a loop-record.json file or run directory. Mutually exclusive with loopId and latest." },
+                        loopId: { type: "string", description: "MartinLoop run identifier from the run store. Mutually exclusive with file and latest." },
+                        runsDir: { type: "string", description: "Override the default run-store root directory. Optional." },
+                        latest: { const: true, description: "When true, reviews against the most recently updated run. Mutually exclusive with file and loopId." },
+                        format: { type: "string", enum: ["json", "md", "github-pr"], description: "Dossier format used when generating the reference body for comparison. Defaults to github-pr." },
+                        prBody: { type: "string", description: "The PR body text to review. If omitted, the auto-generated dossier body is evaluated instead." }
                     },
                     oneOf: [{ required: ["file"] }, { required: ["loopId"] }, { required: ["latest"] }]
                 },
@@ -1469,17 +1606,23 @@ export function createMartinMcpServer(serverInfo) {
                     },
                     required: ["objective", "engine", "budgetUsd", "selectedMode", "confidence", "expectedCostUsd", "expectedPreworkBurnPct", "reason"]
                 }
-            }
+            },
+            ...buildArcadeToolDefinitions(server.getClientCapabilities())
         ]
     }));
-    server.setRequestHandler(ListResourcesRequestSchema, () => ({
-        ...listMartinResources()
-    }));
+    server.setRequestHandler(ListResourcesRequestSchema, () => {
+        const listed = listMartinResources();
+        const arcade = listArcadeResources(server.getClientCapabilities());
+        return { resources: [...listed.resources, ...arcade.resources] };
+    });
     server.setRequestHandler(ListResourceTemplatesRequestSchema, () => ({
         ...listMartinResourceTemplates()
     }));
     server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
         try {
+            if (request.params.uri === MARTIN_ARCADE_RESOURCE_URI) {
+                return await readArcadeResource(request.params.uri);
+            }
             return await readMartinResource({ uri: request.params.uri });
         }
         catch (error) {
@@ -1509,6 +1652,29 @@ export function createMartinMcpServer(serverInfo) {
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const { name, arguments: args } = request.params;
         try {
+            if (name === "martin_arcade") {
+                const available = supportsMartinArcadeApp(server.getClientCapabilities());
+                return createToolSuccessResult({
+                    available,
+                    resourceUri: available ? MARTIN_ARCADE_RESOURCE_URI : null
+                }, MARTIN_ARCADE_FALLBACK_TEXT, { human: MARTIN_ARCADE_FALLBACK_TEXT });
+            }
+            if (name === "martin_arcade_status") {
+                const input = args ?? {};
+                if (!input || typeof input !== "object" || Array.isArray(input)) {
+                    throw new MartinToolError("invalid_arguments", "Arcade status input must be an object.", {
+                        category: "invalid_input"
+                    });
+                }
+                const keys = Object.keys(input);
+                if (keys.some((key) => key !== "loopId") || ("loopId" in input && typeof input.loopId !== "string")) {
+                    throw new MartinToolError("invalid_arguments", "Arcade status accepts only an optional loopId.", {
+                        category: "invalid_input"
+                    });
+                }
+                const output = await readArcadeStatus(input);
+                return createToolSuccessResult(output, `MartinLoop Arcade status for ${output.loopId}: ${output.displayOutcome ?? output.lifecycleState}.`);
+            }
             if (name === "martin_run") {
                 const input = validateToolInput("martin_run", args);
                 const runsRoot = resolveRunsRoot(process.env);
@@ -1544,7 +1710,7 @@ 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); recorded cost ${output.costUsd.toFixed(2)} USD (${describeCostProvenance(output.costProvenance)}).`,
+                    `after ${output.attempts} attempt(s); spend ${output.costUsd.toFixed(2)} USD.`,
                     `Execution mode: ${output.executionMode}; governance claim eligible:`,
                     `${output.governanceClaimEligible ? "yes" : "no"}.`
                 ].join(" "));
@@ -1552,12 +1718,12 @@ export function createMartinMcpServer(serverInfo) {
             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 recorded cost ${output.portfolio.totalActualUsd.toFixed(2)} USD.`);
+                return createToolSuccessResult(output, `Inspected ${output.loopCount} run(s) from ${output.source}; total actual spend ${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}; recorded cost is ${output.costUsd.toFixed(2)} USD (${describeCostProvenance(output.costProvenance)}), and pressure is ${output.pressure} with ${output.remainingBudgetUsd.toFixed(2)} USD remaining.`);
+                return createToolSuccessResult(output, `Loop ${output.loopId} is ${output.status}/${output.lifecycleState}; pressure is ${output.pressure} with ${output.remainingBudgetUsd.toFixed(2)} USD remaining.`);
             }
             if (name === "martin_doctor") {
                 const input = validateToolInput("martin_doctor", args);

package/dist/tools/execution-policy.js

@@ -5,7 +5,7 @@ export function compileMcpExecutionPolicy(input) {
         maxUsd: input.maxUsd ?? DEFAULT_BUDGET.maxUsd,
         softLimitUsd: Math.min(DEFAULT_BUDGET.softLimitUsd, input.maxUsd ?? DEFAULT_BUDGET.maxUsd),
         maxIterations: input.maxIterations ?? DEFAULT_BUDGET.maxIterations,
-        maxTokens: input.maxTokens ?? DEFAULT_BUDGET.maxTokens
+        ...(input.maxTokens !== undefined ? { maxTokens: input.maxTokens } : {})
     };
     const policy = compileExecutionPolicy({
         configPath: "mcp://inline",

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

@@ -1,4 +1,3 @@
-import type { CostProvenance } from "../vendor/contracts/index.js";
 import { type LoopPreview } from "./tool-support.js";
 export interface GetStatusInput {
     /** JSON-serialized LoopRecord. */
@@ -19,18 +18,17 @@ export interface GetStatusOutput {
     lifecycleState: string;
     attempts: number;
     costUsd: number;
-    costProvenance: CostProvenance;
     avoidedUsd: number;
     pressure: string;
     shouldStop: boolean;
     remainingBudgetUsd: number;
     remainingIterations: number;
-    remainingTokens: number;
+    remainingTokens?: number;
     budget: {
         maxUsd: number;
         softLimitUsd: number;
         maxIterations: number;
-        maxTokens: number;
+        maxTokens?: number;
     };
     inspection: {
         loop: LoopPreview;

package/dist/tools/get-status.js

@@ -31,18 +31,21 @@ 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,
         remainingBudgetUsd: costState.remainingBudgetUsd,
         remainingIterations: costState.remainingIterations,
-        remainingTokens: costState.remainingTokens,
+        ...(costState.remainingTokens !== undefined
+            ? { remainingTokens: costState.remainingTokens }
+            : {}),
         budget: {
             maxUsd: loop.budget.maxUsd,
             softLimitUsd: loop.budget.softLimitUsd,
             maxIterations: loop.budget.maxIterations,
-            maxTokens: loop.budget.maxTokens
+            ...(loop.budget.maxTokens !== undefined
+                ? { maxTokens: loop.budget.maxTokens }
+                : {})
         },
         inspection: {
             loop: buildLoopPreview(loop)

package/dist/tools/preflight.d.ts

@@ -51,7 +51,7 @@ export interface MartinPreflightOutput {
             maxUsd: number;
             softLimitUsd: number;
             maxIterations: number;
-            maxTokens: number;
+            maxTokens?: number;
         };
         verificationPlan: string[];
         allowedPaths?: string[];

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

@@ -1,6 +1,6 @@
 import { type SpawnLike } from "../vendor/adapters/index.js";
 import { type RunStore } from "../vendor/core/index.js";
-import type { CostProvenance, ExecutionMode, LoopBudget, ReceiptScope } from "../vendor/contracts/index.js";
+import type { ExecutionMode, LoopBudget, ReceiptScope } from "../vendor/contracts/index.js";
 import { buildArtifactSummary, buildVerificationSummary, buildLoopPreview, type MartinEngine } from "./tool-support.js";
 export interface RunLoopInput {
     objective: string;
@@ -24,7 +24,6 @@ export interface RunLoopOutput {
     reason: string;
     attempts: number;
     costUsd: number;
-    costProvenance: CostProvenance;
     verificationPassed: boolean;
     executionMode: ExecutionMode;
     governanceClaimEligible: boolean;
@@ -33,7 +32,7 @@ export interface RunLoopOutput {
     shouldStop: boolean;
     remainingBudgetUsd: number;
     remainingIterations: number;
-    remainingTokens: number;
+    remainingTokens?: number;
     engine: MartinEngine;
     workingDirectory: string;
     budget: LoopBudget;

package/dist/tools/run-loop.js

@@ -1,4 +1,4 @@
-import { createClaudeCliAdapter, createCodexCliAdapter, createGeminiCliAdapter, createVerifierOnlyAdapter, probeCodexLaunch, resolveCliCommandAvailability } from "../vendor/adapters/index.js";
+import { createClaudeCliAdapter, createCodexCliAdapter, createGeminiCliAdapter, probeCodexLaunch, resolveCliCommandAvailability, createVerifierOnlyAdapter } from "../vendor/adapters/index.js";
 import { createFileRunStore, evaluateCostGovernor, resolveRunsRoot, runMartin } from "../vendor/core/index.js";
 import { normalizeSafePathPatterns, resolveSafeRepoRoot } from "../server-validation.js";
 import { MartinToolError } from "./tool-errors.js";
@@ -166,7 +166,6 @@ export async function runLoopTool(input) {
         reason: result.decision.reason,
         attempts: result.loop.attempts.length,
         costUsd: result.loop.cost.actualUsd,
-        costProvenance: result.loop.cost.provenance ?? "unavailable",
         verificationPassed,
         executionMode: evidenceExecutionMode,
         governanceClaimEligible: evidenceExecutionMode === "governed",
@@ -175,7 +174,9 @@ export async function runLoopTool(input) {
         shouldStop: costState.shouldStop,
         remainingBudgetUsd: costState.remainingBudgetUsd,
         remainingIterations: costState.remainingIterations,
-        remainingTokens: costState.remainingTokens,
+        ...(costState.remainingTokens !== undefined
+            ? { remainingTokens: costState.remainingTokens }
+            : {}),
         engine,
         workingDirectory,
         budget,