@martinloop/mcp 0.3.6 → 0.3.7

package/dist/vendor/adapters/adapters/src/direct-provider.js

@@ -0,0 +1,40 @@
+import { createAdapterCapabilities } from "./runtime-support.js";
+export function createDirectProviderAdapter(options) {
+    return {
+        adapterId: `direct:${options.providerId}:${options.model}`,
+        kind: "direct-provider",
+        label: options.label ?? `Direct provider (${options.providerId}/${options.model})`,
+        metadata: {
+            providerId: options.providerId,
+            model: options.model,
+            transport: options.transport ?? "http",
+            capabilities: createAdapterCapabilities({
+                usageSettlement: true,
+                structuredErrors: true,
+                ...options.capabilities
+            })
+        },
+        async execute(request) {
+            if (options.responder) {
+                return await options.responder(request);
+            }
+            return {
+                status: "failed",
+                summary: `Direct provider ${options.providerId}/${options.model} is not configured for live inference.`,
+                usage: {
+                    actualUsd: 0,
+                    tokensIn: 0,
+                    tokensOut: 0,
+                    provenance: "unavailable"
+                },
+                verification: {
+                    passed: false,
+                    summary: "No live provider request was attempted."
+                },
+                failure: {
+                    message: `Direct provider ${options.providerId}/${options.model} is not configured for live inference. environment_mismatch`
+                }
+            };
+        }
+    };
+}

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

@@ -0,0 +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, 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, 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/adapters/src/index.js

@@ -0,0 +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, createGeminiCliAdapter } from "./claude-cli.js";
+export { createVerifierOnlyAdapter } from "./verifier-only.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/adapters/src/openai-compatible.d.ts

@@ -0,0 +1,62 @@
+/**
+ * OpenAI-compatible adapter for MartinLoop.
+ *
+ * Routes agent execution to any endpoint that implements the OpenAI
+ * Chat Completions API (`POST /v1/chat/completions`). This covers:
+ *
+ * Hosted via OpenRouter / Together.ai / Fireworks.ai:
+ *   DeepSeek-V3, DeepSeek-R1, Qwen3-235B, Mistral Large, Codestral,
+ *   Kimi k2, Nemotron-70B, and hundreds more.
+ *
+ * Local via Ollama / LM Studio / llama.cpp:
+ *   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-loop run "fix the bug" --engine openai
+ *
+ * Or for Ollama:
+ *   MARTIN_OPENAI_BASE_URL=http://localhost:11434
+ *   MARTIN_OPENAI_MODEL=llama3.3
+ *   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;
+    /** 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;
+    /**
+     * System prompt prepended before the MartinLoop task prompt.
+     * Default instructs the model to act as a focused coding assistant.
+     */
+    systemPrompt?: string;
+    /** Request timeout in milliseconds. Default: 300_000 (5 min). */
+    timeoutMs?: number;
+    /** Verifier timeout in milliseconds. Default: 120_000. */
+    verifyTimeoutMs?: number;
+    /** Working directory for git artifact collection and verification. */
+    workingDirectory?: string;
+    /** 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/adapters/src/openai-compatible.js

@@ -0,0 +1,306 @@
+/**
+ * OpenAI-compatible adapter for MartinLoop.
+ *
+ * Routes agent execution to any endpoint that implements the OpenAI
+ * Chat Completions API (`POST /v1/chat/completions`). This covers:
+ *
+ * Hosted via OpenRouter / Together.ai / Fireworks.ai:
+ *   DeepSeek-V3, DeepSeek-R1, Qwen3-235B, Mistral Large, Codestral,
+ *   Kimi k2, Nemotron-70B, and hundreds more.
+ *
+ * Local via Ollama / LM Studio / llama.cpp:
+ *   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-loop run "fix the bug" --engine openai
+ *
+ * Or for Ollama:
+ *   MARTIN_OPENAI_BASE_URL=http://localhost:11434
+ *   MARTIN_OPENAI_MODEL=llama3.3
+ *   martin-loop run "fix the bug" --engine openai
+ */
+import { readGitChangedFiles, runVerification } from "./cli-bridge.js";
+import { createAdapterCapabilities, normalizeUsage } from "./runtime-support.js";
+// ---------------------------------------------------------------------------
+// OpenRouter/OpenAI-compatible model pricing ($/1K tokens)
+// Automatically used when baseUrl contains openrouter.ai or known providers.
+// Defaults to a conservative blended estimate for unknown models.
+// ---------------------------------------------------------------------------
+const KNOWN_MODEL_PRICING = {
+    // DeepSeek
+    "deepseek/deepseek-chat": { inputPer1K: 0.00027, outputPer1K: 0.0011 },
+    "deepseek/deepseek-r1": { inputPer1K: 0.0008, outputPer1K: 0.0032 },
+    "deepseek/deepseek-coder": { inputPer1K: 0.00014, outputPer1K: 0.00028 },
+    // Qwen
+    "qwen/qwen3-235b-a22b": { inputPer1K: 0.00022, outputPer1K: 0.00088 },
+    "qwen/qwen3-32b": { inputPer1K: 0.00009, outputPer1K: 0.00009 },
+    "qwen/qwen-2.5-coder-32b-instruct": { inputPer1K: 0.00007, outputPer1K: 0.00007 },
+    // Mistral
+    "mistralai/codestral-latest": { inputPer1K: 0.0003, outputPer1K: 0.0009 },
+    "mistralai/mistral-large": { inputPer1K: 0.003, outputPer1K: 0.009 },
+    "mistralai/mistral-small": { inputPer1K: 0.0001, outputPer1K: 0.0003 },
+    // Kimi
+    "moonshotai/kimi-k2": { inputPer1K: 0.00065, outputPer1K: 0.0026 },
+    // Nemotron
+    "nvidia/llama-3.1-nemotron-70b-instruct": { inputPer1K: 0.00012, outputPer1K: 0.0003 },
+    // Llama (via OpenRouter)
+    "meta-llama/llama-3.3-70b-instruct": { inputPer1K: 0.00012, outputPer1K: 0.0003 },
+    "meta-llama/llama-3.1-405b-instruct": { inputPer1K: 0.0008, outputPer1K: 0.0008 },
+};
+const FALLBACK_INPUT_PER_1K = 0.0003;
+const FALLBACK_OUTPUT_PER_1K = 0.0012;
+const CHARS_PER_TOKEN = 4;
+function estimateCost(model, inputChars, outputChars) {
+    const pricing = KNOWN_MODEL_PRICING[model] ?? {
+        inputPer1K: FALLBACK_INPUT_PER_1K,
+        outputPer1K: FALLBACK_OUTPUT_PER_1K
+    };
+    const tokensIn = Math.ceil(inputChars / CHARS_PER_TOKEN);
+    const tokensOut = Math.ceil(outputChars / CHARS_PER_TOKEN);
+    const actualUsd = (tokensIn / 1000) * pricing.inputPer1K + (tokensOut / 1000) * pricing.outputPer1K;
+    return { tokensIn, tokensOut, actualUsd };
+}
+// ---------------------------------------------------------------------------
+// Prompt builder
+// ---------------------------------------------------------------------------
+const DEFAULT_SYSTEM_PROMPT = `You are an expert software engineer executing a governed coding task.
+Follow these rules exactly:
+- Read the task description carefully and implement only what is asked.
+- Do not add features, refactors, or improvements beyond the stated task.
+- 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}`,
+        ``,
+        `OBJECTIVE:`,
+        request.context.objective,
+        ``
+    ];
+    if (request.context.focus) {
+        lines.push(`FOCUS: ${request.context.focus}`, ``);
+    }
+    if (request.context.verificationPlan.length > 0) {
+        lines.push(`VERIFICATION COMMANDS (must pass after your changes):`, ...request.context.verificationPlan.map((cmd) => `  ${cmd}`), ``);
+    }
+    if (request.previousAttempts.length > 0) {
+        const last = request.previousAttempts.at(-1);
+        if (last) {
+            lines.push(`PREVIOUS ATTEMPT SUMMARY:`, last.summary ?? "", ``);
+        }
+    }
+    lines.push(`BUDGET REMAINING: $${request.context.remainingBudgetUsd.toFixed(4)} | Iterations left: ${request.context.remainingIterations}`);
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+export function createOpenAiCompatibleAdapter(options) {
+    const workingDirectory = options.workingDirectory ?? process.cwd();
+    const timeoutMs = options.timeoutMs ?? 300_000;
+    const verifyTimeoutMs = options.verifyTimeoutMs ?? 120_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:${model}`,
+        kind: "direct-provider",
+        label: `OpenAI-compatible: ${model}`,
+        metadata: {
+            providerId: "openai-compatible",
+            model,
+            transport: "http",
+            capabilities: createAdapterCapabilities({
+                preflight: true,
+                usageSettlement: true,
+                diffArtifacts: true
+            })
+        },
+        async execute(request) {
+            const prompt = buildPrompt(request);
+            const estimated = estimateCost(model, prompt.length, 2000);
+            const hasVerificationSteps = request.context.verificationPlan.length > 0 ||
+                (request.context.verificationStack?.length ?? 0) > 0;
+            const baselineChangedFiles = hasVerificationSteps
+                ? new Set(await readGitChangedFiles(workingDirectory, 5_000))
+                : new Set();
+            // Preflight: bail if projected cost exceeds remaining budget
+            if (request.context.remainingBudgetUsd > 0 &&
+                estimated.actualUsd > request.context.remainingBudgetUsd * 0.95) {
+                return {
+                    status: "failed",
+                    summary: `Preflight: projected cost $${estimated.actualUsd.toFixed(4)} exceeds remaining budget $${request.context.remainingBudgetUsd.toFixed(4)}.`,
+                    usage: normalizeUsage({
+                        actualUsd: estimated.actualUsd,
+                        estimatedUsd: estimated.actualUsd,
+                        tokensIn: estimated.tokensIn,
+                        tokensOut: estimated.tokensOut,
+                        provenance: "estimated"
+                    }),
+                    verification: { passed: false, summary: "Stopped before execution: budget preflight failed." },
+                    failure: { message: "budget_preflight_exceeded", classHint: "budget_pressure" }
+                };
+            }
+            // Call the OpenAI-compatible endpoint with exponential-backoff retry on
+            // transient failures (429 rate-limit, 503/5xx server errors, network errors).
+            // Auth errors (401/403) and bad-request errors (400) are not retried — they
+            // indicate a permanent configuration problem.
+            const MAX_RETRIES = 3;
+            const RETRYABLE_STATUS = new Set([429, 500, 502, 503, 504]);
+            const endpoint = `${baseUrl}/v1/chat/completions`;
+            let responseText = "";
+            let tokensIn = estimated.tokensIn;
+            let tokensOut = 0;
+            const headers = { "Content-Type": "application/json" };
+            if (apiKey)
+                headers["Authorization"] = `Bearer ${apiKey}`;
+            if (baseUrl.includes("openrouter")) {
+                headers["HTTP-Referer"] = "https://martinloop.com";
+                headers["X-Title"] = "MartinLoop";
+            }
+            const requestBody = JSON.stringify({
+                model,
+                messages: [
+                    { role: "system", content: systemPrompt },
+                    { role: "user", content: prompt }
+                ],
+                temperature: 0.2,
+                max_tokens: 8192
+            });
+            let lastError = "";
+            let succeeded = false;
+            for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+                const controller = new AbortController();
+                const timer = setTimeout(() => controller.abort(), timeoutMs);
+                try {
+                    const res = await fetchFn(endpoint, {
+                        method: "POST",
+                        headers,
+                        body: requestBody,
+                        signal: controller.signal
+                    });
+                    const body = (await res.json());
+                    if (!res.ok || body.error) {
+                        const errMsg = body.error?.message ?? `HTTP ${res.status}`;
+                        if (RETRYABLE_STATUS.has(res.status) && attempt < MAX_RETRIES - 1) {
+                            lastError = errMsg;
+                            // Exponential backoff: 1s, 2s, 4s
+                            await new Promise((resolve) => setTimeout(resolve, 1000 * Math.pow(2, attempt)));
+                            continue;
+                        }
+                        return {
+                            status: "failed",
+                            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" }
+                        };
+                    }
+                    responseText = body.choices?.[0]?.message?.content ?? "";
+                    if (body.usage) {
+                        tokensIn = body.usage.prompt_tokens ?? tokensIn;
+                        tokensOut = body.usage.completion_tokens ?? 0;
+                    }
+                    else {
+                        tokensOut = Math.ceil(responseText.length / CHARS_PER_TOKEN);
+                    }
+                    succeeded = true;
+                    break;
+                }
+                catch (error) {
+                    const isAbort = error instanceof Error && error.name === "AbortError";
+                    if (isAbort || attempt === MAX_RETRIES - 1) {
+                        const message = isAbort
+                            ? `${model} request timed out after ${timeoutMs}ms`
+                            : String(error);
+                        return {
+                            status: "failed",
+                            summary: message,
+                            usage: normalizeUsage({ actualUsd: 0, tokensIn: 0, tokensOut: 0, provenance: "unavailable" }),
+                            verification: { passed: false, summary: isAbort ? "Request timed out." : "Network error." },
+                            failure: { message, classHint: "infrastructure_error" }
+                        };
+                    }
+                    // Transient network error — retry with backoff
+                    lastError = String(error);
+                    await new Promise((resolve) => setTimeout(resolve, 1000 * Math.pow(2, attempt)));
+                }
+                finally {
+                    clearTimeout(timer);
+                }
+            }
+            if (!succeeded) {
+                return {
+                    status: "failed",
+                    summary: `${model} API error after ${MAX_RETRIES} attempts: ${lastError}`,
+                    usage: normalizeUsage({ actualUsd: 0, tokensIn: 0, tokensOut: 0, provenance: "unavailable" }),
+                    verification: { passed: false, summary: "API call failed after retries." },
+                    failure: { message: lastError, classHint: "infrastructure_error" }
+                };
+            }
+            if (!responseText.trim()) {
+                return {
+                    status: "failed",
+                    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" }
+                };
+            }
+            // Run verification
+            const verification = await runVerification(request.context.verificationPlan, workingDirectory, verifyTimeoutMs, request.context.verificationStack);
+            const execution = {
+                changedFiles: hasVerificationSteps
+                    ? (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
+            };
+            const actualUsd = (tokensIn / 1000) * pricing.inputPer1K + (tokensOut / 1000) * pricing.outputPer1K;
+            return {
+                status: verification.passed ? "completed" : "failed",
+                summary: verification.passed
+                    ? `${model} completed the task. Verifier passed.`
+                    : `${model} completed but verifier failed: ${verification.summary}`,
+                usage: normalizeUsage({
+                    actualUsd,
+                    tokensIn,
+                    tokensOut,
+                    provenance: "actual"
+                }),
+                verification,
+                execution,
+                ...(verification.passed ? {} : {
+                    failure: { message: verification.summary }
+                })
+            };
+        }
+    };
+}

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

@@ -0,0 +1,17 @@
+import type { MartinAdapter, MartinAdapterResult } from "../../../core/index.js";
+type StructuredError = NonNullable<NonNullable<MartinAdapterResult["execution"]>["structuredErrors"]>[number];
+type DiffStats = NonNullable<NonNullable<MartinAdapterResult["execution"]>["diffStats"]>;
+export declare function createAdapterCapabilities(overrides?: Partial<NonNullable<MartinAdapter["metadata"]["capabilities"]>>): NonNullable<MartinAdapter["metadata"]["capabilities"]>;
+export declare function normalizeUsage(input: {
+    actualUsd?: number;
+    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[];
+export {};

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

@@ -0,0 +1,59 @@
+export function createAdapterCapabilities(overrides = {}) {
+    return {
+        preflight: true,
+        usageSettlement: false,
+        diffArtifacts: false,
+        structuredErrors: false,
+        cachingSignals: false,
+        workspaceMutations: true,
+        ...overrides
+    };
+}
+export function normalizeUsage(input) {
+    const provenance = input.provenance ??
+        (input.estimatedUsd !== undefined ? "estimated" : "actual");
+    const actualUsd = provenance === "estimated"
+        ? input.estimatedUsd ?? input.actualUsd ?? 0
+        : input.actualUsd ?? 0;
+    return {
+        actualUsd: roundUsd(actualUsd),
+        ...(input.estimatedUsd !== undefined
+            ? { estimatedUsd: roundUsd(input.estimatedUsd) }
+            : {}),
+        tokensIn: input.tokensIn ?? 0,
+        tokensOut: input.tokensOut ?? 0,
+        ...(input.cachedInputTokens !== undefined
+            ? { cachedInputTokens: input.cachedInputTokens }
+            : {}),
+        ...(input.reasoningTokensOut !== undefined
+            ? { reasoningTokensOut: input.reasoningTokensOut }
+            : {}),
+        provenance,
+        ...(input.providerSettlement ? { providerSettlement: input.providerSettlement } : {})
+    };
+}
+export function diffStatsFromNumstat(stdout) {
+    const lines = stdout
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    if (lines.length === 0) {
+        return undefined;
+    }
+    let filesChanged = 0;
+    let addedLines = 0;
+    let deletedLines = 0;
+    for (const line of lines) {
+        const [added, deleted] = line.split(/\s+/u);
+        filesChanged += 1;
+        addedLines += Number(added) || 0;
+        deletedLines += Number(deleted) || 0;
+    }
+    return { filesChanged, addedLines, deletedLines };
+}
+export function normalizeStructuredErrors(errors) {
+    return errors?.slice(0, 10) ?? [];
+}
+function roundUsd(value) {
+    return Math.round(value * 1_000_000) / 1_000_000;
+}

package/dist/vendor/adapters/adapters/src/stub-agent-cli.d.ts

@@ -0,0 +1,8 @@
+import type { MartinAdapter, MartinAdapterRequest, MartinAdapterResult } from "../../../core/index.js";
+export interface StubAgentCliAdapterOptions {
+    command: string[];
+    profile?: string;
+    label?: string;
+    responder?: (request: MartinAdapterRequest) => Promise<MartinAdapterResult> | MartinAdapterResult;
+}
+export declare function createStubAgentCliAdapter(options: StubAgentCliAdapterOptions): MartinAdapter;

package/dist/vendor/adapters/adapters/src/stub-agent-cli.js

@@ -0,0 +1,40 @@
+import { createAdapterCapabilities } from "./runtime-support.js";
+export function createStubAgentCliAdapter(options) {
+    const metadata = {
+        command: options.command.join(" "),
+        providerId: "agent-cli",
+        model: options.profile ?? options.command[0] ?? "default",
+        transport: "cli",
+        capabilities: createAdapterCapabilities(),
+        ...(options.profile ? { profile: options.profile } : {})
+    };
+    return {
+        adapterId: `agent-cli:${options.command.join(":")}`,
+        kind: "agent-cli",
+        label: options.label ?? `Stub agent CLI (${options.command.join(" ")})`,
+        metadata,
+        async execute(request) {
+            if (options.responder) {
+                return await options.responder(request);
+            }
+            return {
+                status: "failed",
+                summary: `Stub agent CLI ${options.command.join(" ")} did not execute a live session.`,
+                usage: {
+                    actualUsd: 0,
+                    tokensIn: 0,
+                    tokensOut: 0,
+                    provenance: "unavailable"
+                },
+                verification: {
+                    passed: false,
+                    summary: "No CLI execution was attempted."
+                },
+                failure: {
+                    message: `Agent CLI ${options.command.join(" ")} is not configured for live execution.`,
+                    classHint: "environment_mismatch"
+                }
+            };
+        }
+    };
+}

package/dist/vendor/adapters/adapters/src/stub-direct-provider.d.ts

@@ -0,0 +1,8 @@
+import type { MartinAdapter, MartinAdapterRequest, MartinAdapterResult } from "../../../core/index.js";
+export interface StubDirectProviderAdapterOptions {
+    providerId: string;
+    model: string;
+    label?: string;
+    responder?: (request: MartinAdapterRequest) => Promise<MartinAdapterResult> | MartinAdapterResult;
+}
+export declare function createStubDirectProviderAdapter(options: StubDirectProviderAdapterOptions): MartinAdapter;

package/dist/vendor/adapters/adapters/src/stub-direct-provider.js

@@ -0,0 +1,12 @@
+import { createDirectProviderAdapter } from "./direct-provider.js";
+export function createStubDirectProviderAdapter(options) {
+    return createDirectProviderAdapter({
+        providerId: options.providerId,
+        model: options.model,
+        label: options.label ?? `Stub direct provider (${options.providerId}/${options.model})`,
+        capabilities: {
+            workspaceMutations: false
+        },
+        responder: options.responder
+    });
+}

package/dist/vendor/adapters/adapters/src/verifier-only.d.ts

@@ -0,0 +1,9 @@
+import type { MartinAdapter } from "../../../core/index.js";
+import { type SpawnLike } from "./cli-bridge.js";
+export interface VerifierOnlyAdapterOptions {
+    workingDirectory?: string;
+    verifyTimeoutMs?: number;
+    label?: string;
+    spawnImpl?: SpawnLike;
+}
+export declare function createVerifierOnlyAdapter(options?: VerifierOnlyAdapterOptions): MartinAdapter;

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

@@ -0,0 +1,63 @@
+import { readGitChangedFiles, runVerification } from "./cli-bridge.js";
+import { createAdapterCapabilities, normalizeUsage } from "./runtime-support.js";
+export function createVerifierOnlyAdapter(options = {}) {
+    const workingDirectory = options.workingDirectory ?? process.cwd();
+    const verifyTimeoutMs = options.verifyTimeoutMs ?? 120_000;
+    return {
+        adapterId: "direct:verifier:verify-only",
+        kind: "direct-provider",
+        label: options.label ?? "Verifier-only adapter",
+        metadata: {
+            providerId: "verifier",
+            model: "verify-only",
+            transport: "cli",
+            capabilities: createAdapterCapabilities({
+                usageSettlement: true,
+                diffArtifacts: true
+            })
+        },
+        async execute(request) {
+            const shouldTrackVerifierWrites = request.context.verificationPlan.length > 0 ||
+                (request.context.verificationStack?.length ?? 0) > 0;
+            const baselineChangedFiles = shouldTrackVerifierWrites
+                ? new Set(await readGitChangedFiles(workingDirectory, 5_000))
+                : new Set();
+            const verification = await runVerification(request.context.verificationPlan, workingDirectory, verifyTimeoutMs, request.context.verificationStack, options.spawnImpl);
+            const changedFiles = shouldTrackVerifierWrites
+                ? (await readGitChangedFiles(workingDirectory, 5_000)).filter((file) => !baselineChangedFiles.has(file))
+                : [];
+            const execution = { changedFiles };
+            if (verification.passed) {
+                return {
+                    status: "completed",
+                    summary: changedFiles.length > 0
+                        ? `Verifier-only run completed but modified files: ${changedFiles.join(", ")}`
+                        : "Verifier-only run completed without file edits.",
+                    usage: normalizeUsage({
+                        actualUsd: 0,
+                        tokensIn: 0,
+                        tokensOut: 0,
+                        provenance: "actual"
+                    }),
+                    verification,
+                    execution
+                };
+            }
+            return {
+                status: "failed",
+                summary: "Verifier-only run failed.",
+                usage: normalizeUsage({
+                    actualUsd: 0,
+                    tokensIn: 0,
+                    tokensOut: 0,
+                    provenance: "actual"
+                }),
+                verification,
+                execution,
+                failure: {
+                    message: verification.summary
+                }
+            };
+        }
+    };
+}