@otto-code/brain 0.7.5

package/dist/bench/curated-repos.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Curated presets for the mined-repo (SWE-bench-style) benchmark flow.
+ *
+ * The raw `otto brain bench --repo-*` flags mine any workspace on demand; these
+ * presets name a few known-good, dependency-light workspaces so a repeatable
+ * "curated" run is one flag instead of five. Each preset still needs the caller
+ * to point `--repo-dir` at a working copy to mine, because the harness resets
+ * that copy hard (git reset --hard + git clean -fd) between tasks - it must never
+ * be aimed at a checkout with work you care about.
+ *
+ * Presets target this repo's own TypeScript/vitest workspaces (the miner keys off
+ * `.test.ts` companions), so the flow runs out of the box against a spare
+ * otto-code clone.
+ */
+/** One curated mining preset. */
+export interface CuratedRepo {
+    /** Short handle used on the command line (`--curated <name>`). */
+    name: string;
+    /** npm workspace name, e.g. `@otto-code/protocol`. */
+    workspace: string;
+    /** Workspace path relative to the repo root, e.g. `packages/protocol`. */
+    workspaceDir: string;
+    /** Git ref whose history is mined for fix commits. */
+    ref: string;
+    /** How many mined tasks to run. */
+    maxTasks: number;
+    /** One-line note shown in the preset listing. */
+    note: string;
+}
+export declare const CURATED_REPOS: CuratedRepo[];
+/** Look up a curated preset by its handle. */
+export declare function findCuratedRepo(name: string): CuratedRepo | null;
+/** A one-per-line listing of the available presets, for help/error text. */
+export declare function describeCuratedRepos(): string;
+//# sourceMappingURL=curated-repos.d.ts.map

package/dist/bench/curated-repos.js

@@ -0,0 +1,41 @@
+/**
+ * Curated presets for the mined-repo (SWE-bench-style) benchmark flow.
+ *
+ * The raw `otto brain bench --repo-*` flags mine any workspace on demand; these
+ * presets name a few known-good, dependency-light workspaces so a repeatable
+ * "curated" run is one flag instead of five. Each preset still needs the caller
+ * to point `--repo-dir` at a working copy to mine, because the harness resets
+ * that copy hard (git reset --hard + git clean -fd) between tasks - it must never
+ * be aimed at a checkout with work you care about.
+ *
+ * Presets target this repo's own TypeScript/vitest workspaces (the miner keys off
+ * `.test.ts` companions), so the flow runs out of the box against a spare
+ * otto-code clone.
+ */
+export const CURATED_REPOS = [
+    {
+        name: "protocol",
+        workspace: "@otto-code/protocol",
+        workspaceDir: "packages/protocol",
+        ref: "origin/main",
+        maxTasks: 3,
+        note: "schema/validation workspace — fast suite, no heavy deps",
+    },
+    {
+        name: "brain",
+        workspace: "@otto-code/brain",
+        workspaceDir: "packages/brain",
+        ref: "origin/main",
+        maxTasks: 3,
+        note: "the brain package itself — pure-logic tests (vram, gguf, bench)",
+    },
+];
+/** Look up a curated preset by its handle. */
+export function findCuratedRepo(name) {
+    return CURATED_REPOS.find((r) => r.name === name) ?? null;
+}
+/** A one-per-line listing of the available presets, for help/error text. */
+export function describeCuratedRepos() {
+    return CURATED_REPOS.map((r) => `  ${r.name.padEnd(10)} ${r.workspace} — ${r.note}`).join("\n");
+}
+//# sourceMappingURL=curated-repos.js.map

package/dist/bench/health.d.ts

@@ -0,0 +1,50 @@
+/** One nvidia-smi sample. */
+export interface GpuSample {
+    util: number | null;
+    temp: number | null;
+    power: number | null;
+    clock: number | null;
+    vramMiB: number | null;
+    thermal: boolean;
+    powerBrake: boolean;
+}
+/** Aggregate of a series of numeric samples. */
+export interface Aggregate {
+    avg: number;
+    min: number;
+    max: number;
+}
+/** Raw samples collected during a run. */
+export interface HealthSamples {
+    gpu: GpuSample[];
+    cpu: number[];
+    ram: number[];
+}
+/** Summary of system health across a run. */
+export interface HealthSummary {
+    samples: number;
+    gpuUtilPct: Aggregate | null;
+    tempC: Aggregate | null;
+    powerW: Aggregate | null;
+    clockMHz: Aggregate | null;
+    vramUsedMiB: Aggregate | null;
+    cpuPct: Aggregate | null;
+    ramUsedBytes: Aggregate | null;
+    thermalThrottle: boolean;
+    powerThrottle: boolean;
+}
+/** A running sampler; call stop() to end it and get the summary. */
+export interface HealthHandle {
+    stop(): HealthSummary;
+}
+/** Collapse raw samples into the summary stored on the result. */
+export declare function summarize(samples: HealthSamples): HealthSummary;
+/**
+ * Begin sampling; returns a handle with stop() that returns the summary.
+ * Sampling failures (no GPU, nvidia-smi missing) degrade to empty aggregates
+ * rather than throwing — health is diagnostic, never a reason to fail a bench.
+ */
+export declare function start({ intervalMs }?: {
+    intervalMs?: number;
+}): HealthHandle;
+//# sourceMappingURL=health.d.ts.map

package/dist/bench/health.js

@@ -0,0 +1,112 @@
+import os from "node:os";
+import { execFile } from "node:child_process";
+import { createCpuSampler } from "../sysmon.js";
+/**
+ * System-health sampling for a benchmark run.
+ *
+ * A score is only trustworthy if the machine was in a comparable state when it
+ * was measured — a thermal-throttled or power-capped GPU produces a slower,
+ * lower run that says nothing about the model. So we sample GPU/CPU/RAM through
+ * the run and summarise it alongside the result, and flag when nvidia-smi itself
+ * reports a thermal or power slowdown (more reliable than inferring one from a
+ * clock dip, since the GPU also idles between tasks).
+ */
+const FIELDS = [
+    "utilization.gpu",
+    "temperature.gpu",
+    "power.draw",
+    "clocks.sm",
+    "memory.used",
+    "clocks_throttle_reasons.sw_thermal_slowdown",
+    "clocks_throttle_reasons.hw_thermal_slowdown",
+    "clocks_throttle_reasons.hw_power_brake_slowdown",
+];
+function sampleGpu() {
+    return new Promise((resolve) => {
+        execFile("nvidia-smi", [`--query-gpu=${FIELDS.join(",")}`, "--format=csv,noheader,nounits"], { timeout: 4000, windowsHide: true }, (error, stdout) => {
+            if (error) {
+                resolve(null);
+                return;
+            }
+            const line = String(stdout).trim().split(/\r?\n/)[0];
+            if (!line) {
+                resolve(null);
+                return;
+            }
+            const c = line.split(",").map((s) => s.trim());
+            const num = (v) => {
+                const n = Number(v);
+                return Number.isFinite(n) ? n : null;
+            };
+            const active = (v) => /active/i.test(v) && !/not\s*active/i.test(v);
+            resolve({
+                util: num(c[0]),
+                temp: num(c[1]),
+                power: num(c[2]),
+                clock: num(c[3]),
+                vramMiB: num(c[4]),
+                thermal: active(c[5]) || active(c[6]),
+                powerBrake: active(c[7]),
+            });
+        });
+    });
+}
+function agg(values) {
+    const nums = values.filter((v) => typeof v === "number" && Number.isFinite(v));
+    if (!nums.length)
+        return null;
+    const sum = nums.reduce((a, b) => a + b, 0);
+    return {
+        avg: Math.round((sum / nums.length) * 10) / 10,
+        min: Math.min(...nums),
+        max: Math.max(...nums),
+    };
+}
+/** Collapse raw samples into the summary stored on the result. */
+export function summarize(samples) {
+    const gpu = samples.gpu || [];
+    return {
+        samples: gpu.length,
+        gpuUtilPct: agg(gpu.map((s) => s.util)),
+        tempC: agg(gpu.map((s) => s.temp)),
+        powerW: agg(gpu.map((s) => s.power)),
+        clockMHz: agg(gpu.map((s) => s.clock)),
+        vramUsedMiB: agg(gpu.map((s) => s.vramMiB)),
+        cpuPct: agg(samples.cpu || []),
+        ramUsedBytes: agg(samples.ram || []),
+        thermalThrottle: gpu.some((s) => s.thermal),
+        powerThrottle: gpu.some((s) => s.powerBrake),
+    };
+}
+/**
+ * Begin sampling; returns a handle with stop() that returns the summary.
+ * Sampling failures (no GPU, nvidia-smi missing) degrade to empty aggregates
+ * rather than throwing — health is diagnostic, never a reason to fail a bench.
+ */
+export function start({ intervalMs = 1000 } = {}) {
+    const samples = { gpu: [], cpu: [], ram: [] };
+    const cpu = createCpuSampler();
+    cpu(); // establish the CPU baseline
+    let stopped = false;
+    const tick = async () => {
+        if (stopped)
+            return;
+        const gpu = await sampleGpu();
+        if (gpu)
+            samples.gpu.push(gpu);
+        const busy = cpu();
+        if (typeof busy === "number")
+            samples.cpu.push(busy * 100);
+        samples.ram.push(os.totalmem() - os.freemem());
+    };
+    const timer = setInterval(tick, intervalMs);
+    tick();
+    return {
+        stop() {
+            stopped = true;
+            clearInterval(timer);
+            return summarize(samples);
+        },
+    };
+}
+//# sourceMappingURL=health.js.map

package/dist/bench/index.d.ts

@@ -0,0 +1,103 @@
+import type { Task } from "./tasks.js";
+import type { Profile } from "../config/schema.js";
+/**
+ * Fast, locally-verifiable agentic-coding suite.
+ *
+ * This is deliberately NOT a replacement for SWE-bench or Aider Polyglot -
+ * those run hundreds of multi-turn exercises and take hours per model. This is
+ * the triage stage: a few minutes per model, enough to rank a shelf of quant
+ * variants and to catch the system-level failures (reasoning runaway, VRAM
+ * spill, throughput collapse at depth) that model-level leaderboards never
+ * measure because they do not know your hardware.
+ *
+ * Use it to pick finalists, then run a full public benchmark on those.
+ */
+export declare const DEFAULT_DEPTHS: number[];
+/** A progress event emitted as the suite runs. */
+export interface ProgressEvent {
+    phase: "start" | "done" | "failed";
+    task?: string;
+    title?: string;
+    id?: string;
+    category?: string;
+    weight?: number;
+    description?: string;
+    score?: number;
+    summary?: string;
+    detail?: unknown;
+    seconds?: number;
+    error?: string | null;
+}
+/** Options for {@link runSuite}. */
+export interface RunSuiteOptions {
+    host?: string;
+    port?: number;
+    execute?: boolean;
+    depths?: number[];
+    only?: string[] | null;
+    concurrency?: number;
+    /**
+     * The resident model's reasoning-token budget, forwarded to tasks that must
+     * size their response cap above it (the concurrency throughput task).
+     */
+    reasoningBudget?: number | null;
+    /** The resident model's loaded context window, for context-utilization reporting. */
+    contextWindow?: number | null;
+    timeoutMs?: number;
+    archiveId?: string | null;
+    onProgress?: (event: ProgressEvent) => void;
+    /**
+     * Task list override. Defaults to the static {@link TASKS}. Repo-backed
+     * SWE-bench tasks are opt-in and passed here so the static suite never
+     * requires a repo checkout to run.
+     */
+    tasks?: Task[] | null;
+}
+/** The scored result of one task within a suite run. */
+export interface SuiteTaskResult {
+    id: string;
+    category: string;
+    weight: number;
+    description?: string;
+    score: number;
+    summary: string;
+    detail?: unknown;
+    seconds: number;
+    error: string | null;
+}
+/** The full scorecard produced by a suite run. */
+export interface SuiteReport {
+    overall: number;
+    grade: string;
+    results: SuiteTaskResult[];
+    seconds: number;
+    executedCode: boolean;
+    pythonVersion: string | null;
+    archiveId: string | null;
+    ranAt: string;
+}
+/**
+ * Run the suite against an already-serving endpoint.
+ *
+ * @param {object} options
+ * @param {string} options.host        endpoint host
+ * @param {number} options.port        endpoint port
+ * @param {boolean} options.execute    actually run generated tests
+ * @param {number[]} options.depths    prompt depths for the scaling task
+ * @param {string[]} options.only      task ids to run (default: all)
+ */
+export declare function runSuite({ host, port, execute, depths, only, concurrency, reasoningBudget, contextWindow, timeoutMs, archiveId, onProgress, tasks, }?: RunSuiteOptions): Promise<SuiteReport>;
+export declare function grade(score: number): string;
+/** Render a scorecard for one model. */
+export declare function formatReport(report: SuiteReport, { modelName, profile }?: {
+    modelName?: string;
+    profile?: Profile | null;
+}): string;
+/** One completed report paired with its model name, for comparison. */
+export interface ComparisonEntry {
+    modelName: string;
+    report: SuiteReport;
+}
+/** Compare several completed reports. */
+export declare function formatComparison(entries: ComparisonEntry[]): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/bench/index.js

@@ -0,0 +1,209 @@
+import http from "node:http";
+import { TASKS } from "./tasks.js";
+import { findPython } from "./verify.js";
+import * as archive from "../ops/archive.js";
+/**
+ * Fast, locally-verifiable agentic-coding suite.
+ *
+ * This is deliberately NOT a replacement for SWE-bench or Aider Polyglot -
+ * those run hundreds of multi-turn exercises and take hours per model. This is
+ * the triage stage: a few minutes per model, enough to rank a shelf of quant
+ * variants and to catch the system-level failures (reasoning runaway, VRAM
+ * spill, throughput collapse at depth) that model-level leaderboards never
+ * measure because they do not know your hardware.
+ *
+ * Use it to pick finalists, then run a full public benchmark on those.
+ */
+export const DEFAULT_DEPTHS = [1000, 16000, 64000];
+function chatRequest({ host, port, payload, timeoutMs }) {
+    return new Promise((resolve, reject) => {
+        const body = JSON.stringify(payload);
+        const req = http.request({
+            host,
+            port,
+            path: "/v1/chat/completions",
+            method: "POST",
+            headers: { "content-type": "application/json", "content-length": Buffer.byteLength(body) },
+            timeout: timeoutMs,
+        }, (res) => {
+            let text = "";
+            res.on("data", (c) => (text += c));
+            res.on("end", () => {
+                if (res.statusCode !== 200) {
+                    reject(new Error(`endpoint returned ${res.statusCode}: ${text.slice(0, 300)}`));
+                    return;
+                }
+                try {
+                    resolve(JSON.parse(text));
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+        req.on("timeout", () => {
+            req.destroy();
+            reject(new Error(`request exceeded ${timeoutMs}ms`));
+        });
+        req.on("error", reject);
+        req.end(body);
+    });
+}
+/**
+ * Run the suite against an already-serving endpoint.
+ *
+ * @param {object} options
+ * @param {string} options.host        endpoint host
+ * @param {number} options.port        endpoint port
+ * @param {boolean} options.execute    actually run generated tests
+ * @param {number[]} options.depths    prompt depths for the scaling task
+ * @param {string[]} options.only      task ids to run (default: all)
+ */
+export async function runSuite({ host = "127.0.0.1", port = 1234, execute = true, depths = DEFAULT_DEPTHS, only = null, concurrency = 3, reasoningBudget = null, contextWindow = null, timeoutMs = 900000, archiveId = null, onProgress = () => { }, tasks = null, } = {}) {
+    const python = findPython();
+    const pool = tasks && tasks.length ? tasks : TASKS;
+    const selected = only && only.length ? pool.filter((t) => only.includes(t.id)) : pool;
+    const results = [];
+    const startedAll = Date.now();
+    for (const task of selected) {
+        onProgress({ phase: "start", task: task.id, title: task.category });
+        const started = Date.now();
+        // Archive every exchange for this task, so a future scorer can re-grade it
+        // without re-running the model.
+        let exchange = 0;
+        const chat = async (payload) => {
+            const response = await chatRequest({ host, port, payload, timeoutMs });
+            if (archiveId) {
+                try {
+                    archive.put(archiveId, task.id, {
+                        label: `exchange-${(exchange += 1)}`,
+                        request: payload,
+                        response,
+                    });
+                }
+                catch {
+                    /* archiving must never fail a benchmark run */
+                }
+            }
+            return response;
+        };
+        try {
+            const outcome = await task.run({
+                chat,
+                execute: execute && Boolean(python),
+                depths,
+                concurrency,
+                reasoningBudget,
+                contextWindow,
+            });
+            const entry = {
+                id: task.id,
+                category: task.category,
+                weight: task.weight,
+                description: task.description,
+                score: Math.max(0, Math.min(1, outcome.score)),
+                summary: outcome.summary,
+                detail: outcome.detail,
+                seconds: (Date.now() - started) / 1000,
+                error: null,
+            };
+            results.push(entry);
+            // `title` is what the progress UI renders; entry carries `category`, not
+            // `title`, so pass it explicitly or the label shows "undefined".
+            onProgress({ phase: "done", title: task.category, ...entry });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const entry = {
+                id: task.id,
+                category: task.category,
+                weight: task.weight,
+                score: 0,
+                summary: `failed: ${message}`,
+                seconds: (Date.now() - started) / 1000,
+                error: message,
+            };
+            results.push(entry);
+            onProgress({ phase: "failed", title: task.category, ...entry });
+        }
+    }
+    const totalWeight = results.reduce((sum, r) => sum + r.weight, 0);
+    const overall = totalWeight
+        ? results.reduce((sum, r) => sum + r.score * r.weight, 0) / totalWeight
+        : 0;
+    return {
+        overall,
+        grade: grade(overall),
+        results,
+        seconds: (Date.now() - startedAll) / 1000,
+        executedCode: execute && Boolean(python),
+        pythonVersion: python ? python.version : null,
+        archiveId,
+        ranAt: new Date().toISOString(),
+    };
+}
+export function grade(score) {
+    if (score >= 0.9)
+        return "excellent";
+    if (score >= 0.75)
+        return "strong";
+    if (score >= 0.55)
+        return "usable";
+    if (score >= 0.35)
+        return "weak";
+    return "unusable";
+}
+/** Render a scorecard for one model. */
+export function formatReport(report, { modelName = "model", profile = null } = {}) {
+    const lines = [];
+    const bar = (score) => {
+        const cells = 20;
+        const filled = Math.round(score * cells);
+        return "█".repeat(filled) + "░".repeat(cells - filled);
+    };
+    lines.push("");
+    lines.push(`  Agentic coding scorecard - ${modelName}`);
+    if (profile) {
+        lines.push(`  context ${profile.contextSize.toLocaleString()}  kv ${profile.cacheTypeK}/${profile.cacheTypeV}  ` +
+            `reasoning budget ${profile.reasoningBudget}${profile.vision ? "  vision on" : ""}`);
+    }
+    lines.push(`  ${"-".repeat(72)}`);
+    for (const r of report.results) {
+        lines.push(`  ${r.category.padEnd(18)} ${bar(r.score)} ${(r.score * 100).toFixed(0).padStart(3)}%  ${r.summary}`);
+    }
+    lines.push(`  ${"-".repeat(72)}`);
+    lines.push(`  ${"OVERALL".padEnd(18)} ${bar(report.overall)} ${(report.overall * 100).toFixed(0).padStart(3)}%  ${report.grade}`);
+    lines.push("");
+    lines.push(`  ran in ${report.seconds.toFixed(0)}s` +
+        (report.executedCode
+            ? `, generated tests executed with ${report.pythonVersion}`
+            : ", code not executed"));
+    // Surface depth numbers, which are the most system-specific result here.
+    const depth = report.results.find((r) => r.id === "context-depth");
+    if (depth && Array.isArray(depth.detail)) {
+        lines.push("");
+        lines.push(`  ${"prompt tokens".padStart(14)} ${"TTFT".padStart(8)} ${"prompt tok/s".padStart(13)} ${"gen tok/s".padStart(10)}`);
+        for (const p of depth.detail) {
+            lines.push(`  ${String(p.promptTokens ?? "?").padStart(14)} ${((p.ttftSeconds ?? 0).toFixed(2) + "s").padStart(8)} ` +
+                `${(p.promptPerSecond ?? 0).toFixed(0).padStart(13)} ${(p.generatePerSecond ?? 0).toFixed(1).padStart(10)}`);
+        }
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+/** Compare several completed reports. */
+export function formatComparison(entries) {
+    const lines = [];
+    const categories = entries[0]?.report.results.map((r) => r.category) || [];
+    lines.push("");
+    lines.push(`  ${"model".padEnd(42)}${categories.map((c) => c.slice(0, 9).padStart(10)).join("")}${"OVERALL".padStart(10)}`);
+    lines.push(`  ${"-".repeat(42 + categories.length * 10 + 10)}`);
+    const ranked = [...entries].sort((a, b) => b.report.overall - a.report.overall);
+    for (const { modelName, report } of ranked) {
+        const cells = report.results.map((r) => `${(r.score * 100).toFixed(0)}%`.padStart(10)).join("");
+        lines.push(`  ${modelName.slice(0, 41).padEnd(42)}${cells}${`${(report.overall * 100).toFixed(0)}%`.padStart(10)}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+//# sourceMappingURL=index.js.map

package/dist/bench/mine.d.ts

@@ -0,0 +1,32 @@
+export declare function isTest(file: string): boolean;
+export declare function isSource(file: string): boolean;
+/** Options for {@link mine}. */
+export interface MineOptions {
+    dir: string;
+    workspaceDir: string;
+    limit?: number;
+    maxFiles?: number;
+    since?: string | null;
+    ref?: string;
+}
+/** A benchmark task mined from a fix commit. */
+export interface MinedTask {
+    id: string;
+    workspaceDir: string;
+    fix: string;
+    parent: string;
+    date: string;
+    subject: string;
+    testPaths: string[];
+    sourcePaths: string[];
+    looksLikeFix: boolean;
+}
+/**
+ * @param {object} options
+ * @param {string} options.dir           repo working copy
+ * @param {string} options.workspaceDir  e.g. "packages/protocol"
+ * @param {number} options.limit         how many commits of history to scan
+ * @param {number} options.maxFiles      skip sprawling commits; they make poor tasks
+ */
+export declare function mine({ dir, workspaceDir, limit, maxFiles, since, ref, }: MineOptions): Promise<MinedTask[]>;
+//# sourceMappingURL=mine.d.ts.map

package/dist/bench/mine.js

@@ -0,0 +1,101 @@
+import path from "node:path";
+import { run } from "./repo.js";
+/**
+ * Mine benchmark tasks out of real git history.
+ *
+ * A commit that changed both source and tests in the same workspace is a
+ * candidate task: check out its parent, bring in only the test changes, and the
+ * new tests describe a bug that the parent commit still has. The author's own
+ * fix is the reference solution and their tests are the oracle - which is the
+ * property that makes this worth more than a hand-written prompt.
+ *
+ * Nothing here reads file contents. Tasks carry SHAs and paths only, so a task
+ * set can be shared or version-controlled without exposing private source.
+ */
+const TEST_PATTERN = /\.(test|spec)\.[cm]?[jt]sx?$/;
+const SOURCE_PATTERN = /\.[cm]?[jt]sx?$/;
+// Commits whose subject suggests a behavioural fix make the best tasks; the
+// rest are still usable but ranked below these.
+const FIX_HINT = /\b(fix|bug|regression|broken|crash|incorrect|wrong|fail)/i;
+export function isTest(file) {
+    return TEST_PATTERN.test(file);
+}
+export function isSource(file) {
+    return SOURCE_PATTERN.test(file) && !isTest(file);
+}
+/**
+ * @param {object} options
+ * @param {string} options.dir           repo working copy
+ * @param {string} options.workspaceDir  e.g. "packages/protocol"
+ * @param {number} options.limit         how many commits of history to scan
+ * @param {number} options.maxFiles      skip sprawling commits; they make poor tasks
+ */
+export async function mine({ dir, workspaceDir, limit = 2000, maxFiles = 12, since = null, ref = "origin/main", }) {
+    // Mine from a fixed ref, never HEAD: the harness moves HEAD around between
+    // tasks, and a HEAD parked on some parent commit makes every descendant
+    // unreachable - silently shrinking the task set instead of failing loudly.
+    const logArgs = [
+        "log",
+        ref,
+        `--max-count=${limit}`,
+        "--format=%H%x00%an%x00%ad%x00%s",
+        "--date=short",
+    ];
+    if (since)
+        logArgs.push(`--since=${since}`);
+    logArgs.push("--", workspaceDir);
+    const log = await run("git", logArgs, { cwd: dir, timeout: 120000 });
+    if (!log.ok)
+        throw new Error(`git log failed: ${log.stderr.trim()}`);
+    const commits = log.stdout
+        .split(/\r?\n/)
+        .filter(Boolean)
+        .map((line) => {
+        const [sha, author, date, subject] = line.split("\0");
+        return { sha, author, date, subject };
+    });
+    const candidates = [];
+    for (const commit of commits) {
+        const show = await run("git", ["show", "--name-only", "--format=", "--no-renames", commit.sha, "--", workspaceDir], { cwd: dir, timeout: 30000 });
+        if (!show.ok)
+            continue;
+        const files = show.stdout
+            .split(/\r?\n/)
+            .map((f) => f.trim())
+            .filter(Boolean);
+        if (!files.length || files.length > maxFiles)
+            continue;
+        const testPaths = files.filter(isTest);
+        const sourcePaths = files.filter(isSource);
+        if (!testPaths.length || !sourcePaths.length)
+            continue;
+        // A commit with no parent (or a merge) cannot define a clean "before" state.
+        const parents = await run("git", ["rev-list", "--parents", "-n", "1", commit.sha], {
+            cwd: dir,
+            timeout: 15000,
+        });
+        const parts = parents.stdout.trim().split(/\s+/);
+        if (parts.length !== 2)
+            continue; // 0 parents (root) or >1 (merge)
+        candidates.push({
+            id: `${path.basename(workspaceDir)}-${commit.sha.slice(0, 8)}`,
+            workspaceDir,
+            fix: commit.sha,
+            parent: parts[1],
+            date: commit.date,
+            subject: commit.subject,
+            testPaths,
+            sourcePaths,
+            looksLikeFix: FIX_HINT.test(commit.subject),
+        });
+    }
+    // Fix-shaped commits first, then smaller diffs - both correlate with tasks
+    // that have a crisp, checkable outcome.
+    candidates.sort((a, b) => {
+        if (a.looksLikeFix !== b.looksLikeFix)
+            return a.looksLikeFix ? -1 : 1;
+        return a.sourcePaths.length + a.testPaths.length - (b.sourcePaths.length + b.testPaths.length);
+    });
+    return candidates;
+}
+//# sourceMappingURL=mine.js.map