martin-loop 0.1.4 → 1.3.0

package/dist/vendor/adapters/git-baseline.js

@@ -0,0 +1,233 @@
+import { createHash } from "node:crypto";
+import { runSubprocess } from "./cli-bridge.js";
+import { diffStatsFromNumstat } from "./runtime-support.js";
+export async function captureBaseline(options) {
+    const [startHeadSha, startTrackedStatus, startUntrackedSet] = await Promise.all([
+        readRequiredScalar(options.repoRoot, ["rev-parse", "HEAD"], options.timeoutMs, options.spawnImpl),
+        readOptionalStdout(options.repoRoot, ["status", "--porcelain=v1", "--untracked-files=no"], options.timeoutMs, options.spawnImpl),
+        readLines(options.repoRoot, ["ls-files", "--others", "--exclude-standard"], options.timeoutMs, options.spawnImpl)
+    ]);
+    const startTrackedSet = parsePorcelainTrackedPaths(startTrackedStatus);
+    const startTrackedDiffSha256 = await collectPathDiffHashes({
+        repoRoot: options.repoRoot,
+        baseRef: startHeadSha,
+        paths: startTrackedSet,
+        timeoutMs: options.timeoutMs,
+        spawnImpl: options.spawnImpl
+    });
+    return {
+        startHeadSha,
+        startTrackedStatus,
+        startTrackedSet,
+        startTrackedDiffSha256,
+        startUntrackedSet,
+        startTimestamp: new Date().toISOString(),
+        worktreeClean: startTrackedStatus.trim().length === 0 && startUntrackedSet.length === 0,
+        pilotRepoClass: options.pilotRepoClass ?? null
+    };
+}
+export async function normalizeAdapterGitState(options) {
+    const endHeadShaBeforeNormalization = await readRequiredScalar(options.repoRoot, ["rev-parse", "HEAD"], options.timeoutMs, options.spawnImpl);
+    const normalizationApplied = endHeadShaBeforeNormalization !== options.baseline.startHeadSha;
+    if (!normalizationApplied) {
+        return {
+            startHeadSha: options.baseline.startHeadSha,
+            endHeadShaBeforeNormalization,
+            normalizationApplied: false,
+            normalizationMode: "none",
+            normalizationSucceeded: true,
+            headAfterNormalization: endHeadShaBeforeNormalization
+        };
+    }
+    const resetResult = await runSubprocess("git", ["reset", "--mixed", options.baseline.startHeadSha], {
+        cwd: options.repoRoot,
+        timeoutMs: options.timeoutMs,
+        spawnImpl: options.spawnImpl
+    });
+    const headAfterNormalization = resetResult.exitCode === 0
+        ? await readRequiredScalar(options.repoRoot, ["rev-parse", "HEAD"], options.timeoutMs, options.spawnImpl)
+        : endHeadShaBeforeNormalization;
+    return {
+        startHeadSha: options.baseline.startHeadSha,
+        endHeadShaBeforeNormalization,
+        normalizationApplied: true,
+        normalizationMode: "reset_mixed_to_start_head",
+        normalizationSucceeded: resetResult.exitCode === 0 && headAfterNormalization === options.baseline.startHeadSha,
+        headAfterNormalization
+    };
+}
+export async function collectScopeSurface(options) {
+    const [nameStatusResult, numstatResult, endUntrackedSet] = await Promise.all([
+        runSubprocess("git", ["diff", "--name-status", "--no-renames", options.baseline.startHeadSha], {
+            cwd: options.repoRoot,
+            timeoutMs: options.timeoutMs,
+            spawnImpl: options.spawnImpl
+        }),
+        runSubprocess("git", ["diff", "--numstat", "--no-renames", options.baseline.startHeadSha], {
+            cwd: options.repoRoot,
+            timeoutMs: options.timeoutMs,
+            spawnImpl: options.spawnImpl
+        }),
+        readLines(options.repoRoot, ["ls-files", "--others", "--exclude-standard"], options.timeoutMs, options.spawnImpl)
+    ]);
+    const trackedChangedPaths = [];
+    const deletedPaths = [];
+    const changedBaselinePaths = [];
+    const seenTracked = new Set();
+    const seenDeleted = new Set();
+    const baselineTracked = new Set(options.baseline.startTrackedSet.map(normalizeGitPath));
+    const candidateTrackedPaths = [];
+    if (nameStatusResult.exitCode === 0) {
+        for (const rawLine of splitLines(nameStatusResult.stdout)) {
+            const parts = rawLine.split(/\t+/u).map((entry) => normalizeGitPath(entry));
+            const status = parts[0]?.trim() ?? "";
+            const candidatePath = parts.at(-1);
+            if (!status || !candidatePath) {
+                continue;
+            }
+            if (status.startsWith("D")) {
+                candidateTrackedPaths.push({ path: candidatePath, deleted: true });
+                continue;
+            }
+            candidateTrackedPaths.push({ path: candidatePath, deleted: false });
+        }
+    }
+    const endTrackedDiffSha256 = await collectPathDiffHashes({
+        repoRoot: options.repoRoot,
+        baseRef: options.baseline.startHeadSha,
+        paths: candidateTrackedPaths.map((candidate) => candidate.path),
+        timeoutMs: options.timeoutMs,
+        spawnImpl: options.spawnImpl
+    });
+    for (const candidate of candidateTrackedPaths) {
+        const baselineHash = options.baseline.startTrackedDiffSha256[candidate.path];
+        const endHash = endTrackedDiffSha256[candidate.path];
+        const changedSinceBaseline = !baselineTracked.has(candidate.path) ||
+            baselineHash === undefined ||
+            endHash === undefined ||
+            baselineHash !== endHash;
+        if (!changedSinceBaseline) {
+            continue;
+        }
+        if (baselineTracked.has(candidate.path)) {
+            changedBaselinePaths.push(candidate.path);
+        }
+        if (candidate.deleted) {
+            if (!seenDeleted.has(candidate.path)) {
+                seenDeleted.add(candidate.path);
+                deletedPaths.push(candidate.path);
+            }
+            continue;
+        }
+        if (!seenTracked.has(candidate.path)) {
+            seenTracked.add(candidate.path);
+            trackedChangedPaths.push(candidate.path);
+        }
+    }
+    const startingUntracked = new Set(options.baseline.startUntrackedSet.map(normalizeGitPath));
+    const newUntrackedPaths = endUntrackedSet
+        .map(normalizeGitPath)
+        .filter((entry) => !startingUntracked.has(entry));
+    const allChangedPaths = uniquePaths([
+        ...trackedChangedPaths,
+        ...deletedPaths,
+        ...newUntrackedPaths
+    ]);
+    const diffStats = allChangedPaths.length > 0
+        ? await collectDiffStats({
+            repoRoot: options.repoRoot,
+            baseRef: options.baseline.startHeadSha,
+            paths: allChangedPaths,
+            fallbackStdout: numstatResult.stdout,
+            fallbackExitCode: numstatResult.exitCode,
+            timeoutMs: options.timeoutMs,
+            spawnImpl: options.spawnImpl
+        })
+        : undefined;
+    return {
+        trackedChangedPaths,
+        deletedPaths,
+        newUntrackedPaths,
+        allChangedPaths,
+        changedBaselinePaths: uniquePaths(changedBaselinePaths),
+        baselineWasClean: options.baseline.worktreeClean,
+        noCodeChange: allChangedPaths.length === 0,
+        ...(diffStats ? { diffStats } : {})
+    };
+}
+function uniquePaths(paths) {
+    return [...new Set(paths.map(normalizeGitPath).filter(Boolean))];
+}
+function splitLines(stdout) {
+    return stdout
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+function parsePorcelainTrackedPaths(status) {
+    const paths = [];
+    for (const line of status.split(/\r?\n/u).filter(Boolean)) {
+        const code = line.slice(0, 2);
+        if (code === "??" || code === "!!") {
+            continue;
+        }
+        const rawPath = line.slice(3).trim();
+        if (!rawPath) {
+            continue;
+        }
+        for (const path of rawPath.split(" -> ")) {
+            paths.push(path);
+        }
+    }
+    return uniquePaths(paths);
+}
+async function collectPathDiffHashes(options) {
+    const hashes = {};
+    for (const path of uniquePaths(options.paths)) {
+        const result = await runSubprocess("git", ["diff", "--binary", options.baseRef, "--", path], {
+            cwd: options.repoRoot,
+            timeoutMs: options.timeoutMs,
+            spawnImpl: options.spawnImpl
+        });
+        hashes[path] = sha256Text(JSON.stringify({
+            stdout: result.stdout,
+            stderr: result.exitCode === 0 ? "" : result.stderr,
+            exitCode: result.exitCode
+        }));
+    }
+    return hashes;
+}
+async function collectDiffStats(options) {
+    const result = await runSubprocess("git", ["diff", "--numstat", "--no-renames", options.baseRef, "--", ...uniquePaths(options.paths)], {
+        cwd: options.repoRoot,
+        timeoutMs: options.timeoutMs,
+        spawnImpl: options.spawnImpl
+    });
+    if (result.exitCode === 0) {
+        return diffStatsFromNumstat(result.stdout);
+    }
+    return options.fallbackExitCode === 0 ? diffStatsFromNumstat(options.fallbackStdout) : undefined;
+}
+function normalizeGitPath(path) {
+    return path.replace(/\\/gu, "/").trim();
+}
+function sha256Text(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+async function readRequiredScalar(repoRoot, args, timeoutMs, spawnImpl) {
+    const result = await runSubprocess("git", args, { cwd: repoRoot, timeoutMs, spawnImpl });
+    if (result.exitCode !== 0) {
+        const detail = result.stderr.trim() || result.stdout.trim() || args.join(" ");
+        throw new Error(`Git baseline command failed: ${detail}`);
+    }
+    return result.stdout.trim();
+}
+async function readOptionalStdout(repoRoot, args, timeoutMs, spawnImpl) {
+    const result = await runSubprocess("git", args, { cwd: repoRoot, timeoutMs, spawnImpl });
+    return result.exitCode === 0 ? result.stdout : "";
+}
+async function readLines(repoRoot, args, timeoutMs, spawnImpl) {
+    const result = await runSubprocess("git", args, { cwd: repoRoot, timeoutMs, spawnImpl });
+    return result.exitCode === 0 ? splitLines(result.stdout) : [];
+}
+//# sourceMappingURL=git-baseline.js.map

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

@@ -2,4 +2,5 @@ export { createDirectProviderAdapter, type DirectProviderAdapterOptions } from "
 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 { createVerifierOnlyAdapter, type VerifierOnlyAdapterOptions } from "./verifier-only.js";
 export type { SpawnLike, SubprocessResult, VerificationOutcome } from "./cli-bridge.js";

package/dist/vendor/adapters/index.js

@@ -2,4 +2,5 @@ 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 { createVerifierOnlyAdapter } from "./verifier-only.js";
 //# sourceMappingURL=index.js.map

package/dist/vendor/adapters/openrouter-adapter.d.ts

@@ -0,0 +1,15 @@
+/**
+ * OpenRouter Adapter — real LLM-backed coding agent via OpenRouter API.
+ *
+ * Uses function-calling (tool use) to give the LLM read_file, write_file,
+ * and run_command tools. Loops until verification passes or max turns reached.
+ *
+ * Compatible with any OpenRouter model that supports function calling:
+ * openai/gpt-4o, openai/gpt-4o-mini, anthropic/claude-3.5-sonnet, etc.
+ */
+import type { MartinAdapter } from "../core/index.js";
+export declare function createOpenRouterAdapter(options: {
+    apiKey: string;
+    model?: string;
+    maxTurns?: number;
+}): MartinAdapter;

package/dist/vendor/adapters/openrouter-adapter.js

@@ -0,0 +1,302 @@
+/**
+ * OpenRouter Adapter — real LLM-backed coding agent via OpenRouter API.
+ *
+ * Uses function-calling (tool use) to give the LLM read_file, write_file,
+ * and run_command tools. Loops until verification passes or max turns reached.
+ *
+ * Compatible with any OpenRouter model that supports function calling:
+ * openai/gpt-4o, openai/gpt-4o-mini, anthropic/claude-3.5-sonnet, etc.
+ */
+import { execFile, exec } from "node:child_process";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { join, dirname, resolve } from "node:path";
+import { promisify } from "node:util";
+const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
+const OPENROUTER_URL = "https://openrouter.ai/api/v1/chat/completions";
+const MAX_TOOL_TURNS = 20;
+// ─── Tool definitions ─────────────────────────────────────────────────────────
+const TOOLS = [
+    {
+        type: "function",
+        function: {
+            name: "read_file",
+            description: "Read the contents of a file in the repository.",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "File path relative to repo root" }
+                },
+                required: ["path"]
+            }
+        }
+    },
+    {
+        type: "function",
+        function: {
+            name: "write_file",
+            description: "Write content to a file. Creates parent directories as needed.",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "File path relative to repo root" },
+                    content: { type: "string", description: "File content to write" }
+                },
+                required: ["path", "content"]
+            }
+        }
+    },
+    {
+        type: "function",
+        function: {
+            name: "run_command",
+            description: "Run a shell command in the repo root. Returns stdout + stderr.",
+            parameters: {
+                type: "object",
+                properties: {
+                    command: { type: "string", description: "Shell command to execute" }
+                },
+                required: ["command"]
+            }
+        }
+    },
+    {
+        type: "function",
+        function: {
+            name: "task_complete",
+            description: "Signal that the task is complete and all acceptance criteria are met.",
+            parameters: {
+                type: "object",
+                properties: {
+                    summary: { type: "string", description: "Summary of what was accomplished" }
+                },
+                required: ["summary"]
+            }
+        }
+    }
+];
+// ─── Tool executor ─────────────────────────────────────────────────────────────
+async function executeTool(name, args, repoRoot) {
+    try {
+        switch (name) {
+            case "read_file": {
+                const fullPath = resolve(join(repoRoot, args["path"] ?? ""));
+                // Prevent path traversal outside repoRoot
+                if (!fullPath.startsWith(resolve(repoRoot))) {
+                    return `BLOCKED: Cannot read files outside repo root`;
+                }
+                const content = await readFile(fullPath, "utf8").catch(e => `ERROR: ${e.message}`);
+                return content;
+            }
+            case "write_file": {
+                const fullPath = resolve(join(repoRoot, args["path"] ?? ""));
+                const resolvedRoot = resolve(repoRoot);
+                // Prevent path traversal outside repoRoot
+                if (!fullPath.startsWith(resolvedRoot)) {
+                    return `BLOCKED: Cannot write files outside repo root (attempted: ${args["path"]})`;
+                }
+                // Block writes to dependency management files
+                const DENIED_WRITE_PATTERNS = /\b(package\.json|package-lock\.json|pnpm-lock\.yaml|yarn\.lock|bun\.lockb)$/;
+                if (DENIED_WRITE_PATTERNS.test(fullPath)) {
+                    return `BLOCKED: Cannot modify dependency files (${args["path"]}). Use existing types from the source code.`;
+                }
+                await mkdir(dirname(fullPath), { recursive: true });
+                await writeFile(fullPath, args["content"] ?? "", "utf8");
+                return `OK: wrote ${args["path"]}`;
+            }
+            case "run_command": {
+                const cmd = args["command"] ?? "";
+                // Block package installation commands — they modify dependency files and trigger the safety leash
+                const BLOCKED_PATTERNS = /\b(npm|pnpm|yarn|bun)\s+(install|add|i\b|ci\b)/i;
+                if (BLOCKED_PATTERNS.test(cmd)) {
+                    return "BLOCKED: Package installation commands are not allowed. Use existing imports and types from the source file.";
+                }
+                const { stdout, stderr } = await execAsync(cmd, { cwd: repoRoot, timeout: 30_000 }).catch(e => ({
+                    stdout: "",
+                    stderr: e.message
+                }));
+                return [stdout, stderr].filter(Boolean).join("\n").slice(0, 4000);
+            }
+            case "task_complete":
+                return `COMPLETE: ${args["summary"]}`;
+            default:
+                return `ERROR: unknown tool ${name}`;
+        }
+    }
+    catch (e) {
+        return `ERROR: ${e.message}`;
+    }
+}
+// ─── Verification runner ──────────────────────────────────────────────────────
+async function runVerification(verificationPlan, repoRoot) {
+    const results = [];
+    let allPassed = true;
+    for (const cmd of verificationPlan) {
+        try {
+            const { stdout, stderr } = await execAsync(cmd, { cwd: repoRoot, timeout: 60_000 });
+            const out = [stdout, stderr].filter(Boolean).join(" ").slice(0, 500);
+            results.push(`✓ ${cmd}: ${out || "OK"}`);
+        }
+        catch (e) {
+            allPassed = false;
+            results.push(`✗ ${cmd}: ${e.stderr?.slice(0, 300) ?? e.message.slice(0, 300)}`);
+        }
+    }
+    return { passed: allPassed, summary: results.join("\n") };
+}
+// ─── Main adapter function ────────────────────────────────────────────────────
+export function createOpenRouterAdapter(options) {
+    const model = options.model ?? "openai/gpt-4o-mini";
+    const maxTurns = options.maxTurns ?? MAX_TOOL_TURNS;
+    return {
+        adapterId: `openrouter:${model}`,
+        kind: "direct-provider",
+        label: `OpenRouter (${model})`,
+        metadata: {
+            providerId: "openrouter",
+            model,
+            transport: "routed_http",
+            capabilities: {
+                usageSettlement: true,
+                structuredErrors: true,
+                diffArtifacts: false
+            }
+        },
+        withModel(newModel) {
+            return createOpenRouterAdapter({ ...options, model: newModel });
+        },
+        async execute(request) {
+            const repoRoot = request.context.repoRoot ?? process.cwd();
+            const startTime = Date.now();
+            let tokensIn = 0;
+            let tokensOut = 0;
+            const systemPrompt = [
+                "You are an expert software engineer completing coding tasks.",
+                "You have tools to read files, write files, and run commands.",
+                "Your goal: complete the task described in the user message.",
+                "Strategy:",
+                "1. Read relevant existing files first to understand the codebase",
+                "2. Make the required changes using write_file",
+                "3. Run verification commands to confirm success",
+                "4. Call task_complete when all acceptance criteria are met",
+                "",
+                "IMPORTANT: Only modify files explicitly required by the task.",
+                "Do not modify: leash.ts, policy.ts, grounding.ts, contracts/src/index.ts",
+                "",
+                `Repo root: ${repoRoot}`,
+                `Remaining budget: $${request.context.remainingBudgetUsd.toFixed(2)}`,
+                `Remaining iterations: ${request.context.remainingIterations}`
+            ].join("\n");
+            const userMessage = [
+                `# Task: ${request.context.taskTitle}`,
+                "",
+                `## Objective`,
+                request.context.objective,
+                "",
+                ...(request.context.verificationPlan.length > 0 ? [
+                    "## Verification (must pass)",
+                    ...request.context.verificationPlan.map(v => `- ${v}`)
+                ] : []),
+                ...(request.context.acceptanceCriteria?.length ? [
+                    "",
+                    "## Acceptance Criteria",
+                    ...request.context.acceptanceCriteria.map(c => `- ${c}`)
+                ] : []),
+                ...(request.previousAttempts.length > 0 ? [
+                    "",
+                    `## Previous attempts (${request.previousAttempts.length} failed)`,
+                    request.previousAttempts.slice(-2).map(a => `- ${a.summary ?? "failed"}`).join("\n")
+                ] : []),
+                "",
+                request.context.focus
+            ].join("\n");
+            const messages = [
+                { role: "system", content: systemPrompt },
+                { role: "user", content: userMessage }
+            ];
+            let completionSummary = "Agent did not complete.";
+            let taskCompleted = false;
+            for (let turn = 0; turn < maxTurns; turn++) {
+                const body = JSON.stringify({
+                    model,
+                    messages,
+                    tools: TOOLS,
+                    tool_choice: "auto",
+                    max_tokens: 4096,
+                    temperature: 0.1
+                });
+                const res = await fetch(OPENROUTER_URL, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        "Authorization": `Bearer ${options.apiKey}`,
+                        "HTTP-Referer": "https://martin-loop.dev",
+                        "X-Title": "Martin Loop Agent"
+                    },
+                    body
+                }).catch(e => { throw new Error(`OpenRouter fetch failed: ${e.message}`); });
+                if (!res.ok) {
+                    const text = await res.text().catch(() => "");
+                    throw new Error(`OpenRouter API error ${res.status}: ${text.slice(0, 200)}`);
+                }
+                const data = await res.json();
+                tokensIn += data.usage?.prompt_tokens ?? 0;
+                tokensOut += data.usage?.completion_tokens ?? 0;
+                const choice = data.choices[0];
+                if (!choice)
+                    break;
+                const assistantMsg = choice.message;
+                messages.push({ role: "assistant", content: assistantMsg.content, tool_calls: assistantMsg.tool_calls });
+                if (choice.finish_reason === "stop" || !assistantMsg.tool_calls?.length) {
+                    completionSummary = assistantMsg.content ?? "Task complete.";
+                    break;
+                }
+                // Execute tool calls
+                for (const toolCall of assistantMsg.tool_calls ?? []) {
+                    let args = {};
+                    try {
+                        args = JSON.parse(toolCall.function.arguments);
+                    }
+                    catch {
+                        args = {};
+                    }
+                    const result = await executeTool(toolCall.function.name, args, repoRoot);
+                    if (toolCall.function.name === "task_complete") {
+                        completionSummary = args["summary"] ?? "Task completed successfully.";
+                        taskCompleted = true;
+                    }
+                    messages.push({
+                        role: "tool",
+                        tool_call_id: toolCall.id,
+                        name: toolCall.function.name,
+                        content: result
+                    });
+                }
+                if (taskCompleted)
+                    break;
+            }
+            // Run verification
+            const verification = await runVerification(request.context.verificationPlan, repoRoot);
+            // Compute cost (gpt-4o-mini pricing: $0.15/1M input, $0.60/1M output)
+            const COST_PER_1K = { input: 0.00015, output: 0.0006 };
+            const costUsd = (tokensIn / 1000) * COST_PER_1K.input + (tokensOut / 1000) * COST_PER_1K.output;
+            return {
+                status: verification.passed ? "completed" : "failed",
+                summary: completionSummary,
+                usage: {
+                    actualUsd: Math.round(costUsd * 100000) / 100000,
+                    tokensIn,
+                    tokensOut,
+                    provenance: "actual"
+                },
+                verification,
+                ...(verification.passed ? {} : {
+                    failure: {
+                        message: `Verification failed: ${verification.summary.slice(0, 300)}`
+                    }
+                })
+            };
+        }
+    };
+}
+//# sourceMappingURL=openrouter-adapter.js.map

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

@@ -0,0 +1,48 @@
+/**
+ * Token usage extraction and cost calculation for Claude CLI JSON output.
+ *
+ * Extracted from claude-cli.ts so it can be unit-tested without spawning
+ * a real subprocess. All exports are stable internal APIs.
+ */
+import type { MartinAdapterResult } from "../core/index.js";
+export declare const BLENDED_INPUT_COST_PER_1K = 0.003;
+export declare const BLENDED_OUTPUT_COST_PER_1K = 0.012;
+/** Per-model cost overrides. Falls back to blended average when model unknown. */
+export declare const MODEL_PRICING: Record<string, {
+    inputPer1K: number;
+    outputPer1K: number;
+}>;
+export interface ClaudeJsonOutput {
+    type: string;
+    subtype?: string;
+    result?: string;
+    error?: string;
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        cacheReadInputTokens?: number;
+        cacheCreationInputTokens?: number;
+        /**
+         * Extended-thinking output tokens from Claude CLI when extended thinking is
+         * enabled. Billed at the same per-token rate as regular output tokens but
+         * tracked separately for cost transparency.
+         */
+        thinkingOutputTokens?: number;
+    };
+}
+/**
+ * Parse a Claude CLI JSON output block into a normalised MartinUsage object.
+ *
+ * Thinking tokens (when present) are:
+ *   - stored separately as `thinkingTokensOut`
+ *   - billed at the same output token rate and included in `actualUsd`
+ *   - NOT added to `tokensOut` (regular output tokens stay clean)
+ */
+export declare function extractUsage(parsed: ClaudeJsonOutput | undefined, modelLabel: string | undefined): MartinAdapterResult["usage"] & {
+    thinkingTokensOut: number;
+};
+/**
+ * Alias exported for unit tests that import directly from this module.
+ * Identical to `extractUsage` — no test-only behaviour.
+ */
+export declare const extractUsageForTest: typeof extractUsage;

package/dist/vendor/adapters/usage.js

@@ -0,0 +1,66 @@
+import { normalizeUsage } from "./runtime-support.js";
+// ---------------------------------------------------------------------------
+// Model pricing
+// ---------------------------------------------------------------------------
+export const BLENDED_INPUT_COST_PER_1K = 0.003; // $/1K input tokens
+export const BLENDED_OUTPUT_COST_PER_1K = 0.012; // $/1K output tokens
+/** Per-model cost overrides. Falls back to blended average when model unknown. */
+export const MODEL_PRICING = {
+    "claude-opus-4-6": { inputPer1K: 0.015, outputPer1K: 0.075 },
+    "claude-sonnet-4-6": { inputPer1K: 0.003, outputPer1K: 0.015 },
+    "claude-haiku-4-5-20251001": { inputPer1K: 0.00025, outputPer1K: 0.00125 },
+    // Legacy short names
+    "claude-haiku-4-5": { inputPer1K: 0.00025, outputPer1K: 0.00125 },
+    "claude-opus": { inputPer1K: 0.015, outputPer1K: 0.075 },
+    "claude-sonnet": { inputPer1K: 0.003, outputPer1K: 0.015 },
+    "claude-haiku": { inputPer1K: 0.00025, outputPer1K: 0.00125 },
+};
+// ---------------------------------------------------------------------------
+// Usage extraction
+// ---------------------------------------------------------------------------
+/**
+ * Parse a Claude CLI JSON output block into a normalised MartinUsage object.
+ *
+ * Thinking tokens (when present) are:
+ *   - stored separately as `thinkingTokensOut`
+ *   - billed at the same output token rate and included in `actualUsd`
+ *   - NOT added to `tokensOut` (regular output tokens stay clean)
+ */
+export function extractUsage(parsed, modelLabel) {
+    if (!parsed?.usage) {
+        return {
+            ...normalizeUsage({ actualUsd: 0, tokensIn: 0, tokensOut: 0, provenance: "unavailable" }),
+            thinkingTokensOut: 0
+        };
+    }
+    const rawIn = parsed.usage.inputTokens ?? 0;
+    const rawOut = parsed.usage.outputTokens ?? 0;
+    const cacheRead = parsed.usage.cacheReadInputTokens ?? 0;
+    const cacheCreate = parsed.usage.cacheCreationInputTokens ?? 0;
+    const thinkingOut = parsed.usage.thinkingOutputTokens ?? 0;
+    // tokensIn = all input-side tokens (prompt + cache hits + cache writes)
+    const tokensIn = rawIn + cacheRead + cacheCreate;
+    // tokensOut = regular completion tokens only (thinking tracked separately)
+    const tokensOut = rawOut;
+    const pricing = (modelLabel ? MODEL_PRICING[modelLabel] : undefined) ??
+        { inputPer1K: BLENDED_INPUT_COST_PER_1K, outputPer1K: BLENDED_OUTPUT_COST_PER_1K };
+    // Thinking tokens billed at output token rate per Anthropic billing docs
+    const actualUsd = (tokensIn / 1000) * pricing.inputPer1K +
+        (tokensOut / 1000) * pricing.outputPer1K +
+        (thinkingOut / 1000) * pricing.outputPer1K;
+    return {
+        ...normalizeUsage({
+            actualUsd: Number(actualUsd.toFixed(6)),
+            tokensIn,
+            tokensOut,
+            provenance: "actual"
+        }),
+        thinkingTokensOut: thinkingOut
+    };
+}
+/**
+ * Alias exported for unit tests that import directly from this module.
+ * Identical to `extractUsage` — no test-only behaviour.
+ */
+export const extractUsageForTest = extractUsage;
+//# sourceMappingURL=usage.js.map