@martinloop/mcp 0.3.9 → 0.5.0

package/dist/server-validation.js

@@ -14,12 +14,12 @@ export function validateToolInput(name, args) {
             return validateStatusInput(args);
         case "martin_doctor":
             return validateDoctorInput(args);
-        case "martin_estimate":
-            return validateEstimateInput(args);
         case "martin_plan":
             return validatePlanInput(args);
         case "martin_preflight":
             return validatePreflightInput(args);
+        case "martin_estimate":
+            return validateEstimateInput(args);
         case "martin_logs":
             return validateLogsInput(args);
         case "martin_cancel":
@@ -254,22 +254,27 @@ function validateDoctorInput(args) {
         ...optionalEnumAsObject(record.engine, "engine", MARTIN_ENGINE_VALUES)
     };
 }
+function validatePreflightInput(args) {
+    return validateRunInput(args);
+}
+function validatePlanInput(args) {
+    return validateRunInput(args);
+}
 function validateEstimateInput(args) {
     const record = requireObject(args);
-    assertAllowedKeys(record, ["objective", "engine", "budgetUsd", "fileScope"]);
+    assertAllowedKeys(record, ["objective", "engine", "budgetUsd", "fileScope", "workingDirectory"]);
+    const engine = optionalEnum(record.engine, "engine", MARTIN_ENGINE_VALUES);
+    const fileScope = normalizeSafePathPatterns(record.fileScope, "fileScope");
     return {
         objective: requireString(record.objective, "objective"),
-        ...optionalEnumAsObject(record.engine, "engine", MARTIN_ENGINE_VALUES),
+        ...(engine ? { engine } : {}),
         ...optionalPositiveNumber(record.budgetUsd, "budgetUsd"),
-        ...optionalStringArrayAsObject(record.fileScope, "fileScope")
+        ...(fileScope ? { fileScope } : {}),
+        ...(record.workingDirectory !== undefined
+            ? { workingDirectory: resolveSafeRepoRoot(requireString(record.workingDirectory, "workingDirectory")) }
+            : {})
     };
 }
-function validatePreflightInput(args) {
-    return validateRunInput(args);
-}
-function validatePlanInput(args) {
-    return validateRunInput(args);
-}
 function validateLogsInput(args) {
     const record = requireObject(args);
     assertAllowedKeys(record, ["file", "loopId", "runsDir", "latest", "limit"]);

package/dist/server.d.ts

@@ -16,6 +16,7 @@
  * Manual start:
  *   node dist/server.js
  */
+import { type Server as NodeHttpServer } from "node:http";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 export declare function createMartinMcpServer(serverInfo?: {
     name?: string;
@@ -88,4 +89,26 @@ export declare function connectMartinMcpStdioServer(): Promise<Server<{
         } | undefined;
     } | undefined;
 }>>;
+export interface MartinMcpHttpServerOptions {
+    host?: string;
+    port?: number;
+    path?: string;
+}
+export interface MartinMcpHttpServerHandle {
+    server: NodeHttpServer;
+    host: string;
+    port: number;
+    path: string;
+    endpoint: string;
+    close: () => Promise<void>;
+}
+export declare function parseMartinMcpServerArgs(argv: string[]): {
+    transport: "stdio";
+} | {
+    transport: "http";
+    host: string;
+    port: number;
+    path: string;
+};
+export declare function connectMartinMcpHttpServer(options?: MartinMcpHttpServerOptions): Promise<MartinMcpHttpServerHandle>;
 export declare function isDirectExecutionEntry(entryPath: string | undefined, moduleUrl?: string): boolean;

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";
@@ -1401,6 +1403,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"]
@@ -1518,7 +1524,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 +1541,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 +1559,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 +1646,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: [],
@@ -1673,8 +1679,14 @@ export function createMartinMcpServer(serverInfo) {
                     step: "estimate",
                     workingDirectory,
                     objective,
-                    engine
-                });
+                    engine,
+                    receiptScope: {
+                        invocationRoot: resolveSafeRepoRoot(),
+                        workingDirectory,
+                        repoRoot: workingDirectory,
+                        runsRoot
+                    }
+                }).catch(() => { });
                 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)}.`);
             }
             return createToolErrorResult(toToolFailure(new Error(`Unknown tool: ${name}`)));
@@ -1698,6 +1710,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 +1838,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/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);
@@ -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,5 +1,4 @@
-import { type SpawnLike } from "../vendor/adapters/index.js";
-import { type RunStore, type RunMartinInput, type RunMartinResult } from "../vendor/core/index.js";
+import { type RunStore } from "../vendor/core/index.js";
 import type { LoopBudget, ReceiptScope } from "../vendor/contracts/index.js";
 import { buildArtifactSummary, buildVerificationSummary, buildLoopPreview, type MartinEngine } from "./tool-support.js";
 export interface RunLoopInput {
@@ -44,7 +43,5 @@ export interface RunLoopOutput {
         artifacts: ReturnType<typeof buildArtifactSummary>;
     };
 }
-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>;

package/dist/tools/run-loop.js

@@ -1,21 +1,13 @@
-import { createClaudeCliAdapter, createCodexCliAdapter, createGeminiCliAdapter, probeCodexLaunch, resolveCliCommandAvailability, createVerifierOnlyAdapter } from "../vendor/adapters/index.js";
+import { createClaudeCliAdapter, createCodexCliAdapter, createGeminiCliAdapter, createStubDirectProviderAdapter, probeCodexLaunch, resolveCliCommandAvailability } 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";
 import { buildArtifactSummary, buildVerificationSummary, buildLoopPreview, buildRunRecordPaths, getEngineAvailability, resolveExecutionMode } from "./tool-support.js";
 import { normalizeLoopBudget } from "./workflow-governance.js";
-let proofModeVerifierSpawnImpl;
 let runStoreOverrideForTests;
-let runMartinImpl = runMartin;
-export function __setProofModeVerifierSpawnImplForTests(spawnImpl) {
-    proofModeVerifierSpawnImpl = spawnImpl;
-}
 export function __setRunStoreOverrideForTests(store) {
     runStoreOverrideForTests = store;
 }
-export function __setRunMartinImplForTests(impl) {
-    runMartinImpl = impl ?? runMartin;
-}
 export async function runLoopTool(input) {
     const workingDirectory = resolveSafeRepoRoot(input.workingDirectory);
     const engine = input.engine ?? "claude";
@@ -67,11 +59,10 @@ export async function runLoopTool(input) {
         }
     }
     const adapter = !executionMode.liveMode
-        ? createVerifierOnlyAdapter({
-            workingDirectory,
-            label: "Proof mode adapter (MARTIN_LIVE=false)",
-            ...(input.verifyTimeoutMs !== undefined ? { verifyTimeoutMs: input.verifyTimeoutMs } : {}),
-            ...(proofModeVerifierSpawnImpl ? { spawnImpl: proofModeVerifierSpawnImpl } : {})
+        ? createStubDirectProviderAdapter({
+            label: "Proof mode stub adapter (MARTIN_LIVE=false)",
+            providerId: "stub",
+            model: "stub"
         })
         : engine === "codex"
             ? createCodexCliAdapter({
@@ -102,7 +93,7 @@ export async function runLoopTool(input) {
         partialBudget.maxTokens = input.maxTokens;
     }
     const budget = normalizeLoopBudget(partialBudget);
-    const result = await runMartinImpl({
+    const result = await runMartin({
         workspaceId: input.workspaceId ?? "ws_mcp",
         projectId: input.projectId ?? "proj_mcp",
         store: runStoreOverrideForTests ?? createFileRunStore({ runsRoot }),

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

@@ -1,4 +1,4 @@
-import type { LoopArtifact, LoopBudget, LoopCost, LoopEvent, LoopTask, ReceiptIntegritySummary, ReceiptScope } from "../vendor/contracts/index.js";
+import type { LoopArtifact, LoopBudget, LoopCost, LoopEvent, LoopTask, ReceiptIntegritySummary, ReceiptScope, TerminationEnvelopeV1 } from "../vendor/contracts/index.js";
 import { type LedgerEvent, type LoopAttemptRecord, type LoopRunRecord } from "../vendor/core/index.js";
 export declare const MARTIN_ENGINE_VALUES: readonly ["claude", "codex", "gemini", "openai"];
 export type MartinEngine = (typeof MARTIN_ENGINE_VALUES)[number];
@@ -14,6 +14,7 @@ export interface InspectableLoopRecord extends Omit<LoopRunRecord, "attempts" |
     metadata?: Record<string, string>;
     receiptIntegrity?: ReceiptIntegritySummary;
     receiptScope?: ReceiptScope;
+    terminationEnvelope?: TerminationEnvelopeV1;
     routingEconomics?: import("../vendor/contracts/index.js").RoutingEconomics;
 }
 export interface LoopPreview {

package/dist/tools/tool-support.js

@@ -105,11 +105,6 @@ function discoverCommonInstallDirectories(command) {
         if (localAppData) {
             dirs.push(join(localAppData, "OpenAI", "Codex", "bin"));
         }
-        // Claude Code native installer places binary at %USERPROFILE%\.local\bin
-        const userProfile = process.env.USERPROFILE ?? process.env.HOMEPATH;
-        if (userProfile) {
-            dirs.push(join(userProfile, ".local", "bin"));
-        }
         // Scoop
         if (home) {
             dirs.push(join(home, "scoop", "shims"));
@@ -166,13 +161,8 @@ function isOnPathDirectly(command, resolvedPath) {
  * Returns a platform-specific one-liner install command for a known CLI.
  */
 function suggestInstallCommand(command) {
-    if (command === "claude") {
-        const installCmd = process.platform === "win32"
-            ? "irm https://claude.ai/install.ps1 | iex"
-            : "curl -fsSL https://claude.ai/install.sh | bash";
-        return `Install with: ${installCmd}`;
-    }
     const npmInstalls = {
+        claude: "npm install -g @anthropic-ai/claude-code",
         codex: "npm install -g @openai/codex",
         gemini: "npm install -g @google/gemini-cli"
     };
@@ -439,7 +429,6 @@ export function buildSuggestedResourceUris(loopId) {
         "martin://runs/triage",
         "martin://runs/latest",
         "martin://runs/latest/summary",
-        "martin://runs/latest/receipt",
         "martin://runs/latest/proof-card",
         "martin://runs/latest/budget-status",
         "martin://runs/latest/verifier-evidence",