@martinloop/mcp 0.2.7 → 0.3.0

package/dist/vendor/adapters/codex-launcher.js

@@ -0,0 +1,247 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, extname, resolve } from "node:path";
+function isInsideGitRepository(workingDirectory) {
+    let current = resolve(workingDirectory);
+    while (true) {
+        if (existsSync(resolve(current, ".git"))) {
+            return true;
+        }
+        const parent = dirname(current);
+        if (parent === current) {
+            return false;
+        }
+        current = parent;
+    }
+}
+function selectResolvedPath(candidates, platform) {
+    const cleaned = candidates
+        .map((line) => line.trim())
+        .filter(Boolean);
+    if (cleaned.length === 0) {
+        return undefined;
+    }
+    if (platform !== "win32") {
+        return cleaned[0];
+    }
+    const preference = (candidate) => {
+        switch (extname(candidate).toLowerCase()) {
+            case ".cmd":
+                return 0;
+            case ".bat":
+                return 1;
+            case ".ps1":
+                return 2;
+            case ".exe":
+                return 3;
+            case "":
+                return 4;
+            default:
+                return 5;
+        }
+    };
+    const [firstCandidate, ...remainingCandidates] = cleaned;
+    if (firstCandidate === undefined) {
+        return undefined;
+    }
+    let bestCandidate = firstCandidate;
+    let bestPreference = preference(bestCandidate);
+    for (const candidate of remainingCandidates) {
+        const candidatePreference = preference(candidate);
+        if (candidatePreference < bestPreference) {
+            bestCandidate = candidate;
+            bestPreference = candidatePreference;
+        }
+    }
+    return bestCandidate;
+}
+function buildProbeCommand(command, args, platform) {
+    if (platform !== "win32") {
+        return { command, args };
+    }
+    const extension = extname(command).toLowerCase();
+    switch (extension) {
+        case ".cmd":
+        case ".bat":
+            return {
+                command: process.env.ComSpec || "cmd.exe",
+                args: ["/d", "/c", command, ...args]
+            };
+        case ".ps1":
+            return {
+                command: "powershell.exe",
+                args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", command, ...args]
+            };
+        default:
+            return { command, args };
+    }
+}
+export function resolveCliCommandAvailability(command, options = {}) {
+    const platform = options.platform ?? process.platform;
+    const spawnSyncImpl = options.spawnSyncImpl ?? spawnSync;
+    const locator = platform === "win32" ? "where.exe" : "which";
+    const result = spawnSyncImpl(locator, [command], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"]
+    });
+    const resolvedPath = result.status === 0
+        ? selectResolvedPath((result.stdout ?? "").split(/\r?\n/u), platform)
+        : undefined;
+    return result.status === 0
+        ? {
+            command,
+            available: true,
+            locator,
+            detail: `${command} is available on PATH.`,
+            ...(resolvedPath ? { resolvedPath } : {})
+        }
+        : {
+            command,
+            available: false,
+            locator,
+            detail: `${command} is not available on PATH.`
+        };
+}
+export function detectCodexHostPlatform(env = process.env, platform = process.platform) {
+    if (platform === "win32") {
+        return "windows";
+    }
+    if (platform === "darwin") {
+        return "macos";
+    }
+    if (env["WSL_DISTRO_NAME"] || env["WSL_INTEROP"]) {
+        return "wsl";
+    }
+    return "linux";
+}
+export function diagnoseCodexHost(availability, options = {}) {
+    const hostPlatform = detectCodexHostPlatform(options.env ?? process.env, options.platform ?? process.platform);
+    const warnings = [];
+    if (!availability.available) {
+        return {
+            hostPlatform,
+            nativeInstallValid: false,
+            warnings,
+            remediation: "Install or expose the Codex CLI on PATH before running governed Codex work."
+        };
+    }
+    const resolvedPath = availability.resolvedPath?.replace(/\\/gu, "/").toLowerCase() ?? "";
+    const looksWindowsShim = resolvedPath.endsWith(".cmd") ||
+        resolvedPath.endsWith(".bat") ||
+        resolvedPath.endsWith(".ps1") ||
+        resolvedPath.includes("/appdata/roaming/npm/");
+    const looksMountedWindowsPath = resolvedPath.startsWith("/mnt/c/");
+    if ((hostPlatform === "linux" || hostPlatform === "wsl") && (looksWindowsShim || looksMountedWindowsPath)) {
+        warnings.push("Codex resolves to a Windows-hosted install from a Linux/WSL environment.");
+        return {
+            hostPlatform,
+            nativeInstallValid: false,
+            warnings,
+            remediation: "Install Codex natively inside this Linux/WSL environment instead of relying on a Windows PATH shim."
+        };
+    }
+    return {
+        hostPlatform,
+        nativeInstallValid: true,
+        warnings
+    };
+}
+export function probeCodexLaunch(input) {
+    const availability = input.availability ??
+        resolveCliCommandAvailability("codex", {
+            platform: input.platform,
+            spawnSyncImpl: input.spawnSyncImpl
+        });
+    const diagnosis = diagnoseCodexHost(availability, {
+        env: input.env,
+        platform: input.platform
+    });
+    const args = [
+        "exec",
+        "--cd",
+        input.workingDirectory,
+        "--sandbox",
+        "workspace-write",
+        "--json",
+        "--color",
+        "never",
+        "--help"
+    ];
+    if (!availability.available) {
+        return {
+            ok: false,
+            summary: availability.detail,
+            availability,
+            diagnosis,
+            command: availability.command,
+            args
+        };
+    }
+    if (!diagnosis.nativeInstallValid) {
+        return {
+            ok: false,
+            summary: diagnosis.remediation ?? "Codex host installation is not valid for this environment.",
+            availability,
+            diagnosis,
+            command: availability.resolvedPath ?? availability.command,
+            args
+        };
+    }
+    if (!isInsideGitRepository(input.workingDirectory)) {
+        return {
+            ok: false,
+            summary: "Working directory is not inside a git repository. Codex exec requires a trusted repo unless --skip-git-repo-check is explicitly enabled.",
+            availability,
+            diagnosis,
+            command: availability.resolvedPath ?? availability.command,
+            args
+        };
+    }
+    const spawnSyncImpl = input.spawnSyncImpl ?? spawnSync;
+    const platform = input.platform ?? process.platform;
+    const spawnPlan = buildProbeCommand(availability.resolvedPath ?? availability.command, args, platform);
+    const result = spawnSyncImpl(spawnPlan.command, spawnPlan.args, {
+        cwd: input.workingDirectory,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (result.error) {
+        return {
+            ok: false,
+            summary: `Codex launch probe failed: ${result.error.message}`,
+            availability,
+            diagnosis,
+            command: availability.resolvedPath ?? availability.command,
+            args,
+            stderr: result.stderr ?? "",
+            stdout: result.stdout ?? ""
+        };
+    }
+    if (result.status !== 0) {
+        const stderr = (result.stderr ?? "").trim();
+        return {
+            ok: false,
+            summary: stderr.length > 0
+                ? `Codex launch probe failed: ${stderr}`
+                : "Codex launch probe exited non-zero.",
+            availability,
+            diagnosis,
+            command: availability.resolvedPath ?? availability.command,
+            args,
+            exitCode: result.status ?? undefined,
+            stderr: result.stderr ?? "",
+            stdout: result.stdout ?? ""
+        };
+    }
+    return {
+        ok: true,
+        summary: "Codex exec launch probe passed for the current MartinLoop invocation shape.",
+        availability,
+        diagnosis,
+        command: availability.resolvedPath ?? availability.command,
+        args,
+        exitCode: result.status ?? undefined,
+        stderr: result.stderr ?? "",
+        stdout: result.stdout ?? ""
+    };
+}

package/dist/vendor/adapters/index.d.ts

@@ -1,7 +1,8 @@
 export { createDirectProviderAdapter, type DirectProviderAdapterOptions } from "./direct-provider.js";
 export { createStubDirectProviderAdapter, type StubDirectProviderAdapterOptions } from "./stub-direct-provider.js";
 export { createStubAgentCliAdapter, type StubAgentCliAdapterOptions } from "./stub-agent-cli.js";
-export { createAgentCliAdapter, createClaudeCliAdapter, createCodexCliAdapter, type AgentCliAdapterOptions, type ClaudeCliAdapterOptions, type CodexCliAdapterOptions, type CliArgsBuilder } from "./claude-cli.js";
+export { createAgentCliAdapter, createClaudeCliAdapter, createCodexCliAdapter, createGeminiCliAdapter, type AgentCliAdapterOptions, type ClaudeCliAdapterOptions, type CodexCliAdapterOptions, type GeminiCliAdapterOptions, type CliArgsBuilder } from "./claude-cli.js";
 export { createVerifierOnlyAdapter, type VerifierOnlyAdapterOptions } from "./verifier-only.js";
-export { createOpenAiCompatibleAdapter, type OpenAiCompatibleAdapterOptions } from "./openai-compatible.js";
+export { createOpenAiCompatibleAdapter, resolveOpenAiCompatibleRuntimeConfig, type OpenAiCompatibleAdapterOptions } from "./openai-compatible.js";
+export { detectCodexHostPlatform, diagnoseCodexHost, probeCodexLaunch, resolveCliCommandAvailability, type CliCommandAvailability, type CodexHostDiagnosis, type CodexHostPlatform, type CodexLaunchProbeResult } from "./codex-launcher.js";
 export { createSpawnPlan, type SpawnLike, type SpawnPlan, type SubprocessResult, type VerificationOutcome } from "./cli-bridge.js";

package/dist/vendor/adapters/index.js

@@ -1,7 +1,8 @@
 export { createDirectProviderAdapter } from "./direct-provider.js";
 export { createStubDirectProviderAdapter } from "./stub-direct-provider.js";
 export { createStubAgentCliAdapter } from "./stub-agent-cli.js";
-export { createAgentCliAdapter, createClaudeCliAdapter, createCodexCliAdapter } from "./claude-cli.js";
+export { createAgentCliAdapter, createClaudeCliAdapter, createCodexCliAdapter, createGeminiCliAdapter } from "./claude-cli.js";
 export { createVerifierOnlyAdapter } from "./verifier-only.js";
-export { createOpenAiCompatibleAdapter } from "./openai-compatible.js";
+export { createOpenAiCompatibleAdapter, resolveOpenAiCompatibleRuntimeConfig } from "./openai-compatible.js";
+export { detectCodexHostPlatform, diagnoseCodexHost, probeCodexLaunch, resolveCliCommandAvailability } from "./codex-launcher.js";
 export { createSpawnPlan } from "./cli-bridge.js";

package/dist/vendor/adapters/openai-compatible.d.ts

@@ -12,24 +12,30 @@
  *   Llama 3.x, Mistral 7B, Phi-4, Gemma 3, any GGUF model.
  *
  * Usage:
+ *   # Defaults to OpenAI's hosted endpoint when MARTIN_OPENAI_BASE_URL is unset.
+ *   MARTIN_OPENAI_API_KEY=sk-...
+ *   MARTIN_OPENAI_MODEL=gpt-4.1-mini
+ *   martin-loop run "fix the bug" --engine openai
+ *
+ *   # Or route to a third-party / self-hosted OpenAI-compatible endpoint:
  *   MARTIN_OPENAI_BASE_URL=https://openrouter.ai/api
  *   MARTIN_OPENAI_API_KEY=sk-or-...
  *   MARTIN_OPENAI_MODEL=deepseek/deepseek-chat
- *   martin run "fix the bug" --engine openai
+ *   martin-loop run "fix the bug" --engine openai
  *
  * Or for Ollama:
  *   MARTIN_OPENAI_BASE_URL=http://localhost:11434
  *   MARTIN_OPENAI_MODEL=llama3.3
- *   martin run "fix the bug" --engine openai
+ *   martin-loop run "fix the bug" --engine openai
  */
 import type { MartinAdapter } from "../core/index.js";
 export interface OpenAiCompatibleAdapterOptions {
     /** Base URL of the OpenAI-compatible API. No trailing slash. */
-    baseUrl: string;
+    baseUrl?: string;
     /** API key. Empty string for local (Ollama/LM Studio) endpoints. */
     apiKey?: string;
     /** Model identifier passed as-is to the API (e.g. "deepseek/deepseek-chat"). */
-    model: string;
+    model?: string;
     /**
      * System prompt prepended before the MartinLoop task prompt.
      * Default instructs the model to act as a focused coding assistant.
@@ -44,4 +50,13 @@ export interface OpenAiCompatibleAdapterOptions {
     /** Optional fetch override for testing. */
     fetchImpl?: typeof fetch;
 }
+export declare const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com";
+export declare const DEFAULT_OPENAI_MODEL = "gpt-4.1-mini";
+export declare function resolveOpenAiCompatibleRuntimeConfig(env?: NodeJS.ProcessEnv): {
+    baseUrl: string;
+    model: string;
+    apiKey: string;
+    apiKeyConfigured: boolean;
+    authPosture: "api_key" | "anonymous_or_local";
+};
 export declare function createOpenAiCompatibleAdapter(options: OpenAiCompatibleAdapterOptions): MartinAdapter;

package/dist/vendor/adapters/openai-compatible.js

@@ -12,17 +12,23 @@
  *   Llama 3.x, Mistral 7B, Phi-4, Gemma 3, any GGUF model.
  *
  * Usage:
+ *   # Defaults to OpenAI's hosted endpoint when MARTIN_OPENAI_BASE_URL is unset.
+ *   MARTIN_OPENAI_API_KEY=sk-...
+ *   MARTIN_OPENAI_MODEL=gpt-4.1-mini
+ *   martin-loop run "fix the bug" --engine openai
+ *
+ *   # Or route to a third-party / self-hosted OpenAI-compatible endpoint:
  *   MARTIN_OPENAI_BASE_URL=https://openrouter.ai/api
  *   MARTIN_OPENAI_API_KEY=sk-or-...
  *   MARTIN_OPENAI_MODEL=deepseek/deepseek-chat
- *   martin run "fix the bug" --engine openai
+ *   martin-loop run "fix the bug" --engine openai
  *
  * Or for Ollama:
  *   MARTIN_OPENAI_BASE_URL=http://localhost:11434
  *   MARTIN_OPENAI_MODEL=llama3.3
- *   martin run "fix the bug" --engine openai
+ *   martin-loop run "fix the bug" --engine openai
  */
-import { runVerification, readGitExecutionArtifacts } from "./cli-bridge.js";
+import { readGitChangedFiles, runVerification } from "./cli-bridge.js";
 import { createAdapterCapabilities, normalizeUsage } from "./runtime-support.js";
 // ---------------------------------------------------------------------------
 // OpenRouter/OpenAI-compatible model pricing ($/1K tokens)
@@ -73,6 +79,18 @@ Follow these rules exactly:
 - If the task asks you to write or modify code, output the complete file content with changes applied.
 - Be precise, minimal, and test-backed in all changes.
 - State what you changed and why at the end of your response.`;
+export const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com";
+export const DEFAULT_OPENAI_MODEL = "gpt-4.1-mini";
+export function resolveOpenAiCompatibleRuntimeConfig(env = process.env) {
+    const apiKey = env["MARTIN_OPENAI_API_KEY"] ?? "";
+    return {
+        baseUrl: env["MARTIN_OPENAI_BASE_URL"] ?? DEFAULT_OPENAI_BASE_URL,
+        model: env["MARTIN_OPENAI_MODEL"] ?? DEFAULT_OPENAI_MODEL,
+        apiKey,
+        apiKeyConfigured: apiKey.length > 0,
+        authPosture: apiKey.length > 0 ? "api_key" : "anonymous_or_local"
+    };
+}
 function buildPrompt(request) {
     const lines = [
         `TASK: ${request.context.taskTitle}`,
@@ -105,13 +123,17 @@ export function createOpenAiCompatibleAdapter(options) {
     const verifyTimeoutMs = options.verifyTimeoutMs ?? 60_000;
     const systemPrompt = options.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
     const fetchFn = options.fetchImpl ?? globalThis.fetch;
+    const runtimeConfig = resolveOpenAiCompatibleRuntimeConfig();
+    const baseUrl = (options.baseUrl ?? runtimeConfig.baseUrl).replace(/\/$/, "");
+    const model = options.model ?? runtimeConfig.model;
+    const apiKey = options.apiKey ?? runtimeConfig.apiKey;
     return {
-        adapterId: `openai-compatible:${options.model}`,
+        adapterId: `openai-compatible:${model}`,
         kind: "direct-provider",
-        label: `OpenAI-compatible: ${options.model}`,
+        label: `OpenAI-compatible: ${model}`,
         metadata: {
             providerId: "openai-compatible",
-            model: options.model,
+            model,
             transport: "http",
             capabilities: createAdapterCapabilities({
                 preflight: true,
@@ -121,7 +143,8 @@ export function createOpenAiCompatibleAdapter(options) {
         },
         async execute(request) {
             const prompt = buildPrompt(request);
-            const estimated = estimateCost(options.model, prompt.length, 2000);
+            const estimated = estimateCost(model, prompt.length, 2000);
+            const baselineChangedFiles = new Set(await readGitChangedFiles(workingDirectory, 5_000));
             // Preflight: bail if projected cost exceeds remaining budget
             if (request.context.remainingBudgetUsd > 0 &&
                 estimated.actualUsd > request.context.remainingBudgetUsd * 0.95) {
@@ -140,7 +163,7 @@ export function createOpenAiCompatibleAdapter(options) {
                 };
             }
             // Call the OpenAI-compatible endpoint
-            const endpoint = `${options.baseUrl.replace(/\/$/, "")}/v1/chat/completions`;
+            const endpoint = `${baseUrl}/v1/chat/completions`;
             let responseText = "";
             let tokensIn = estimated.tokensIn;
             let tokensOut = 0;
@@ -148,10 +171,10 @@ export function createOpenAiCompatibleAdapter(options) {
             const timer = setTimeout(() => controller.abort(), timeoutMs);
             try {
                 const headers = { "Content-Type": "application/json" };
-                if (options.apiKey)
-                    headers["Authorization"] = `Bearer ${options.apiKey}`;
+                if (apiKey)
+                    headers["Authorization"] = `Bearer ${apiKey}`;
                 // OpenRouter requires a site URL header for attribution
-                if (options.baseUrl.includes("openrouter")) {
+                if (baseUrl.includes("openrouter")) {
                     headers["HTTP-Referer"] = "https://martinloop.com";
                     headers["X-Title"] = "MartinLoop";
                 }
@@ -159,7 +182,7 @@ export function createOpenAiCompatibleAdapter(options) {
                     method: "POST",
                     headers,
                     body: JSON.stringify({
-                        model: options.model,
+                        model,
                         messages: [
                             { role: "system", content: systemPrompt },
                             { role: "user", content: prompt }
@@ -174,7 +197,7 @@ export function createOpenAiCompatibleAdapter(options) {
                     const errMsg = body.error?.message ?? `HTTP ${res.status}`;
                     return {
                         status: "failed",
-                        summary: `${options.model} API error: ${errMsg}`,
+                        summary: `${model} API error: ${errMsg}`,
                         usage: normalizeUsage({ actualUsd: 0, tokensIn: 0, tokensOut: 0, provenance: "unavailable" }),
                         verification: { passed: false, summary: "API call failed before verifier." },
                         failure: { message: errMsg, classHint: "infrastructure_error" }
@@ -191,7 +214,7 @@ export function createOpenAiCompatibleAdapter(options) {
             }
             catch (error) {
                 const isAbort = error instanceof Error && error.name === "AbortError";
-                const message = isAbort ? `${options.model} request timed out after ${timeoutMs}ms` : String(error);
+                const message = isAbort ? `${model} request timed out after ${timeoutMs}ms` : String(error);
                 return {
                     status: "failed",
                     summary: message,
@@ -206,7 +229,7 @@ export function createOpenAiCompatibleAdapter(options) {
             if (!responseText.trim()) {
                 return {
                     status: "failed",
-                    summary: `${options.model} returned an empty response.`,
+                    summary: `${model} returned an empty response.`,
                     usage: normalizeUsage({ actualUsd: 0, tokensIn, tokensOut: 0, provenance: "actual" }),
                     verification: { passed: false, summary: "Empty response — nothing to verify." },
                     failure: { message: "empty_response" }
@@ -214,8 +237,10 @@ export function createOpenAiCompatibleAdapter(options) {
             }
             // Run verification
             const verification = await runVerification(request.context.verificationPlan, workingDirectory, verifyTimeoutMs, request.context.verificationStack);
-            const execution = await readGitExecutionArtifacts(workingDirectory, 5_000);
-            const pricing = KNOWN_MODEL_PRICING[options.model] ?? {
+            const execution = {
+                changedFiles: (await readGitChangedFiles(workingDirectory, 5_000)).filter((file) => !baselineChangedFiles.has(file))
+            };
+            const pricing = KNOWN_MODEL_PRICING[model] ?? {
                 inputPer1K: FALLBACK_INPUT_PER_1K,
                 outputPer1K: FALLBACK_OUTPUT_PER_1K
             };
@@ -223,8 +248,8 @@ export function createOpenAiCompatibleAdapter(options) {
             return {
                 status: verification.passed ? "completed" : "failed",
                 summary: verification.passed
-                    ? `${options.model} completed the task. Verifier passed.`
-                    : `${options.model} completed but verifier failed: ${verification.summary}`,
+                    ? `${model} completed the task. Verifier passed.`
+                    : `${model} completed but verifier failed: ${verification.summary}`,
                 usage: normalizeUsage({
                     actualUsd,
                     tokensIn,

package/dist/vendor/adapters/runtime-support.d.ts

@@ -7,7 +7,10 @@ export declare function normalizeUsage(input: {
     estimatedUsd?: number;
     tokensIn?: number;
     tokensOut?: number;
+    cachedInputTokens?: number;
+    reasoningTokensOut?: number;
     provenance?: MartinAdapterResult["usage"]["provenance"];
+    providerSettlement?: MartinAdapterResult["usage"]["providerSettlement"];
 }): MartinAdapterResult["usage"];
 export declare function diffStatsFromNumstat(stdout: string): DiffStats | undefined;
 export declare function normalizeStructuredErrors(errors: StructuredError[] | undefined): StructuredError[];

package/dist/vendor/adapters/runtime-support.js

@@ -21,7 +21,14 @@ export function normalizeUsage(input) {
             : {}),
         tokensIn: input.tokensIn ?? 0,
         tokensOut: input.tokensOut ?? 0,
-        provenance
+        ...(input.cachedInputTokens !== undefined
+            ? { cachedInputTokens: input.cachedInputTokens }
+            : {}),
+        ...(input.reasoningTokensOut !== undefined
+            ? { reasoningTokensOut: input.reasoningTokensOut }
+            : {}),
+        provenance,
+        ...(input.providerSettlement ? { providerSettlement: input.providerSettlement } : {})
     };
 }
 export function diffStatsFromNumstat(stdout) {

package/dist/vendor/adapters/verifier-only.js

@@ -1,4 +1,4 @@
-import { readGitExecutionArtifacts, runVerification } from "./cli-bridge.js";
+import { readGitChangedFiles, runVerification } from "./cli-bridge.js";
 import { createAdapterCapabilities, normalizeUsage } from "./runtime-support.js";
 export function createVerifierOnlyAdapter(options = {}) {
     const workingDirectory = options.workingDirectory ?? process.cwd();
@@ -17,9 +17,10 @@ export function createVerifierOnlyAdapter(options = {}) {
             })
         },
         async execute(request) {
+            const baselineChangedFiles = new Set(await readGitChangedFiles(workingDirectory, 5_000));
             const verification = await runVerification(request.context.verificationPlan, workingDirectory, verifyTimeoutMs, request.context.verificationStack);
-            const execution = await readGitExecutionArtifacts(workingDirectory, 5_000);
-            const changedFiles = execution.changedFiles ?? [];
+            const changedFiles = (await readGitChangedFiles(workingDirectory, 5_000)).filter((file) => !baselineChangedFiles.has(file));
+            const execution = { changedFiles };
             if (verification.passed) {
                 return {
                     status: "completed",

package/dist/vendor/contracts/index.d.ts

@@ -49,6 +49,40 @@ export interface LoopCost {
     avoidedUsd: number;
     tokensIn: number;
     tokensOut: number;
+    estimatedUsd?: number;
+    provenance?: CostProvenance;
+    providerSettlement?: ProviderUsageSettlement;
+}
+export type UsageSettlementSource = "claude_json" | "codex_jsonl" | "gemini_json" | "estimated_fallback" | "unavailable";
+export interface ProviderUsageSettlement {
+    providerId: string;
+    model: string;
+    transport?: "cli" | "http" | "routed_http";
+    source: UsageSettlementSource;
+    inputTokens: number;
+    cachedInputTokens?: number;
+    outputTokens: number;
+    reasoningOutputTokens?: number;
+    rawUsageAvailable: boolean;
+    settledAt: string;
+}
+export interface ReceiptScope {
+    repoRoot?: string;
+    workingDirectory?: string;
+    invocationRoot?: string;
+    runsRoot?: string;
+}
+export type ReceiptIntegrityState = "verified" | "unsigned" | "tamper_detected";
+export interface ReceiptIntegritySummary {
+    state: ReceiptIntegrityState;
+    keyId?: string;
+    signedAt?: string;
+    loopRecordSha256?: string;
+    ledgerSha256?: string;
+    ledgerHeadHash?: string;
+    entryCount?: number;
+    reason?: string;
+    warnings?: string[];
 }
 export interface LoopArtifact {
     artifactId: string;
@@ -90,6 +124,8 @@ export interface LoopRecord {
     metadata: Record<string, string>;
     createdAt: string;
     updatedAt: string;
+    receiptScope?: ReceiptScope;
+    receiptIntegrity?: ReceiptIntegritySummary;
 }
 export interface LoopRecordDraft {
     loopId?: string;
@@ -107,6 +143,8 @@ export interface LoopRecordDraft {
     metadata?: Record<string, string>;
     createdAt?: string;
     updatedAt?: string;
+    receiptScope?: ReceiptScope;
+    receiptIntegrity?: ReceiptIntegritySummary;
 }
 export type { MartinErrorCategory, MartinOutputMode, MartinRunListFilters, MartinRunSelector } from "./operator.js";
 export { MARTIN_ERROR_CATEGORIES } from "./operator.js";
@@ -272,6 +310,7 @@ export interface BudgetSettlement {
         usd: number;
         provenance: CostProvenance;
     };
+    providerSettlement?: ProviderUsageSettlement;
     totalActualUsd: number;
     preflightEstimateUsd: number;
     varianceUsd: number;

package/dist/vendor/contracts/index.js

@@ -36,6 +36,8 @@ export function createLoopRecord(draft, options = {}) {
         },
         createdAt: draft.createdAt ?? now,
         updatedAt: draft.updatedAt ?? now,
+        ...(draft.receiptScope ? { receiptScope: draft.receiptScope } : {}),
+        ...(draft.receiptIntegrity ? { receiptIntegrity: draft.receiptIntegrity } : {}),
         ...(draft.teamId ? { teamId: draft.teamId } : {})
     };
 }

package/dist/vendor/core/index.d.ts

@@ -1,4 +1,4 @@
-import { type ApprovalPolicy, type CostProvenance, type ExecutionProfile, type FailureClass, type InterventionType, type LoopArtifact, type LoopAttempt, type LoopBudget, type MutationMode, type LoopRecord, type LoopTask } from "../contracts/index.js";
+import { type ApprovalPolicy, type CostProvenance, type ExecutionProfile, type FailureClass, type InterventionType, type LoopArtifact, type LoopAttempt, type LoopBudget, type ProviderUsageSettlement, type MutationMode, type LoopRecord, type LoopTask, type ReceiptScope } from "../contracts/index.js";
 import { classifyFailure, computeEvidenceVector, evaluatePatchDecision, evaluateCostGovernor, evaluateBudgetPreflight, inferExit, nextPolicyPhase, policyPhaseToLifecycleState, scorePatchDecision, selectRecoveryRecipe, type ExitDecision } from "./policy.js";
 import { evaluateChangeApprovalLeash, evaluateFilesystemLeash, evaluateSecretLeash, redactSecretsFromText, resolveExecutionProfile, evaluateVerificationLeash } from "./leash.js";
 import { buildRepoGroundingIndex, loadOrBuildRepoGroundingIndex, queryRepoGroundingIndex, scanPatchForGroundingViolations } from "./grounding.js";
@@ -13,8 +13,8 @@ export { runContextIntegrityPrecheck } from "./context-integrity.js";
 export type { ContextIntegrityPrecheck, ContextIntegrityVerdict } from "./context-integrity.js";
 export { compilePromptPacket } from "./compiler.js";
 export type { PromptPacket, CompilerAdapterRequest } from "./compiler.js";
-export { createFileRunStore, makeLedgerEvent, readAllLoopRecords, readLatestLoopRecord, readLatestLoopRecordFromFile, readLoopRecordsFromFile, resolveRunsRoot } from "./persistence/index.js";
-export type { AttemptArtifacts, LedgerEvent, LedgerEventKind, LoopAttemptRecord, LoopRunRecord, RunContract, RunStore } from "./persistence/index.js";
+export { createFileRunStore, makeLedgerEvent, readAllLoopRecords, readLatestLoopRecord, readLatestLoopRecordFromFile, readLoopRecordsFromFile, resolveRunsRoot, resolveReceiptIntegrityPath, verifyReceiptIntegrityFromFiles, writeReceiptIntegrityMaterial } from "./persistence/index.js";
+export type { AttemptArtifacts, LedgerEvent, LedgerEventKind, LoopAttemptRecord, LoopRunRecord, ReceiptIntegrityChainEntry, RunContract, RunStore, StoredReceiptIntegrityMaterial } from "./persistence/index.js";
 export { compileAndPersistContext } from "./persistence/index.js";
 export type { CompileResult } from "./persistence/index.js";
 export interface MartinAdapterRequest {
@@ -44,6 +44,20 @@ export interface MartinAdapterRequest {
     };
     previousAttempts: LoopAttempt[];
 }
+export interface MartinVerificationStep {
+    command: string;
+    launched: boolean;
+    exitCode?: number;
+    timedOut: boolean;
+    fastFail?: boolean;
+    detail?: string;
+}
+export interface MartinVerificationOutcome {
+    passed: boolean;
+    summary: string;
+    steps?: MartinVerificationStep[];
+    warnings?: string[];
+}
 export interface MartinAdapterResult {
     status: "completed" | "failed";
     summary: string;
@@ -52,11 +66,16 @@ export interface MartinAdapterResult {
         estimatedUsd?: number;
         tokensIn: number;
         tokensOut: number;
+        cachedInputTokens?: number;
+        reasoningTokensOut?: number;
         provenance?: CostProvenance;
+        providerSettlement?: ProviderUsageSettlement;
     };
     verification: {
         passed: boolean;
         summary: string;
+        steps?: MartinVerificationStep[];
+        warnings?: string[];
     };
     execution?: {
         changedFiles?: string[];
@@ -135,6 +154,7 @@ export interface RunMartinInput {
     maxRecentAttempts?: number;
     fallbackModels?: string[];
     fallbackAdapters?: MartinAdapter[];
+    receiptScope?: ReceiptScope;
     /** Optional persistence store. When provided, runMartin writes artifacts on each lifecycle event. */
     store?: RunStore;
 }