@mousedev/harness 0.1.1

package/dist/mouse.mjs

@@ -0,0 +1,1688 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from 'node:module';
+const require = __createRequire(import.meta.url);
+
+// src/main.ts
+import { mkdirSync as mkdirSync2, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { homedir as homedir2, tmpdir } from "node:os";
+import path4 from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+
+// ../core/src/workspace.ts
+function shellPath(p) {
+  return /^[A-Za-z0-9_./-]+$/.test(p) ? p : `'${p.replace(/'/g, `'\\''`)}'`;
+}
+
+// ../core/src/detect.ts
+var EMPTY_MANIFEST = {
+  packageJson: null,
+  packageManager: "npm",
+  pyproject: false,
+  pytestIni: false,
+  setupCfg: false,
+  toxIni: false,
+  testsDir: false,
+  uvLock: false,
+  poetryLock: false,
+  goMod: false,
+  cargoToml: false,
+  makefileTest: false
+};
+var DEFAULT_SCRIPTS = [
+  ["build", ["build", "typecheck"]],
+  ["test", ["test"]],
+  ["lint", ["lint"]]
+];
+var PYTEST_ARGS = "-q --maxfail=25 -p no:cacheprovider";
+function parseJsonObject(raw) {
+  if (!raw?.trim()) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function runCommand(pm, script) {
+  return pm === "npm" ? `npm run ${script} --if-present` : `${pm} run ${script}`;
+}
+function checksFromPackageJson(packageJson, pm = "npm") {
+  const scripts = parseJsonObject(packageJson)?.scripts;
+  if (!scripts || typeof scripts !== "object") return [];
+  const has = (s) => typeof scripts[s] === "string";
+  const out = [];
+  for (const [name, candidates] of DEFAULT_SCRIPTS) {
+    const script = candidates.find(has);
+    if (script) out.push({ name, command: runCommand(pm, script) });
+  }
+  return out;
+}
+function pytestCommand(m) {
+  if (m.uvLock) return `uv run --frozen pytest ${PYTEST_ARGS}`;
+  if (m.poetryLock) return `poetry run pytest ${PYTEST_ARGS}`;
+  return `python3 -m pytest ${PYTEST_ARGS}`;
+}
+function checksFromEcosystem(m) {
+  const out = checksFromPackageJson(m.packageJson, m.packageManager);
+  const python = m.pyproject || m.pytestIni || m.toxIni || m.setupCfg && m.testsDir;
+  if (python) out.push({ name: "pytest", command: pytestCommand(m) });
+  if (m.goMod) out.push({ name: "go-test", command: "go test ./..." });
+  if (m.cargoToml) out.push({ name: "cargo-test", command: "cargo test" });
+  if (m.makefileTest && out.length === 0) out.push({ name: "make-test", command: "make test" });
+  return out;
+}
+var MANIFEST_FILES = [
+  "pyproject.toml",
+  "pytest.ini",
+  "setup.cfg",
+  "tox.ini",
+  "uv.lock",
+  "poetry.lock",
+  "go.mod",
+  "Cargo.toml"
+];
+function detectEcosystemCommand(root) {
+  return [
+    `cd ${shellPath(root)} 2>/dev/null || exit 0`,
+    `for f in ${MANIFEST_FILES.join(" ")}; do [ -e "$f" ] && echo "F:$f"; done`,
+    '{ [ -d tests ] || [ -d test ]; } && echo "D:tests"',
+    "grep -qE '^test:' Makefile 2>/dev/null && echo 'M:test'",
+    '[ -f pnpm-lock.yaml ] && echo "PM:pnpm"',
+    '[ -f yarn.lock ] && echo "PM:yarn"',
+    '[ -f package.json ] && { echo "PKG_BEGIN"; cat package.json; echo; echo "PKG_END"; }',
+    "true"
+  ].join("; ");
+}
+var DETECT_ECOSYSTEM_COMMAND = detectEcosystemCommand("/workspace");
+function parseEcosystemOutput(stdout) {
+  const m = { ...EMPTY_MANIFEST };
+  const lines = stdout.split("\n");
+  const pkgStart = lines.indexOf("PKG_BEGIN");
+  const pkgEnd = lines.indexOf("PKG_END");
+  if (pkgStart >= 0 && pkgEnd > pkgStart) {
+    m.packageJson = lines.slice(pkgStart + 1, pkgEnd).join("\n");
+  }
+  for (const line of lines) {
+    switch (line.trim()) {
+      case "F:pyproject.toml":
+        m.pyproject = true;
+        break;
+      case "F:pytest.ini":
+        m.pytestIni = true;
+        break;
+      case "F:setup.cfg":
+        m.setupCfg = true;
+        break;
+      case "F:tox.ini":
+        m.toxIni = true;
+        break;
+      case "F:uv.lock":
+        m.uvLock = true;
+        break;
+      case "F:poetry.lock":
+        m.poetryLock = true;
+        break;
+      case "F:go.mod":
+        m.goMod = true;
+        break;
+      case "F:Cargo.toml":
+        m.cargoToml = true;
+        break;
+      case "D:tests":
+        m.testsDir = true;
+        break;
+      case "M:test":
+        m.makefileTest = true;
+        break;
+      case "PM:pnpm":
+        m.packageManager = "pnpm";
+        break;
+      case "PM:yarn":
+        if (m.packageManager === "npm") m.packageManager = "yarn";
+        break;
+      default:
+        break;
+    }
+  }
+  return m;
+}
+async function detectEcosystem(ws) {
+  const res = await ws.exec(detectEcosystemCommand(ws.root), { cwd: ws.root, timeoutMs: 1e4 }).catch(() => ({ stdout: "" }));
+  return parseEcosystemOutput(res.stdout);
+}
+
+// ../core/src/exec.ts
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+var LOCAL_EXEC_TIMEOUT_CODE = 124;
+function localWorkspace(opts) {
+  const root = opts.root.replace(/\/+$/, "") || "/";
+  const resolveCwd = (cwd) => cwd && existsSync(cwd) ? cwd : root;
+  function run(file, argv, execOpts) {
+    return new Promise((resolve, reject) => {
+      const child = spawn(file, argv, {
+        cwd: resolveCwd(execOpts?.cwd),
+        env: opts.env ?? process.env,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      let timedOut = false;
+      child.stdout.on("data", (d) => {
+        stdout += String(d);
+      });
+      child.stderr.on("data", (d) => {
+        stderr += String(d);
+      });
+      const timer = execOpts?.timeoutMs ? setTimeout(() => {
+        timedOut = true;
+        child.kill("SIGKILL");
+      }, execOpts.timeoutMs) : null;
+      const onAbort = () => child.kill("SIGKILL");
+      execOpts?.signal?.addEventListener("abort", onAbort, { once: true });
+      child.on("error", (e) => {
+        if (timer) clearTimeout(timer);
+        execOpts?.signal?.removeEventListener("abort", onAbort);
+        reject(e);
+      });
+      child.on("close", (code) => {
+        if (timer) clearTimeout(timer);
+        execOpts?.signal?.removeEventListener("abort", onAbort);
+        resolve({ stdout, stderr, code: timedOut ? LOCAL_EXEC_TIMEOUT_CODE : code ?? 1 });
+      });
+    });
+  }
+  return {
+    root,
+    exec: (cmd, execOpts) => run("bash", ["-lc", cmd], execOpts)
+  };
+}
+
+// ../core/src/failures.ts
+function stringifyInferenceUnknown(raw) {
+  if (raw == null) return "";
+  if (typeof raw === "string") return raw;
+  try {
+    return JSON.stringify(raw);
+  } catch {
+    return String(raw);
+  }
+}
+function classifyInferenceFailure(message, raw) {
+  const blob = `${message}
+${stringifyInferenceUnknown(raw)}`.toLowerCase();
+  if (/\b429\b/.test(blob) || /\b503\b/.test(blob) || /\b502\b/.test(blob) || blob.includes("rate limit") || blob.includes("ratelimit") || blob.includes("too many requests") || blob.includes("overload") || blob.includes("overloaded") || blob.includes("econnreset") || blob.includes("etimedout") || blob.includes("timed out") || blob.includes("timeout") || blob.includes("temporarily unavailable") || blob.includes("service unavailable") || blob.includes("please retry") || blob.includes("retry your request")) {
+    return "transient";
+  }
+  if (blob.includes("model_not_found") || blob.includes("model not found") || blob.includes("invalid model") || blob.includes("no such model") || blob.includes("unknown model") || blob.includes("does not exist") && blob.includes("model") || blob.includes("not available") && (blob.includes("model") || blob.includes("provider")) || blob.includes("model id") || blob.includes("unsupported model")) {
+    return "model_route";
+  }
+  return "other";
+}
+
+// ../core/src/git.ts
+var git = (ws) => `git -C ${shellPath(ws.root)}`;
+async function headSha(ws) {
+  const r = await ws.exec(`${git(ws)} rev-parse HEAD`, { cwd: ws.root, timeoutMs: 1e4 }).catch(() => ({ stdout: "", code: 1 }));
+  if (r.code !== 0) return null;
+  const s = r.stdout.trim();
+  return s.length >= 7 ? s : null;
+}
+async function fingerprint(ws, baseSha) {
+  const p = await ws.exec(`${git(ws)} status --porcelain`, { cwd: ws.root, timeoutMs: 1e4 });
+  if (!baseSha) return p.stdout;
+  const diff = await ws.exec(`${git(ws)} diff --shortstat ${baseSha} --`, {
+    cwd: ws.root,
+    timeoutMs: 2e4
+  });
+  return `${p.stdout}
+${diff.stdout}`;
+}
+var VERIFICATION_PATH = /(^|\/)(tests?|spec|__tests__)(\/|$)|\.github\/workflows\//;
+async function deletedVerificationFiles(ws, baseSha) {
+  if (!baseSha) return [];
+  const r = await ws.exec(`${git(ws)} diff --diff-filter=D --name-only ${baseSha} --`, {
+    cwd: ws.root,
+    timeoutMs: 2e4
+  }).catch(() => ({ stdout: "", code: 1 }));
+  if (r.code !== 0) return [];
+  return r.stdout.split("\n").map((l) => l.trim()).filter((p) => p && VERIFICATION_PATH.test(p));
+}
+
+// ../core/src/mea.ts
+function initTaskState(objective) {
+  const trimmed = objective.trim();
+  const chunks = trimmed.split(/(?:^|\n)\s*(?:\d+[.)]\s+|[-*]\s+)/).map((s) => s.trim()).filter((s) => s.length > 8);
+  const requirementTexts = chunks.length >= 2 ? chunks.slice(0, 8) : [
+    trimmed.slice(0, 500),
+    "Hard gates pass: build, tests, lint, and no verification tampering.",
+    "Changes are committed and reviewable (focused diff, clear commit message)."
+  ];
+  return {
+    objective: trimmed,
+    requirements: requirementTexts.map((text, i) => ({
+      id: `req_${i + 1}`,
+      text,
+      status: "pending",
+      evidenceRefs: []
+    })),
+    artifacts: [],
+    facts: [],
+    round: 0
+  };
+}
+function applyAudit(state, audit) {
+  const completed = new Set(audit.integrity === "clean" ? audit.completedRequirementIds : []);
+  const unmet = new Set(audit.unmetRequirementIds);
+  const blocked = audit.completion === "blocked";
+  const requirements = state.requirements.map((r) => {
+    if (completed.has(r.id)) {
+      return {
+        ...r,
+        status: "completed",
+        evidenceRefs: [...r.evidenceRefs, ...audit.facts.map((f) => f.evidenceRef)].slice(0, 8)
+      };
+    }
+    if (audit.integrity === "violation") {
+      return { ...r, status: "untrusted" };
+    }
+    if (blocked && unmet.has(r.id)) {
+      return { ...r, status: "blocked" };
+    }
+    if (unmet.has(r.id) && r.status === "completed") {
+      return { ...r, status: "untrusted" };
+    }
+    return r;
+  });
+  const newFacts = audit.facts.map((f, i) => ({
+    id: `fact_${state.round}_${i + 1}`,
+    text: f.text,
+    status: audit.integrity === "violation" ? "untrusted" : "completed",
+    evidenceRefs: [f.evidenceRef]
+  }));
+  return {
+    ...state,
+    requirements,
+    facts: [...state.facts, ...newFacts].slice(-40),
+    round: state.round + 1
+  };
+}
+function auditFromSandboxProbe(input) {
+  const facts = [
+    {
+      text: `workspace ${input.workspaceChanged ? "changed" : "unchanged"} since the run started`,
+      evidenceRef: "fingerprint"
+    }
+  ];
+  const checks = input.checks ?? [];
+  for (const c of checks) {
+    facts.push({
+      text: `check ${c.name}: ${c.pass ? "pass" : `fail (exit ${c.exitCode ?? "timeout"})`}`,
+      evidenceRef: `check:${c.name}`
+    });
+  }
+  const tampering = input.tampering ?? [];
+  if (tampering.length > 0) {
+    facts.push({
+      text: `Verification tampering: ${tampering.slice(0, 5).join(", ")}`,
+      evidenceRef: "verification_tampering"
+    });
+  }
+  const integrity = tampering.length > 0 ? "violation" : "clean";
+  const failedChecks = checks.filter((c) => !c.pass).map((c) => c.name);
+  const checksOk = failedChecks.length === 0;
+  const passes = input.workspaceChanged && checksOk && integrity === "clean";
+  const completedRequirementIds = [];
+  const unmetRequirementIds = [];
+  const gaps = [];
+  for (const id of input.contractTargets) {
+    if (passes) completedRequirementIds.push(id);
+    else {
+      unmetRequirementIds.push(id);
+      if (!input.workspaceChanged) gaps.push("Workspace unchanged since the run started.");
+      if (!checksOk) gaps.push(`Checks failed: ${failedChecks.join(", ")}.`);
+      if (integrity !== "clean") gaps.push("Verification files were deleted.");
+    }
+  }
+  if (passes) {
+    for (const r of input.state.requirements) {
+      if (r.status === "pending" && /commit|hard gates|build|tests/i.test(r.text)) {
+        completedRequirementIds.push(r.id);
+      }
+    }
+  }
+  const completion = integrity === "violation" ? "blocked" : completedRequirementIds.length > 0 && unmetRequirementIds.length === 0 ? "complete" : "incomplete";
+  const passedNames = checks.filter((c) => c.pass).map((c) => c.name);
+  return {
+    completion,
+    integrity,
+    completedRequirementIds: [...new Set(completedRequirementIds)],
+    unmetRequirementIds: [...new Set(unmetRequirementIds)],
+    facts,
+    gaps: [...new Set(gaps)],
+    summary: completion === "complete" ? passedNames.length > 0 ? `Sandbox audit: workspace changed; ${passedNames.join(", ")} passed.` : "Sandbox audit: workspace changed; no checks to run." : `Sandbox audit incomplete: ${[...new Set(gaps)].join(" ") || "criteria unmet"}`
+  };
+}
+
+// ../core/src/loop.ts
+var MIN_ROUND_MS = 6e4;
+var ESCALATE_AFTER_NON_PROGRESS_ROUNDS = 2;
+var INSTRUCTION_MAX_CHARS = 6e3;
+var EXCERPT_MAX_CHARS = 1500;
+var AUDIT_OPEN = "MOUSE_AUDIT";
+var AUDIT_CLOSE = "END_MOUSE_AUDIT";
+function parseAuditBlock(text) {
+  let open = text.lastIndexOf(AUDIT_OPEN);
+  while (open > 0 && text.startsWith(AUDIT_CLOSE, open - "END_".length)) {
+    open = text.lastIndexOf(AUDIT_OPEN, open - 1);
+  }
+  if (open < 0) return null;
+  const closeAt = text.indexOf(AUDIT_CLOSE, open + AUDIT_OPEN.length);
+  const body = text.slice(open + AUDIT_OPEN.length, closeAt < 0 ? void 0 : closeAt);
+  const done = [];
+  const todo = [];
+  for (const raw of body.split("\n")) {
+    const m = /^\s*[-*]\s*\[(done|todo|x|X| )\]\s*(.*)$/.exec(raw);
+    if (!m) continue;
+    const item = m[2].trim();
+    if (m[1] === "done" || m[1] === "x" || m[1] === "X") done.push(item);
+    else todo.push(item);
+  }
+  if (done.length === 0 && todo.length === 0) return null;
+  return { done, todo };
+}
+function auditFooter() {
+  return [
+    "When you are finished, end your reply with an audit of the original task, one line per requirement, in exactly this form:",
+    AUDIT_OPEN,
+    "- [done] <requirement>: <the file, test, or command output that proves it>",
+    "- [todo] <requirement>: <what is still missing>",
+    AUDIT_CLOSE,
+    "Mark a requirement done only with evidence you produced in this workspace."
+  ].join("\n");
+}
+function requirementLines(state) {
+  return state.requirements.map((r) => `- ${r.text}`);
+}
+function buildContinuePrompt(kind, ctx) {
+  const lines = [];
+  if (kind === "fix") {
+    lines.push("Verification failed after your changes.", "");
+    for (const c of ctx.failed) {
+      lines.push(
+        `Check \`${c.name}\` (\`${c.command}\`) ${c.exitCode == null ? "timed out" : `exited ${c.exitCode}`}:`,
+        "```",
+        c.excerpt.slice(-EXCERPT_MAX_CHARS),
+        "```",
+        ""
+      );
+    }
+    lines.push(
+      "Continue working on the task. Do not stop until these checks pass and every requirement below is done. Never weaken, skip, or delete tests to make them pass."
+    );
+  } else if (kind === "nochange") {
+    lines.push(
+      "No files in the workspace have changed, so the task is not done. Read the task again, then implement it here. If the task only requires producing files or output, produce them now."
+    );
+  } else {
+    lines.push(
+      "Before finishing, verify the task is complete. Re-read each requirement below and confirm it is implemented and checked in this workspace. If anything is missing, untested, or only partially done, do it now."
+    );
+    if (ctx.audit && ctx.audit.todo.length > 0) {
+      lines.push("", "You previously listed these as not done:");
+      for (const t of ctx.audit.todo) lines.push(`- ${t}`);
+    }
+  }
+  lines.push("", "## Requirements", ...requirementLines(ctx.state));
+  lines.push("", "## Original task", ctx.instruction.slice(0, INSTRUCTION_MAX_CHARS));
+  lines.push("", auditFooter());
+  return lines.join("\n");
+}
+async function runCompletionLoop(input) {
+  const now = input.now ?? Date.now;
+  const { probe, budget, signal } = input;
+  const onEvent = input.onEvent ?? (() => {
+  });
+  let state = initTaskState(input.instruction);
+  const targets = state.requirements.map((r) => r.id);
+  const rounds = [];
+  let nonProgress = 0;
+  let model = input.model;
+  const finish = (outcome) => ({
+    outcome,
+    rounds,
+    totalSteps: input.steps(),
+    state
+  });
+  for (let round = 1; ; round++) {
+    if (signal.aborted) return finish("aborted");
+    const elapsed = now() - input.startedAt;
+    if (elapsed >= budget.maxWallMs) return finish("wall_clock");
+    if (input.steps() >= budget.maxTotalSteps) return finish("step_budget");
+    const fp = await probe.fingerprint();
+    const changed = fp !== input.initialFingerprint;
+    const checks = changed ? await probe.checks() : [];
+    const tampering = changed ? await probe.tampering() : [];
+    for (const c of checks) {
+      await onEvent({
+        type: "check_status",
+        name: c.name,
+        conclusion: c.pass ? "success" : "failure",
+        ...c.pass ? {} : { detail: c.excerpt.slice(-EXCERPT_MAX_CHARS), retryable: true }
+      });
+    }
+    if (tampering.length > 0) {
+      await onEvent({
+        type: "notice",
+        message: `Verification files were deleted: ${tampering.slice(0, 5).join(", ")}`,
+        level: "warn"
+      });
+      return finish("blocked");
+    }
+    const audit = auditFromSandboxProbe({
+      state,
+      contractTargets: targets,
+      workspaceChanged: changed,
+      checks,
+      tampering
+    });
+    state = applyAudit(state, audit);
+    const failed = checks.filter((c) => !c.pass);
+    const modelAudit = parseAuditBlock(input.lastAssistantText());
+    if (changed && failed.length === 0 && modelAudit && modelAudit.todo.length === 0) {
+      return finish("satisfied");
+    }
+    const kind = !changed ? "nochange" : failed.length > 0 ? "fix" : "audit";
+    if (budget.maxWallMs - elapsed < (budget.minRoundMs ?? MIN_ROUND_MS))
+      return finish("wall_clock");
+    if (nonProgress >= ESCALATE_AFTER_NON_PROGRESS_ROUNDS && input.escalate) {
+      const next = await input.escalate(nonProgress);
+      if (next) model = next;
+    }
+    const prompt = buildContinuePrompt(kind, {
+      instruction: input.instruction,
+      state,
+      failed,
+      audit: modelAudit
+    });
+    try {
+      await input.engine.prompt(input.sessionId, prompt, signal, { model });
+    } catch (e) {
+      if (e?.name === "AbortError" || signal.aborted) return finish("aborted");
+      throw e;
+    }
+    const after = await probe.fingerprint();
+    const progressed = after !== fp;
+    nonProgress = progressed ? 0 : nonProgress + 1;
+    const record = {
+      round,
+      kind,
+      checksRun: checks.map((c) => c.name),
+      checksFailed: failed.map((c) => c.name),
+      changed,
+      audit: modelAudit,
+      progressed,
+      stepsAfter: input.steps(),
+      elapsedMs: now() - input.startedAt,
+      model
+    };
+    rounds.push(record);
+    await input.onRound?.(record);
+    const claimedDone = parseAuditBlock(input.lastAssistantText());
+    if (!progressed && claimedDone && claimedDone.todo.length === 0 && failed.length === 0) {
+      continue;
+    }
+    if (nonProgress >= budget.maxNonProgressRounds) return finish("stalled");
+  }
+}
+
+// ../core/src/paths.ts
+import { homedir } from "node:os";
+import path from "node:path";
+function mouseHome(env = process.env) {
+  return env.MOUSE_HOME?.trim() || path.join(homedir(), ".mouse");
+}
+function workspaceSlug(cwd) {
+  const abs = path.resolve(cwd).replace(/[/\\:]+/g, "-").replace(/^-+|-+$/g, "");
+  return `--${abs || "root"}--`;
+}
+function runsDir(cwd, env = process.env) {
+  return path.join(mouseHome(env), "runs", workspaceSlug(cwd));
+}
+function traceFile(cwd, env = process.env, now = /* @__PURE__ */ new Date()) {
+  const stamp = now.toISOString().replace(/[:.]/g, "-");
+  return path.join(runsDir(cwd, env), `${stamp}-${process.pid}.jsonl`);
+}
+
+// ../core/src/policy.ts
+var DEFAULT_POLICY = {
+  version: 1,
+  verify: { checks: null, timeoutSec: 900 },
+  loop: {
+    maxWallSec: 780,
+    maxSteps: 600,
+    nonProgressRounds: 3,
+    idleTimeoutSec: 600,
+    minRoundSec: 60
+  },
+  context: { prune: { enabled: false, thresholdChars: 8192, headChars: 4096, tailChars: 1024 } },
+  permissions: {},
+  extra: {}
+};
+var KNOWN_KEYS = /* @__PURE__ */ new Set(["version", "verify", "loop", "context", "permissions"]);
+var ACTIONS = /* @__PURE__ */ new Set(["allow", "ask", "deny"]);
+function obj(v) {
+  return v && typeof v === "object" && !Array.isArray(v) ? v : null;
+}
+function int(v, fallback, min = 1, max = Number.MAX_SAFE_INTEGER) {
+  return typeof v === "number" && Number.isInteger(v) && v >= min && v <= max ? v : fallback;
+}
+function bool(v, fallback) {
+  return typeof v === "boolean" ? v : fallback;
+}
+function parseChecks(v) {
+  if (Array.isArray(v)) {
+    const out2 = [];
+    for (const item of v) {
+      const o2 = obj(item);
+      if (o2 && typeof o2.name === "string" && typeof o2.command === "string" && o2.command.trim()) {
+        out2.push({ name: o2.name, command: o2.command });
+      }
+    }
+    return out2;
+  }
+  const o = obj(v);
+  if (!o) return null;
+  const out = [];
+  for (const [name, command] of Object.entries(o)) {
+    if (typeof command === "string" && command.trim()) out.push({ name, command });
+  }
+  return out;
+}
+function parseToolEntry(v) {
+  if (typeof v === "string") return ACTIONS.has(v) ? v : void 0;
+  const o = obj(v);
+  if (!o) return void 0;
+  const out = {};
+  for (const [pattern, action] of Object.entries(o)) {
+    if (typeof action === "string" && ACTIONS.has(action))
+      out[pattern] = action;
+  }
+  return out;
+}
+function parsePermissions(v) {
+  const o = obj(v);
+  if (!o) return {};
+  const out = {};
+  for (const tool of ["bash", "write", "edit"]) {
+    const entry = parseToolEntry(o[tool]);
+    if (entry !== void 0) out[tool] = entry;
+  }
+  if (typeof o.doom_loop === "string" && ACTIONS.has(o.doom_loop)) {
+    out.doom_loop = o.doom_loop;
+  }
+  return out;
+}
+function parsePolicy(raw) {
+  const o = obj(raw) ?? {};
+  const d = DEFAULT_POLICY;
+  const verify = obj(o.verify) ?? {};
+  const loop = obj(o.loop) ?? {};
+  const prune = obj(obj(o.context)?.prune) ?? {};
+  const extra = {};
+  for (const [k, v] of Object.entries(o)) if (!KNOWN_KEYS.has(k)) extra[k] = v;
+  return {
+    version: 1,
+    verify: {
+      checks: "checks" in verify ? parseChecks(verify.checks) : d.verify.checks,
+      timeoutSec: int(verify.timeoutSec, d.verify.timeoutSec, 1, 86400)
+    },
+    loop: {
+      maxWallSec: int(loop.maxWallSec, d.loop.maxWallSec),
+      maxSteps: int(loop.maxSteps, d.loop.maxSteps),
+      nonProgressRounds: int(loop.nonProgressRounds, d.loop.nonProgressRounds),
+      idleTimeoutSec: int(loop.idleTimeoutSec, d.loop.idleTimeoutSec),
+      minRoundSec: int(loop.minRoundSec, d.loop.minRoundSec, 0)
+    },
+    context: {
+      prune: {
+        enabled: bool(prune.enabled, d.context.prune.enabled),
+        thresholdChars: int(prune.thresholdChars, d.context.prune.thresholdChars),
+        headChars: int(prune.headChars, d.context.prune.headChars, 0),
+        tailChars: int(prune.tailChars, d.context.prune.tailChars, 0)
+      }
+    },
+    permissions: parsePermissions(o.permissions),
+    extra
+  };
+}
+function permissionRulesForTool(entry) {
+  if (!entry) return [];
+  if (typeof entry === "string") return [["*", entry]];
+  return Object.entries(entry);
+}
+async function readWorkspaceFile(ws, relPath) {
+  if (relPath.includes("..") || relPath.startsWith("/")) return null;
+  const abs = `${ws.root.replace(/\/+$/, "")}/${relPath}`;
+  try {
+    const res = await ws.exec(`test -f ${shellPath(abs)} && cat ${shellPath(abs)} || true`, {
+      cwd: ws.root,
+      timeoutMs: 5e3
+    });
+    if (res.code !== 0) return null;
+    return res.stdout || null;
+  } catch {
+    return null;
+  }
+}
+function parseJson(raw) {
+  if (!raw?.trim()) return null;
+  try {
+    return obj(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+}
+async function loadPolicy(ws) {
+  const raw = parseJson(await readWorkspaceFile(ws, ".mouse/policy.json")) ?? {};
+  if (!obj(raw.verify)) {
+    const app = parseJson(await readWorkspaceFile(ws, ".mouse/app.json"));
+    const verify = obj(app?.verify);
+    if (verify) {
+      const alias = {};
+      if ("checks" in verify) alias.checks = verify.checks;
+      if (typeof verify.timeoutSec === "number") alias.timeoutSec = verify.timeoutSec;
+      raw.verify = alias;
+    }
+  }
+  return parsePolicy(raw);
+}
+
+// ../core/src/probe.ts
+var DEFAULT_CHECK_TIMEOUT_MS = 9e5;
+var FALLBACK_LIST_MAX = 2e3;
+var FALLBACK_LIST_TIMEOUT_MS = 2e4;
+function makeProbe(o) {
+  const ws = o.workspace;
+  const timeoutMs = o.checkTimeoutMs ?? DEFAULT_CHECK_TIMEOUT_MS;
+  let checksCache = o.checks ?? null;
+  async function detected() {
+    if (checksCache) return checksCache;
+    checksCache = checksFromEcosystem(await detectEcosystem(ws));
+    return checksCache;
+  }
+  return {
+    async checks() {
+      const out = [];
+      for (const check of await detected()) {
+        if (o.signal.aborted) break;
+        const res = await ws.exec(check.command, { cwd: ws.root, timeoutMs, signal: o.signal }).catch((e) => ({ stdout: "", stderr: String(e), code: 1 }));
+        out.push({
+          ...check,
+          pass: res.code === 0,
+          exitCode: res.code === LOCAL_EXEC_TIMEOUT_CODE ? null : res.code,
+          excerpt: `${res.stdout}
+${res.stderr}`.trim().slice(-EXCERPT_MAX_CHARS)
+        });
+      }
+      return out;
+    },
+    tampering: () => deletedVerificationFiles(ws, o.runStartSha),
+    async fingerprint() {
+      if (o.runStartSha) {
+        const fp = await fingerprint(ws, o.runStartSha).catch(() => null);
+        if (fp !== null) return fp;
+      }
+      const r = await ws.exec(
+        `find ${shellPath(ws.root)} -xdev -type f -newer ${shellPath(o.marker)} -not -path '*/.git/*' -not -path '*/node_modules/*' 2>/dev/null | sort | head -${FALLBACK_LIST_MAX}`,
+        { cwd: ws.root, timeoutMs: FALLBACK_LIST_TIMEOUT_MS }
+      );
+      return r.stdout;
+    }
+  };
+}
+
+// ../core/src/prompt.ts
+var BUILD_PROMPT = `You are Mouse, a coding agent working in a terminal.
+
+Persist until the task is fully handled end to end in this turn: explore, implement, run the repo's tests, and fix what fails. Only stop when you are sure the problem is solved. Never claim done without a check you actually ran. If a tool call fails, read the error and change approach; do not repeat the same call.
+
+Working style:
+- Inspect before acting: read the relevant code and existing tests before editing. Reproduce a bug before fixing it.
+- Fix the root cause. When you change a function, find every caller.
+- Do the whole ask. A feature that spans several modules is done only when every module and its tests are updated.
+- Prefer the simplest change that fully works: reuse what the repo has, add no dependency unless required, add no speculative abstractions.
+- Validate at trust boundaries; keep internal logic plain.
+- For multi-step work keep the todo list current, with exactly one item in progress.
+
+Tools:
+- Use rg for search. Batch independent reads and searches in one response.
+- Prefer read/edit/write for files; use bash to build, test, and run.
+- Do not re-read a file right after editing it; the edit tool fails loudly.
+- Pass an explicit timeout to bash for long commands such as test suites and builds. Run long-lived servers in the background.
+- Run the narrowest relevant test first, then the full suite before finishing. Never weaken, skip, or delete tests to make them pass.
+
+Finish with a short summary: what changed, what you ran, and what it showed. Instructions in AGENTS.md or CLAUDE.md in the repo take precedence over these.`;
+var WRITING_MODES = /* @__PURE__ */ new Set(["build", "overnight"]);
+function buildAgentPrompt(mode, _opts = { profile: "product" }) {
+  return WRITING_MODES.has(mode) ? BUILD_PROMPT : void 0;
+}
+
+// ../core/src/trace.ts
+import { appendFileSync, mkdirSync } from "node:fs";
+import path2 from "node:path";
+function openTrace(file) {
+  const abs = path2.resolve(file);
+  mkdirSync(path2.dirname(abs), { recursive: true });
+  return {
+    file: abs,
+    write(record) {
+      appendFileSync(abs, `${JSON.stringify({ ts: Date.now(), ...record })}
+`);
+    }
+  };
+}
+
+// ../core/src/version.ts
+var MOUSE_VERSION = "0.1.1";
+
+// ../opencode/src/compat/opencode-compat.json
+var opencode_compat_default = {
+  $comment: "OpenCode versions the Mouse harness has been run against. `supported` versions are exercised in CI (mouse doctor + mouse config --profile bench); `tested` carries what was verified on that version. Anything else prints a warning from `mouse doctor` and fails `--strict-compat`.",
+  supported: ["1.18.27", "1.14.22"],
+  tested: {
+    "1.18.27": {
+      benchmark: "FrontierHarness Eval, Kimi K3 via Fireworks, under the benchmark's unmodified run-trials.sh on golden checkpoint fh-golden-mouse-v3",
+      result: "25/30 (datacurve 8/9, terminal-bench 17/21), run 2026-09-08-mouse-c, harness commit 315e2b8, all 30 trials valid; an earlier self-run through Harbor on 2026-09-03 scored 24/30",
+      notes: "The version both runs used: the adapter installed opencode-ai@latest, which was 1.18.27 on 2026-09-03, and the adapters have pinned it since."
+    },
+    "1.14.22": {
+      benchmark: "none",
+      result: "CI compat job only: mouse doctor --strict-compat and a bench config write succeed",
+      notes: "The version the hosted product's SDK pins. No benchmark run on it."
+    }
+  },
+  notes: {
+    "1.18.19": "FrontierHarness pinned 1.18.19 for its stock OpenCode control. Not run; 1.18.27 is the same minor line."
+  }
+};
+
+// ../opencode/src/compat.ts
+function loadCompatManifest() {
+  return opencode_compat_default;
+}
+function parseOpencodeVersion(output) {
+  const m = /(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)/.exec(output);
+  return m?.[1] ?? null;
+}
+function checkCompat(versionOutput, manifest = loadCompatManifest()) {
+  const version = versionOutput ? parseOpencodeVersion(versionOutput) : null;
+  if (!version) return { level: "unknown", version: null };
+  if (manifest.supported.includes(version)) return { level: "supported", version };
+  return { level: "untested", version, supported: manifest.supported };
+}
+
+// ../opencode/src/config.ts
+var SET_CACHE_KEY_PROVIDER_IDS = ["anthropic", "openrouter", "fireworks-ai"];
+var NO_CACHE_KEY_WHEN_SERVING = ["fireworks-ai"];
+function providerCacheOptions(extra = []) {
+  const out = {};
+  for (const id of [...SET_CACHE_KEY_PROVIDER_IDS, ...extra]) {
+    out[id] = { options: { setCacheKey: true } };
+  }
+  return out;
+}
+function runProviderCacheOptions(modelProvider) {
+  const provider = providerCacheOptions(modelProvider ? [modelProvider] : []);
+  const skip = NO_CACHE_KEY_WHEN_SERVING;
+  if (modelProvider && skip.includes(modelProvider)) delete provider[modelProvider];
+  return provider;
+}
+var BENCH_COMPACTION = { auto: true, prune: true, reserved: 1e4 };
+var OPENROUTER_PIN_FIREWORKS = {
+  provider: { order: ["Fireworks"], allow_fallbacks: false }
+};
+var MODE_PERMISSIONS = {
+  ask: { edit: "deny", bash: "deny" },
+  plan: { edit: "deny", bash: "ask" },
+  debug: { edit: "ask", bash: "allow" },
+  build: { edit: "allow", bash: "allow" }
+};
+var DISABLED_TOOLS = ["webfetch", "websearch", "task", "skill"];
+function bashPermission(base, policy) {
+  const denies = policy ? permissionRulesForTool(policy.bash).filter(([, action]) => action === "deny").map(([pattern]) => pattern) : [];
+  if (denies.length === 0) return base;
+  const out = { "*": base };
+  for (const pattern of denies) out[pattern] = "deny";
+  return out;
+}
+function editPermission(base, permissionMode) {
+  if (permissionMode === "bypass" && base === "ask") return "allow";
+  return base;
+}
+var PLAN_EDIT = {
+  "*": "deny",
+  ".mouse/plans/*.md": "allow"
+};
+function agentNameForMode(mode) {
+  return mode;
+}
+function buildOpencodeConfig(input) {
+  const profile = input.profile ?? "product";
+  const withPrompt = profile !== "product";
+  const modes = [
+    ...Object.entries(MODE_PERMISSIONS),
+    ...Object.entries(input.extraModes ?? {})
+  ];
+  const agent = {};
+  for (const [mode, posture] of modes) {
+    const prompt = withPrompt ? buildAgentPrompt(mode, { profile }) : void 0;
+    agent[agentNameForMode(mode)] = {
+      mode: "primary",
+      ...prompt ? { prompt } : {},
+      permission: {
+        edit: mode === "plan" ? PLAN_EDIT : editPermission(posture.edit, input.permissionMode),
+        bash: bashPermission(posture.bash, input.permissions),
+        // Native fetch is off; belt-and-braces alongside `tools.webfetch: false`.
+        webfetch: "deny",
+        // Hosts run their own doom-loop detector; OpenCode's would double-prompt.
+        doom_loop: "allow"
+      }
+    };
+  }
+  const tools = {};
+  for (const name of DISABLED_TOOLS) tools[name] = false;
+  const config = { agent, tools };
+  const smallModel = input.smallModel?.trim();
+  if (smallModel) config.small_model = smallModel;
+  if (profile === "bench") {
+    const bench = config;
+    bench.$schema = "https://opencode.ai/config.json";
+    bench.autoupdate = false;
+    bench.share = "disabled";
+    bench.compaction = { ...BENCH_COMPACTION };
+    const modelProvider = input.model?.includes("/") ? input.model.split("/")[0] : void 0;
+    const provider = runProviderCacheOptions(modelProvider);
+    if (modelProvider === "openrouter") {
+      provider.openrouter.options.extraBody = OPENROUTER_PIN_FIREWORKS;
+    }
+    bench.provider = provider;
+    if (input.model) bench.small_model = input.model;
+  } else if (profile === "local") {
+    const local = config;
+    local.compaction = { ...BENCH_COMPACTION };
+    const modelProvider = input.model?.includes("/") ? input.model.split("/")[0] : void 0;
+    local.provider = runProviderCacheOptions(modelProvider);
+  }
+  return config;
+}
+function mergeConfig(base, over) {
+  const out = { ...base };
+  for (const [k, v] of Object.entries(over)) {
+    const prev = out[k];
+    out[k] = v && typeof v === "object" && !Array.isArray(v) && prev && typeof prev === "object" && !Array.isArray(prev) ? mergeConfig(prev, v) : v;
+  }
+  return out;
+}
+
+// ../opencode/src/locate.ts
+import { execFileSync } from "node:child_process";
+import { existsSync as existsSync2 } from "node:fs";
+import path3 from "node:path";
+function locateOpencode(o = {}) {
+  const env = o.env ?? process.env;
+  if (o.flag) {
+    if (o.flag.includes(path3.sep)) return existsSync2(o.flag) ? o.flag : null;
+    return whichNamed(o.flag, env, o.platform) ?? o.flag;
+  }
+  if (env.MOUSE_OPENCODE_BIN?.trim()) return env.MOUSE_OPENCODE_BIN.trim();
+  const onPath = whichNamed("opencode", env, o.platform);
+  if (onPath) return onPath;
+  let dir = path3.resolve(o.cwd ?? process.cwd());
+  for (; ; ) {
+    const candidate = path3.join(dir, "node_modules", ".bin", "opencode");
+    if (existsSync2(candidate)) return candidate;
+    const parent = path3.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function whichNamed(name, env, platform = process.platform) {
+  const suffixes = platform === "win32" && !path3.extname(name) ? ["", ...(env.PATHEXT ?? ".EXE;.CMD;.BAT").toLowerCase().split(";").filter(Boolean)] : [""];
+  for (const dir of (env.PATH ?? "").split(path3.delimiter)) {
+    if (!dir) continue;
+    for (const ext of suffixes) {
+      const candidate = path3.join(dir, name + ext);
+      if (existsSync2(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+function opencodeVersion(bin, timeoutMs = 2e4) {
+  try {
+    return execFileSync(bin, ["--version"], { encoding: "utf8", timeout: timeoutMs }).trim();
+  } catch {
+    return null;
+  }
+}
+
+// ../opencode/src/plugins/prune.ts
+var PRUNE_PLUGIN_FILENAME = "mouse-prune.mjs";
+function prunePluginSource(p) {
+  return `// Written by the Mouse harness from .mouse/policy.json (context.prune).
+const THRESHOLD = ${p.thresholdChars}, HEAD = ${p.headChars}, TAIL = ${p.tailChars};
+export default {
+  name: "mouse-prune",
+  events: {
+    "tool.execute.after": async (_input, output) => {
+      if (!output || typeof output.output !== "string") return;
+      const s = output.output;
+      if (s.length <= THRESHOLD) return;
+      output.output = s.slice(0, HEAD) + "\\n\\n[... " + (s.length - HEAD - TAIL) + " chars omitted by mouse-prune ...]\\n\\n" + s.slice(-TAIL);
+    },
+  },
+};
+`;
+}
+
+// ../opencode/src/run-engine.ts
+import { spawn as spawn2 } from "node:child_process";
+import { createInterface } from "node:readline";
+var DEFAULT_IDLE_MS = 6e5;
+var DEFAULT_ATTEMPTS = 3;
+var RETRY_BASE_MS = 2e3;
+var RETRY_MAX_MS = 3e4;
+function retryDelayMs(attempt) {
+  return Math.min(RETRY_MAX_MS, RETRY_BASE_MS * 2 ** (attempt - 1));
+}
+function num(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+}
+var OpencodeRunEngine = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  sessionId = null;
+  steps = 0;
+  lastText = "";
+  tokens = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
+  title;
+  child = null;
+  /**
+   * `opencode run` creates the session on the first prompt, so `open` only
+   * records what to name it. Pass `sessionId` to continue an existing one.
+   */
+  async open(opts = {}) {
+    if (opts.sessionId) this.sessionId = opts.sessionId;
+    this.title = opts.title;
+    return this.sessionId ?? "";
+  }
+  async prompt(_sessionId, text, signal, opts) {
+    const max = this.opts.maxAttempts ?? DEFAULT_ATTEMPTS;
+    const model = opts?.model ?? this.opts.model;
+    let steps = 0;
+    for (let attempt = 1; attempt <= max; attempt++) {
+      if (signal.aborted) throw Object.assign(new Error("Aborted"), { name: "AbortError" });
+      const r = await this.spawnOnce(text, model, signal);
+      this.steps += r.steps;
+      steps += r.steps;
+      if (r.text) this.lastText = r.text;
+      this.opts.trace?.({
+        type: "mouse.attempt",
+        attempt,
+        steps: r.steps,
+        exitCode: r.exitCode,
+        timedOut: r.timedOut,
+        transientError: r.transientError,
+        error: r.errorMessage,
+        sessionId: this.sessionId
+      });
+      if (r.steps > 0) return { steps, text: this.lastText };
+      const retryable = r.timedOut || r.transientError || r.exitCode !== 0;
+      if (!retryable) return { steps, text: this.lastText };
+      if (attempt === max) {
+        throw new Error(
+          `opencode run produced no steps after ${max} attempts${r.errorMessage ? `: ${r.errorMessage}` : ""}`
+        );
+      }
+      await new Promise((res) => setTimeout(res, retryDelayMs(attempt)));
+    }
+    return { steps, text: this.lastText };
+  }
+  async abort() {
+    this.child?.kill("SIGKILL");
+  }
+  /** The argv for one turn; exported for tests and for `mouse doctor`. */
+  argsFor(prompt, model = this.opts.model) {
+    return [
+      "run",
+      "--format=json",
+      "--agent",
+      this.opts.agent ?? "build",
+      "--model",
+      model,
+      ...this.opts.skipPermissions === false ? [] : ["--dangerously-skip-permissions"],
+      ...this.sessionId ? ["--session", this.sessionId] : [],
+      // Passed on every turn, continuation included, as the benchmark run did.
+      ...this.title ? ["--title", this.title] : [],
+      ...this.opts.extraArgs ?? [],
+      "--",
+      prompt
+    ];
+  }
+  spawnOnce(prompt, model, signal) {
+    return new Promise((resolve, reject) => {
+      const child = spawn2(this.opts.bin ?? "opencode", this.argsFor(prompt, model), {
+        cwd: this.opts.cwd,
+        env: this.opts.env ?? process.env,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      this.child = child;
+      const attempt = {
+        exitCode: null,
+        steps: 0,
+        text: "",
+        timedOut: false,
+        transientError: false,
+        errorMessage: null
+      };
+      const texts = [];
+      const idleMs = this.opts.idleTimeoutMs ?? DEFAULT_IDLE_MS;
+      let idle = setTimeout(onIdle, idleMs);
+      function onIdle() {
+        attempt.timedOut = true;
+        child.kill("SIGKILL");
+      }
+      const touch = () => {
+        clearTimeout(idle);
+        idle = setTimeout(onIdle, idleMs);
+      };
+      const onAbort = () => child.kill("SIGKILL");
+      signal.addEventListener("abort", onAbort, { once: true });
+      const out = createInterface({ input: child.stdout });
+      out.on("line", (line) => {
+        touch();
+        this.opts.passthrough?.(line);
+        let ev;
+        try {
+          ev = JSON.parse(line);
+        } catch {
+          return;
+        }
+        if (!ev || typeof ev !== "object") return;
+        if (!this.sessionId && typeof ev.sessionID === "string" && ev.sessionID) {
+          this.sessionId = ev.sessionID;
+        }
+        const part = ev.part ?? {};
+        switch (ev.type) {
+          case "step_finish": {
+            attempt.steps += 1;
+            const tokens = part.tokens ?? {};
+            const cache = tokens.cache ?? {};
+            this.tokens.input += num(tokens.input);
+            this.tokens.output += num(tokens.output);
+            this.tokens.cacheRead += num(cache.read);
+            this.tokens.cacheWrite += num(cache.write);
+            this.tokens.cost += num(part.cost);
+            break;
+          }
+          case "text": {
+            if (typeof part.text === "string" && part.text.trim()) texts.push(part.text);
+            break;
+          }
+          case "error": {
+            const message = JSON.stringify(ev.error ?? "");
+            attempt.errorMessage = message.slice(0, 500);
+            if (classifyInferenceFailure(message, ev.error) === "transient") {
+              attempt.transientError = true;
+            }
+            break;
+          }
+          default:
+            break;
+        }
+      });
+      const err = createInterface({ input: child.stderr });
+      err.on("line", (line) => {
+        touch();
+        this.opts.passthroughErr?.(line);
+      });
+      child.on("error", (e) => {
+        clearTimeout(idle);
+        signal.removeEventListener("abort", onAbort);
+        this.child = null;
+        reject(e);
+      });
+      child.on("close", (code) => {
+        clearTimeout(idle);
+        signal.removeEventListener("abort", onAbort);
+        this.child = null;
+        attempt.exitCode = code;
+        attempt.text = texts.join("\n");
+        resolve(attempt);
+      });
+    });
+  }
+};
+
+// ../opencode/src/version.ts
+function versionLine(opencode) {
+  return `mouse/${MOUSE_VERSION} opencode/${opencode ?? "unavailable"}`;
+}
+
+// src/main.ts
+var EXIT = {
+  satisfied: 0,
+  error: 1,
+  usage: 2,
+  budget: 3,
+  blocked: 4,
+  aborted: 130
+};
+function exitCodeFor(outcome) {
+  switch (outcome) {
+    case "satisfied":
+      return EXIT.satisfied;
+    case "blocked":
+      return EXIT.blocked;
+    case "aborted":
+      return EXIT.aborted;
+    case "stalled":
+    case "wall_clock":
+    case "step_budget":
+      return EXIT.budget;
+    default: {
+      const unhandled = outcome;
+      throw new Error(`unhandled outcome ${String(unhandled)}`);
+    }
+  }
+}
+function configHomeFromEnv(env = process.env) {
+  return path4.join(env.XDG_CONFIG_HOME ?? path4.join(homedir2(), ".config"), "opencode");
+}
+function fail(message) {
+  throw new UsageError(message);
+}
+var UsageError = class extends Error {
+};
+function writeBenchConfig(configHome, model, policy) {
+  mkdirSync2(configHome, { recursive: true });
+  const file = path4.join(configHome, "opencode.json");
+  let existing = {};
+  let raw = null;
+  try {
+    raw = readFileSync(file, "utf8");
+  } catch {
+    raw = null;
+  }
+  if (raw !== null) {
+    try {
+      existing = JSON.parse(raw);
+    } catch (e) {
+      throw new Error(`${file} is not valid JSON (${e.message}); fix or move it first`);
+    }
+  }
+  const config = mergeConfig(
+    existing,
+    buildOpencodeConfig({ profile: "bench", model, permissions: policy.permissions })
+  );
+  writeFileSync(file, `${JSON.stringify(config, null, 2)}
+`);
+  writePrunePlugin(configHome, policy);
+  return file;
+}
+function writePrunePlugin(configHome, policy) {
+  const prune = policy.context.prune;
+  if (!prune.enabled && process.env.MOUSE_TOOL_OUTPUT_PRUNE !== "1") return null;
+  const pluginDir = path4.join(configHome, "plugin");
+  mkdirSync2(pluginDir, { recursive: true });
+  const file = path4.join(pluginDir, PRUNE_PLUGIN_FILENAME);
+  writeFileSync(file, prunePluginSource(prune));
+  return file;
+}
+function positiveInt(v) {
+  if (v === void 0) return void 0;
+  if (!/^\d+$/.test(v) || Number(v) <= 0) fail(`expected a positive integer, got ${v}`);
+  return Number(v);
+}
+function parseRunArgs(argv, env = process.env, isTTY = Boolean(process.stdout.isTTY)) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      "instruction-file": { type: "string" },
+      model: { type: "string", short: "m" },
+      workspace: { type: "string" },
+      "config-home": { type: "string" },
+      log: { type: "string" },
+      profile: { type: "string" },
+      yolo: { type: "boolean", default: false },
+      format: { type: "string" },
+      session: { type: "string" },
+      "max-wall-sec": { type: "string" },
+      "max-steps": { type: "string" },
+      "non-progress-rounds": { type: "string" },
+      "idle-timeout-sec": { type: "string" },
+      "opencode-bin": { type: "string" }
+    },
+    strict: true
+  });
+  let instruction = positionals.join(" ").trim();
+  if (values["instruction-file"]) {
+    if (instruction) fail("pass the task as text or --instruction-file, not both");
+    instruction = readFileSync(values["instruction-file"], "utf8").trim();
+  }
+  if (!instruction) fail('a task is required: mouse run "task" or --instruction-file FILE');
+  const model = values.model ?? env.MOUSE_MODEL;
+  if (!model?.includes("/")) fail("--model provider/model is required (or set MOUSE_MODEL)");
+  const profile = values.profile ?? "local";
+  if (profile !== "local" && profile !== "bench")
+    fail(`--profile must be local or bench, got ${profile}`);
+  const format = values.format ?? (isTTY ? "text" : "json");
+  if (format !== "text" && format !== "json") fail(`--format must be text or json, got ${format}`);
+  return {
+    instruction,
+    model,
+    workspace: path4.resolve(values.workspace ?? process.cwd()),
+    configHome: values["config-home"] ?? configHomeFromEnv(env),
+    logFile: values.log ?? env.MOUSE_HARNESS_LOG,
+    profile,
+    yolo: values.yolo,
+    // `opencode run` reads no stdin, so a permission prompt could never be
+    // answered; without a terminal the only workable mode is to skip them.
+    skipPermissions: values.yolo || !isTTY,
+    warnNoTerminal: !values.yolo && !isTTY,
+    format,
+    session: values.session,
+    maxWallSec: positiveInt(values["max-wall-sec"] ?? env.MOUSE_MAX_WALL_SEC),
+    maxSteps: positiveInt(values["max-steps"]),
+    nonProgressRounds: positiveInt(values["non-progress-rounds"]),
+    idleSec: positiveInt(values["idle-timeout-sec"]),
+    opencodeBin: values["opencode-bin"]
+  };
+}
+async function runCommand2(argv) {
+  const args = parseRunArgs(argv);
+  const startedAt = Date.now();
+  const ws = localWorkspace({ root: args.workspace });
+  const policy = await loadPolicy(ws);
+  const budget = {
+    maxWallSec: args.maxWallSec ?? policy.loop.maxWallSec,
+    maxSteps: args.maxSteps ?? policy.loop.maxSteps,
+    nonProgressRounds: args.nonProgressRounds ?? policy.loop.nonProgressRounds,
+    idleSec: args.idleSec ?? policy.loop.idleTimeoutSec
+  };
+  const trace = openTrace(args.logFile ?? traceFile(args.workspace));
+  const say = (line) => {
+    if (args.format === "text") process.stdout.write(`${line}
+`);
+  };
+  const bin = locateOpencode({ flag: args.opencodeBin, cwd: args.workspace });
+  if (!bin)
+    fail(
+      "opencode not found: install it (npm i -g opencode-ai), or pass --opencode-bin / MOUSE_OPENCODE_BIN"
+    );
+  const env = { ...process.env };
+  let configFile;
+  if (args.profile === "bench") {
+    configFile = writeBenchConfig(args.configHome, args.model, policy);
+  } else {
+    env.OPENCODE_CONFIG_CONTENT = JSON.stringify(
+      buildOpencodeConfig({ profile: "local", model: args.model, permissions: policy.permissions })
+    );
+    const plugin = writePrunePlugin(args.configHome, policy);
+    if (plugin) say(`mouse: wrote ${plugin} (context.prune is enabled in .mouse/policy.json)`);
+  }
+  if (args.warnNoTerminal) {
+    process.stderr.write(
+      "mouse: no terminal to answer permission prompts; running as if --yolo was passed\n"
+    );
+  }
+  const marker = path4.join(tmpdir(), `mouse-${process.pid}.marker`);
+  writeFileSync(marker, "");
+  const abort = new AbortController();
+  const onSignal = () => abort.abort();
+  process.on("SIGTERM", onSignal);
+  process.on("SIGINT", onSignal);
+  const runStartSha = await headSha(ws);
+  const probe = makeProbe({
+    workspace: ws,
+    runStartSha,
+    marker,
+    signal: abort.signal,
+    checks: policy.verify.checks,
+    checkTimeoutMs: policy.verify.timeoutSec * 1e3
+  });
+  const initialFingerprint = await probe.fingerprint();
+  trace.write({
+    type: "mouse.start",
+    v: 1,
+    version: MOUSE_VERSION,
+    model: args.model,
+    workspace: args.workspace,
+    profile: args.profile,
+    runStartSha,
+    maxWallSec: budget.maxWallSec,
+    ...configFile ? { configFile } : {}
+  });
+  const engine = new OpencodeRunEngine({
+    bin,
+    cwd: args.workspace,
+    model: args.model,
+    agent: "build",
+    env,
+    idleTimeoutMs: budget.idleSec * 1e3,
+    skipPermissions: args.skipPermissions,
+    passthrough: (line) => {
+      if (args.format === "json") process.stdout.write(`${line}
+`);
+    },
+    passthroughErr: (line) => process.stderr.write(`${line}
+`),
+    trace: (r) => trace.write(r)
+  });
+  say(`mouse ${MOUSE_VERSION}: ${args.model}, profile ${args.profile}, trace ${trace.file}`);
+  let exitCode = EXIT.error;
+  try {
+    const sessionId = await engine.open({
+      sessionId: args.session,
+      title: args.instruction.slice(0, 60).replace(/\s+/g, " ")
+    });
+    const first = await engine.prompt(sessionId, args.instruction, abort.signal);
+    trace.write({
+      type: "mouse.turn",
+      steps: engine.steps,
+      tokens: engine.tokens,
+      sessionId: engine.sessionId
+    });
+    say(`turn 1: ${first.steps} steps`);
+    const result = await runCompletionLoop({
+      probe,
+      engine,
+      sessionId: engine.sessionId ?? sessionId,
+      model: args.model,
+      signal: abort.signal,
+      instruction: args.instruction,
+      onEvent: (e) => {
+        trace.write({ type: "mouse.event", event: e });
+        if (e.type === "check_status") say(`check ${e.name}: ${e.conclusion}`);
+        else say(`notice: ${e.message}`);
+      },
+      budget: {
+        maxWallMs: budget.maxWallSec * 1e3,
+        maxTotalSteps: budget.maxSteps,
+        maxNonProgressRounds: budget.nonProgressRounds,
+        minRoundMs: policy.loop.minRoundSec * 1e3
+      },
+      startedAt,
+      initialFingerprint,
+      steps: () => engine.steps,
+      lastAssistantText: () => engine.lastText,
+      onRound: (r) => {
+        trace.write({ type: "mouse.round", ...r });
+        say(
+          `round ${r.round} (${r.kind}): ${r.progressed ? "progressed" : "no change"}, ${r.stepsAfter} steps total`
+        );
+      }
+    });
+    trace.write({
+      type: "mouse.done",
+      outcome: result.outcome,
+      rounds: result.rounds.length,
+      checksRun: result.rounds.at(-1)?.checksRun ?? [],
+      totalSteps: result.totalSteps,
+      tokens: engine.tokens,
+      elapsedMs: Date.now() - startedAt,
+      sessionId: engine.sessionId
+    });
+    if (args.format === "text" && engine.lastText) say(`
+${engine.lastText}
+`);
+    say(
+      `outcome: ${result.outcome} after ${result.rounds.length} round(s), ${result.totalSteps} steps, ${Math.round((Date.now() - startedAt) / 1e3)}s, $${engine.tokens.cost.toFixed(2)}`
+    );
+    exitCode = exitCodeFor(result.outcome);
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    trace.write({
+      type: "mouse.error",
+      error: message,
+      steps: engine.steps,
+      elapsedMs: Date.now() - startedAt
+    });
+    process.stderr.write(`mouse: ${message}
+`);
+    exitCode = EXIT.error;
+  } finally {
+    process.off("SIGTERM", onSignal);
+    process.off("SIGINT", onSignal);
+    rmSync(marker, { force: true });
+  }
+  return exitCode;
+}
+async function configCommand(argv) {
+  const { values } = parseArgs({
+    args: argv,
+    options: {
+      out: { type: "string" },
+      model: { type: "string" },
+      profile: { type: "string" },
+      workspace: { type: "string" }
+    },
+    strict: true
+  });
+  const profile = values.profile ?? "local";
+  const ws = localWorkspace({ root: path4.resolve(values.workspace ?? process.cwd()) });
+  const policy = await loadPolicy(ws);
+  if (profile === "bench") {
+    const file = writeBenchConfig(values.out ?? configHomeFromEnv(), values.model, policy);
+    process.stdout.write(
+      `wrote ${file}
+
+--- agent prompt (build) ---
+${buildAgentPrompt("build", { profile })}
+`
+    );
+    return 0;
+  }
+  const config = buildOpencodeConfig({
+    profile: "local",
+    model: values.model,
+    permissions: policy.permissions
+  });
+  process.stdout.write(`${JSON.stringify(config, null, 2)}
+`);
+  return 0;
+}
+var POLICY_SKELETON = {
+  $docs: "https://github.com/mousedev/mouse-harness/blob/main/docs/config.md",
+  version: 1,
+  verify: { timeoutSec: DEFAULT_POLICY.verify.timeoutSec },
+  loop: { ...DEFAULT_POLICY.loop },
+  context: { prune: { ...DEFAULT_POLICY.context.prune } },
+  permissions: { bash: { "git push*": "deny", "rm -rf *": "deny" } }
+};
+function initCommand(argv) {
+  const { values } = parseArgs({
+    args: argv,
+    options: { workspace: { type: "string" } },
+    strict: true
+  });
+  const root = path4.resolve(values.workspace ?? process.cwd());
+  const dir = path4.join(root, ".mouse");
+  const file = path4.join(dir, "policy.json");
+  try {
+    readFileSync(file);
+    process.stdout.write(`${file} already exists; nothing written
+`);
+    return 0;
+  } catch {
+    mkdirSync2(dir, { recursive: true });
+    writeFileSync(file, `${JSON.stringify(POLICY_SKELETON, null, 2)}
+`);
+    process.stdout.write(`wrote ${file}
+`);
+    return 0;
+  }
+}
+var PROVIDER_KEY_ENV = {
+  anthropic: ["ANTHROPIC_API_KEY"],
+  openai: ["OPENAI_API_KEY"],
+  openrouter: ["OPENROUTER_API_KEY"],
+  "fireworks-ai": ["FIREWORKS_API_KEY"],
+  moonshotai: ["MOONSHOT_API_KEY"],
+  togetherai: ["TOGETHER_API_KEY"],
+  google: ["GOOGLE_GENERATIVE_AI_API_KEY", "GEMINI_API_KEY"]
+};
+async function doctorCommand(argv) {
+  const { values } = parseArgs({
+    args: argv,
+    options: {
+      model: { type: "string" },
+      workspace: { type: "string" },
+      "opencode-bin": { type: "string" },
+      "strict-compat": { type: "boolean", default: false }
+    },
+    strict: true
+  });
+  const lines = [];
+  let failed = false;
+  const root = path4.resolve(values.workspace ?? process.cwd());
+  const bin = locateOpencode({ flag: values["opencode-bin"], cwd: root });
+  const version = bin ? opencodeVersion(bin) : null;
+  const compat = checkCompat(version);
+  lines.push(`mouse      ${MOUSE_VERSION}`);
+  lines.push(
+    `opencode   ${bin ?? "not found (npm i -g opencode-ai)"}${version ? ` (${version})` : ""}`
+  );
+  if (!bin || !version) failed = true;
+  if (compat.level === "supported") lines.push(`compat     ${compat.version}: supported`);
+  else if (compat.level === "untested") {
+    lines.push(
+      `compat     ${compat.version}: untested (supported: ${compat.supported.join(", ")})`
+    );
+    if (values["strict-compat"]) failed = true;
+  } else lines.push("compat     unknown");
+  const model = values.model ?? process.env.MOUSE_MODEL;
+  if (model?.includes("/")) {
+    const provider = model.split("/")[0];
+    const envs = PROVIDER_KEY_ENV[provider] ?? [
+      `${provider.toUpperCase().replace(/-/g, "_")}_API_KEY`
+    ];
+    const present = envs.find((e) => process.env[e]);
+    lines.push(
+      `provider   ${provider}: ${present ? `${present} set` : `${envs.join("/")} not in env (opencode's own auth store may hold it: opencode auth list)`}`
+    );
+  } else {
+    lines.push("provider   pass --model provider/model to check its key");
+  }
+  const ws = localWorkspace({ root });
+  const sha = await headSha(ws);
+  lines.push(
+    `git        ${sha ? `repo at ${sha.slice(0, 12)}` : "not a git repo (fingerprint falls back to mtime scan)"}`
+  );
+  const policy = await loadPolicy(ws);
+  const checks = policy.verify.checks ?? checksFromEcosystem(await detectEcosystem(ws));
+  lines.push(
+    `checks     ${checks.length ? checks.map((c) => `${c.name} (${c.command})`).join("; ") : "none detected; the loop can only prove that files changed"}${policy.verify.checks ? " [from .mouse/policy.json]" : ""}`
+  );
+  lines.push(`traces     ${runsDir(root)}`);
+  process.stdout.write(`${lines.join("\n")}
+`);
+  return failed ? 1 : 0;
+}
+function versionCommand(argv) {
+  const { values } = parseArgs({
+    args: argv,
+    options: { "opencode-bin": { type: "string" } },
+    strict: true
+  });
+  const bin = locateOpencode({ flag: values["opencode-bin"] });
+  process.stdout.write(`${versionLine(bin ? opencodeVersion(bin) : null)}
+`);
+  return 0;
+}
+var USAGE = `mouse ${MOUSE_VERSION}: run OpenCode in a repo until its checks pass.
+
+usage:
+  mouse run "task" | --instruction-file F   --model provider/model [--workspace DIR]
+           [--profile local|bench] [--yolo] [--format text|json] [--log FILE] [--session ID]
+           [--max-wall-sec N] [--max-steps N] [--non-progress-rounds N] [--idle-timeout-sec N]
+           [--config-home DIR] [--opencode-bin PATH]
+  mouse config [--profile local|bench] [--model M] [--out DIR]
+  mouse init [--workspace DIR]
+  mouse doctor [--model M] [--workspace DIR] [--strict-compat]
+  mouse --version
+
+exit codes: 0 satisfied, 1 error, 2 usage, 3 budget (stalled, wall clock, steps), 4 blocked, 130 aborted
+`;
+async function main(argv = process.argv.slice(2)) {
+  const [command, ...rest] = argv;
+  try {
+    switch (command) {
+      case "run":
+        return await runCommand2(rest);
+      case "config":
+        return await configCommand(rest);
+      case "init":
+        return initCommand(rest);
+      case "doctor":
+        return await doctorCommand(rest);
+      case "version":
+      case "--version":
+      case "-v":
+        return versionCommand(rest);
+      case "help":
+      case "--help":
+      case "-h":
+        process.stdout.write(USAGE);
+        return 0;
+      default:
+        process.stderr.write(USAGE);
+        return EXIT.usage;
+    }
+  } catch (e) {
+    if (e instanceof UsageError || isParseArgsError(e)) {
+      process.stderr.write(`mouse: ${e.message}
+`);
+      return EXIT.usage;
+    }
+    if (e instanceof Error) {
+      process.stderr.write(`mouse: ${e.message}
+`);
+      return EXIT.error;
+    }
+    throw e;
+  }
+}
+function isParseArgsError(e) {
+  return e instanceof Error && String(e.code).startsWith("ERR_PARSE_ARGS_");
+}
+function invokedDirectly() {
+  const entry = process.argv[1];
+  if (typeof entry !== "string") return false;
+  try {
+    return realpathSync(entry) === fileURLToPath(import.meta.url);
+  } catch {
+    return false;
+  }
+}
+if (invokedDirectly()) {
+  main().then(
+    (code) => process.exit(code),
+    (e) => {
+      process.stderr.write(`mouse: ${e instanceof Error ? e.message : String(e)}
+`);
+      process.exit(EXIT.error);
+    }
+  );
+}
+export {
+  EXIT,
+  exitCodeFor,
+  main,
+  parseRunArgs,
+  writeBenchConfig
+};