@mushi-mushi/cli 0.35.7 → 0.36.1

package/README.md

@@ -21,7 +21,7 @@ npm install -g @mushi-mushi/cli      # optional: a global `mushi` command
 
 The wizard detects your framework and package manager, checks your credentials, installs the right SDK, writes framework-prefixed env vars (`NEXT_PUBLIC_`, `VITE_`, `EXPO_PUBLIC_`…) to `.env.local`, prints the snippet to paste, and offers to send a test report. It never overwrites an existing env var or edits your code.
 
-**Credentials** come from the [console](https://kensaur.us/mushi-mushi/admin): the **project ID** is on the Projects page; the **API key** is under **Setup → Verify → Generate API key** (`report:write`), not the AI keys in Settings. No project yet? The wizard can open the console for you.
+**Credentials** come from the [console](https://kensaur.us/mushi-mushi/admin): the **project ID** is on the **Manage apps** page; the **API key** is under **Set up → Test it → Generate API key** (`report:write`), not the AI keys in Settings. No project yet? The wizard can open the console for you.
 
 For your editor, `mushi setup` writes the hosted MCP entry by default: the editor opens a browser sign-in on first use and no key is stored on disk. Add `--stdio` for a local server instead.
 
@@ -32,7 +32,7 @@ For your editor, `mushi setup` writes the hosted MCP entry by default: the edito
 | Set up | `init`, `login`, `setup`, `connect`, `doctor`, `test` (send a test report), `upgrade`, `nudge`, `completion`, `profile` |
 | Bugs | `reports list/show/search/triage`, `lessons list/show`, `sentry import` |
 | Fixes | `fix <reportId>`, `fixes tail/merge/refresh-ci/review/verify`, `verify workflow` |
-| Local agent | `work` (a Cursor agent on your own computer fixes a report; you push), `worker install/status/revoke` (keeps it running, steered from the console) |
+| Local agent | `work` (the Cursor CLI or Claude Code on your own computer fixes a report; `mushi work` pushes and opens the draft PR with your `git` and `gh`), `worker install/status/revoke` (keeps it running, steered from the console) |
 | Ship | `sourcemaps upload`, `deploy check`, `migrate`, `audit`, `releases` |
 | Test and UX | `qa stories/runs/run`, `tdd gen/pending/approve/improve`, `stories map`, `ux` (including `ux fresh-eyes`, the first-time user test) |
 | CI | `runner status/compare/bill`: where your tests run, what they cost, and whether a red check was your code or the machine |
@@ -45,7 +45,7 @@ For your editor, `mushi setup` writes the hosted MCP entry by default: the edito
 ```bash
 mushi doctor --fix                                  # check SDK, ingest and dispatch; fix what's safe locally
 mushi reports list --status new --severity critical # what broke
-mushi fix <reportId> --wait                         # an agent opens a draft PR for it (your own AI key)
+mushi fix <reportId> --wait                         # the built-in fixer opens a draft PR for it
 mushi fixes merge <fixId>                           # merge it and mark the report Fixed
 mushi upgrade                                       # bump @mushi-mushi/* to the latest stable
 mushi upgrade --check                               # CI: exit 0 current, 1 outdated, 2 registry down
@@ -62,7 +62,7 @@ MUSHI_API_KEY=mushi_xxx mushi connect --project-id <uuid> --endpoint <url> --wai
 
 Other `init` flags: `--framework next`, `--cwd apps/web` (monorepos), `--endpoint <url>` (self-hosted), `--skip-install`, `--audit` (check an existing install instead).
 
-**What needs your own key.** Reading reports, diagnoses and fix prompts does not. `mushi fix` hands the report to an agent that runs on your own key: Anthropic for the built-in fixer (the default), or Cursor with `--agent cursor_cloud`. `mushi work` runs a Cursor agent on your own computer instead.
+**What needs your own key.** Reading reports, diagnoses and fix prompts does not. `mushi fix` hands the report to the built-in fixer by default (`--agent claude_code`): it uses your own Anthropic or OpenAI key when you have added one, and on hosted Mushi Mushi it falls back to Mushi Mushi's key when you have not. `--agent cursor_cloud` needs your own Cursor key. `mushi work` runs the Cursor CLI or Claude Code (`--agent claude`, CLI 0.36.0 or later) on your own computer instead, on the account that tool is signed in to.
 
 ## Environment variables
 

package/dist/chunk-5DQLHMVZ.js

@@ -0,0 +1,8 @@
+// src/version.ts
+var MUSHI_CLI_VERSION = true ? "0.36.1" : "0.0.0-dev";
+var MUSHI_MCP_PIN_SPEC = "@mushi-mushi/mcp@0.30.7";
+
+export {
+  MUSHI_CLI_VERSION,
+  MUSHI_MCP_PIN_SPEC
+};

package/dist/{chunk-YAVF3ZUN.js → chunk-D3ABBB6H.js}

@@ -8,10 +8,10 @@ import {
   requireConfig,
   requireUuid,
   tryLoadWorkerKey
-} from "./chunk-PAL6GBXT.js";
+} from "./chunk-TFNFJXCK.js";
 import {
   MUSHI_CLI_VERSION
-} from "./chunk-SC376RQS.js";
+} from "./chunk-R4ZRRD4B.js";
 
 // src/worker/daemon.ts
 import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
@@ -302,13 +302,116 @@ function collectHeartbeat(io, mushiVersion) {
   };
 }
 
+// src/commands/work-agents.ts
+import { stripVTControlCharacters } from "util";
+var LOCAL_AGENTS = ["cursor", "claude"];
+function cursorSignInState(p) {
+  if (p.code === null && /\bENOENT\b/.test(p.stderr)) return "missing";
+  if (p.timedOut || p.code === null) return "unknown";
+  const out = stripVTControlCharacters(`${p.stdout}
+${p.stderr}`);
+  if (/\bnot\s+(?:logged|signed)\s+in\b|\blogged\s+out\b/i.test(out)) return "signed_out";
+  if (p.code === 0 && /\b(?:logged|signed)\s+in\b/i.test(out)) return "signed_in";
+  return "unknown";
+}
+function claudeSignInState(p) {
+  if (p.code === null && /\bENOENT\b/.test(p.stderr)) return "missing";
+  if (p.timedOut || p.code === null) return "unknown";
+  const out = stripVTControlCharacters(p.stdout).trim();
+  try {
+    const parsed = JSON.parse(out.slice(out.indexOf("{")));
+    if (parsed.loggedIn === true) return "signed_in";
+    if (parsed.loggedIn === false) return "signed_out";
+  } catch {
+  }
+  if (/\bnot\s+(?:logged|signed)\s+in\b/i.test(`${out}
+${p.stderr}`)) return "signed_out";
+  return "unknown";
+}
+var AGENTS = {
+  cursor: {
+    label: "Cursor",
+    branchTag: "cursor",
+    bin: "cursor-agent",
+    run: ({ mode, workspace, model, prompt }) => ({
+      cmd: "cursor-agent",
+      args: [
+        "-p",
+        ...mode === "ask" ? ["--mode", "ask"] : ["--force"],
+        "--trust",
+        "--output-format",
+        "text",
+        "--workspace",
+        workspace,
+        ...model ? ["--model", model] : [],
+        prompt
+      ]
+    }),
+    status: ["status"],
+    signInState: cursorSignInState,
+    install: "Install it: https://cursor.com/cli",
+    login: "Run: cursor-agent login",
+    models: "cursor-agent --list-models"
+  },
+  claude: {
+    label: "Claude Code",
+    branchTag: "claude",
+    bin: "claude",
+    // The worktree is the cwd (runProc's), which is Claude Code's workspace.
+    run: ({ mode, model, prompt }) => ({
+      cmd: "claude",
+      args: [
+        "-p",
+        "--output-format",
+        "text",
+        // ask: read-only tools, and anything that would prompt is refused.
+        ...mode === "ask" ? ["--permission-mode", "dontAsk", "--tools", "Read,Grep,Glob"] : ["--permission-mode", "bypassPermissions"],
+        "--strict-mcp-config",
+        "--setting-sources",
+        "project,local",
+        "--no-session-persistence",
+        ...model ? ["--model", model] : []
+      ],
+      input: prompt
+    }),
+    status: ["auth", "status"],
+    signInState: claudeSignInState,
+    install: "Install it: https://code.claude.com/docs/en/setup (the native installer puts claude on PATH)",
+    login: "Run: claude auth login",
+    models: "an alias such as opus, sonnet or haiku, or a full claude-\u2026 id"
+  }
+};
+function agentSpec(agent) {
+  return AGENTS[agent];
+}
+function agentRun(agent, o) {
+  return AGENTS[agent].run(o);
+}
+function parseLocalAgent(raw, where = "--agent") {
+  if (raw === void 0 || raw === null || raw === "") return "cursor";
+  if (typeof raw === "string" && LOCAL_AGENTS.includes(raw.toLowerCase())) return raw.toLowerCase();
+  throw new MushiCliError("E_INVALID_INPUT", `Unknown agent "${String(raw).slice(0, 40)}" (${where}).`, `Use one of: ${LOCAL_AGENTS.join(", ")}.`);
+}
+function isClaudeModel(id) {
+  if (/\.|-(?:low|medium|high|xhigh|max|thinking|fast)$/i.test(id)) return false;
+  return /^(?:claude-[a-z]|(?:opus|sonnet|haiku|fable)$)/i.test(id);
+}
+var AGENT_UNAVAILABLE = /ActionRequiredError|Increase limits|usage limit|out of (?:extra )?(?:usage|credits)|Cannot use this model|You've (?:hit|reached) your|You're out of usage|(?:spend|usage) limit reached|limit reached\s*[·∙•]\s*resets|credit balance (?:is )?too low|run \/login|Invalid API key|OAuth token (?:has )?(?:expired|refresh failed|unavailable)|issue with the selected model/i;
+function agentUnavailable(run) {
+  if (run.code === 0 || run.timedOut) return false;
+  const text = stripVTControlCharacters(`${run.stdout}
+${run.stderr}`).trim();
+  return AGENT_UNAVAILABLE.test(text.length > 4e3 ? `${text.slice(0, 2e3)}
+${text.slice(-2e3)}` : text);
+}
+
 // src/commands/work.ts
 import { spawn } from "child_process";
 import { createHash as createHash2 } from "crypto";
 import { existsSync, mkdirSync, rmSync } from "fs";
 import { homedir, tmpdir } from "os";
 import { basename, join as join2 } from "path";
-import { stripVTControlCharacters } from "util";
+import { stripVTControlCharacters as stripVTControlCharacters2 } from "util";
 var WORK_AGENT_KIND = "mcp";
 var WORK_AGENT_TIMEOUT_MS = 30 * 6e4;
 var PROMPT_MAX_CHARS = 4e4;
@@ -342,14 +445,14 @@ function freeBranchName(base, onOrigin) {
 function branchNameFor(reportId, category, agent = "cursor") {
   const c = (category ?? "bug").toLowerCase();
   const prefix = c === "other" ? "chore" : ["feature", "bugfix", "hotfix", "refactor", "chore", "docs", "test", "ci"].includes(c) ? c : "bugfix";
-  return `${prefix}/MUSHI-${reportId}-local-${agent}`;
+  return `${prefix}/MUSHI-${reportId}-local-${agentSpec(agent).branchTag}`;
 }
 function cap(text, max) {
   const t = (text ?? "").replace(/\s+/g, " ").trim();
   return t.length > max ? `${t.slice(0, max)} [cut]` : t;
 }
 function failureTail(r, max = 600) {
-  const t = [r.stdout, r.stderr].map((x) => x.trim()).filter(Boolean).join("\n").replace(/[ \t]+/g, " ");
+  const t = stripVTControlCharacters2([r.stdout, r.stderr].map((x) => x.trim()).filter(Boolean).join("\n")).replace(/[ \t]+/g, " ");
   const lines = t.split("\n").map((l) => l.trim()).filter(Boolean);
   const kept = [];
   let size = 0;
@@ -361,7 +464,7 @@ function failureTail(r, max = 600) {
   return kept.length < lines.length ? `[\u2026] ${kept.join(" / ")}` : kept.join(" / ");
 }
 function hookFailureDetail(r, max = 900) {
-  const text = stripVTControlCharacters([r.stdout, r.stderr].join("\n"));
+  const text = stripVTControlCharacters2([r.stdout, r.stderr].join("\n"));
   const failed = [...text.matchAll(/^\s*🥊\s+([\w:.-]+)/gmu)].map((m) => m[1]);
   if (!failed.length) return null;
   const lines = text.split("\n");
@@ -530,7 +633,11 @@ function agentEnv(base, emptyDir) {
     GIT_CONFIG_GLOBAL: join2(emptyDir, "gitconfig"),
     GIT_TERMINAL_PROMPT: "0",
     GIT_ASKPASS: "false",
-    GIT_SSH_COMMAND: "false"
+    GIT_SSH_COMMAND: "false",
+    GIT_CONFIG_COUNT: "1",
+    GIT_CONFIG_KEY_0: "credential.helper",
+    GIT_CONFIG_VALUE_0: "",
+    GCM_INTERACTIVE: "never"
   };
 }
 var liveChildren = /* @__PURE__ */ new Set();
@@ -686,6 +793,14 @@ async function earlierFor(api, detail) {
   }
   return out;
 }
+function agentUnavailablePayload(branch, agent, run, now = /* @__PURE__ */ new Date()) {
+  return {
+    status: "failed",
+    branch,
+    error: `${WORK_INFRA_PREFIX} the ${agentSpec(agent).label} agent could not run (usage or sign-in): ${failureTail(run, 300)}`.slice(0, 1e3),
+    completed_at: now.toISOString()
+  };
+}
 async function workOne(api, detail, o) {
   const base = await defaultBranch(o.repoDir);
   await git(o.repoDir, ["fetch", "--quiet", "origin", base]);
@@ -744,14 +859,12 @@ async function workOne(api, detail, o) {
     await api(`/v1/admin/fixes/${fixId}`, { method: "PATCH", body: JSON.stringify(runningPayload(branch)) }).catch(
       (err) => o.log(`  fix ${fixId}: not marked running (${err instanceof Error ? err.message : String(err)})`)
     );
-    o.log(`  agent: cursor-agent in ${wt} (up to ${WORK_AGENT_TIMEOUT_MS / 6e4} min); fix ${fixId} shows as running in the console`);
+    const spec = agentSpec(o.agent);
+    o.log(`  agent: ${spec.bin} in ${wt} (up to ${WORK_AGENT_TIMEOUT_MS / 6e4} min); fix ${fixId} shows as running in the console`);
     stage = "agent";
     o.onStage?.(stage);
-    const run = await runProc(
-      "cursor-agent",
-      ["-p", "--force", "--trust", "--output-format", "text", "--workspace", wt, ...o.model ? ["--model", o.model] : [], prompt],
-      { cwd: wt, env: agentEnv(process.env, empty), timeoutMs: WORK_AGENT_TIMEOUT_MS, signal: o.signal }
-    );
+    const inv = agentRun(o.agent, { mode: "edit", workspace: wt, model: o.model, prompt });
+    const run = await runProc(inv.cmd, inv.args, { cwd: wt, env: agentEnv(process.env, empty), timeoutMs: WORK_AGENT_TIMEOUT_MS, signal: o.signal, ...inv.input !== void 0 ? { input: inv.input } : {} });
     const stoppedBy = interruptedBy() ?? (o.signal?.aborted ? "lost lease" : null);
     if (stoppedBy) {
       keep = true;
@@ -760,8 +873,14 @@ async function workOne(api, detail, o) {
     }
     if (run.timedOut) o.log("  agent: timed out; keeping what it changed");
     const status = await git(wt, ["status", "--porcelain"]);
+    const spent = agentUnavailable(run) || !status && run.code === 0 && !parseVerdict(run.stdout).verdict && agentUnavailable({ ...run, code: 1 });
+    if (spent) {
+      keep = true;
+      await close(agentUnavailablePayload(branch, o.agent, run));
+      return { reportId: detail.id, result: "failed", failureKind: "infra", agentUnavailable: true, outcome: `failed (infra): the ${spec.label} agent could not run (usage or sign-in): ${failureTail(run, 300)}`, fixId };
+    }
     if (!status) {
-      const noPr = run.timedOut ? { verdict: null, reason: `timed out after ${WORK_AGENT_TIMEOUT_MS / 6e4} min without a change; the report may need splitting into one page or cause each` } : run.code === 0 ? parseVerdict(run.stdout) : { verdict: null, reason: failureTail(run, 300) || `cursor-agent exited ${run.code}` };
+      const noPr = run.timedOut ? { verdict: null, reason: `timed out after ${WORK_AGENT_TIMEOUT_MS / 6e4} min without a change; the report may need splitting into one page or cause each` } : run.code === 0 ? parseVerdict(run.stdout) : { verdict: null, reason: failureTail(run, 300) || `${spec.bin} exited ${run.code}` };
       await close(submitPayload({ branch, prUrl: null, commitSha: null, filesChanged: [], linesChanged: 0, summary: "", noPr }));
       return { reportId: detail.id, result: run.timedOut ? "timeout" : noPr.verdict ? "verdict" : "no_change", outcome: `no change (${noPr.verdict ?? "no verdict"}): ${noPr.reason}`, fixId };
     }
@@ -774,7 +893,7 @@ async function workOne(api, detail, o) {
     o.onStage?.(stage);
     await git(wt, ["add", "-A"]);
     const last = run.stdout.trim().split("\n").filter((l) => l.trim()).slice(-6).join(" ");
-    await commitWithHooks(wt, ["--quiet", "-m", prTitle(detail.summary, detail.id), "-m", commitBody(`Mushi report: ${detail.id}`, "Made by a local Cursor agent through `mushi work`.")], o.log);
+    await commitWithHooks(wt, ["--quiet", "-m", prTitle(detail.summary, detail.id), "-m", commitBody(`Mushi report: ${detail.id}`, `Made by a local ${spec.label} agent through \`mushi work\`.`)], o.log);
     const sha = await git(wt, ["rev-parse", "HEAD"]);
     const numstat = await git(wt, ["diff", "--numstat", `origin/${base}`, "HEAD"]);
     const files = [];
@@ -798,7 +917,7 @@ async function workOne(api, detail, o) {
 
 ${cap(last, 1500) || "See the commits."}
 
-Opened by \`mushi work\` with a local Cursor agent; Mushi's Opus review decides whether it merges.`;
+Opened by \`mushi work\` with a local ${spec.label} agent; Mushi's Opus review decides whether it merges.`;
     const pr = await runProc("gh", ["pr", "create", "--draft", "--base", base, "--head", branch, "--title", prTitle(detail.summary, detail.id), "--body", body], { cwd: wt });
     const prUrl = pr.stdout.match(/https:\/\/github\.com\/\S+\/pull\/\d+/)?.[0] ?? null;
     if (!prUrl) throw new MushiCliError("E_INTERNAL", `gh pr create failed: ${failureTail(pr)}`);
@@ -851,27 +970,31 @@ async function followUpOne(api, f, o) {
     const empty = join2(tmpdir(), `mushi-work-${process.pid}`);
     mkdirSync(empty, { recursive: true });
     o.onStage?.("agent");
-    o.log(`  agent: cursor-agent on ${claim.branch}, round ${claim.round}, ${claim.findingsSent} finding(s)${claim.findingsDropped ? ` (${claim.findingsDropped} left out by the safety screen)` : ""}`);
-    const run = await runProc(
-      "cursor-agent",
-      ["-p", "--force", "--trust", "--output-format", "text", "--workspace", wt, ...o.model ? ["--model", o.model] : [], claim.prompt],
-      { cwd: wt, env: agentEnv(process.env, empty), timeoutMs: WORK_AGENT_TIMEOUT_MS }
-    );
+    const spec = agentSpec(o.agent);
+    o.log(`  agent: ${spec.bin} on ${claim.branch}, round ${claim.round}, ${claim.findingsSent} finding(s)${claim.findingsDropped ? ` (${claim.findingsDropped} left out by the safety screen)` : ""}`);
+    const inv = agentRun(o.agent, { mode: "edit", workspace: wt, model: o.model, prompt: claim.prompt });
+    const run = await runProc(inv.cmd, inv.args, { cwd: wt, env: agentEnv(process.env, empty), timeoutMs: WORK_AGENT_TIMEOUT_MS, ...inv.input !== void 0 ? { input: inv.input } : {} });
     const stoppedBy = interruptedBy();
     if (stoppedBy) {
       keep = true;
       return { fixId: f.fixId, outcome: `stopped by ${stoppedBy}; the change so far is kept in ${wt}` };
     }
+    if (agentUnavailable(run)) {
+      keep = true;
+      const why = `${WORK_INFRA_PREFIX} the ${spec.label} agent could not run (usage or sign-in): ${failureTail(run, 300)}`;
+      await done(null, why);
+      return { fixId: f.fixId, outcome: `failed: ${why}`, agentUnavailable: true };
+    }
     if (run.timedOut) o.log("  agent: timed out; keeping what it changed");
     const last = run.stdout.trim().split("\n").filter((l) => l.trim()).slice(-6).join(" ");
     if (!await git(wt, ["status", "--porcelain"])) {
       const why = run.code === 0 ? cap(last, 300) : failureTail(run, 300);
       await done(null, why);
-      return { fixId: f.fixId, outcome: `no change: ${why || `cursor-agent exited ${run.code}`}` };
+      return { fixId: f.fixId, outcome: `no change: ${why || `${spec.bin} exited ${run.code}`}` };
     }
     o.onStage?.("commit");
     await git(wt, ["add", "-A"]);
-    await commitWithHooks(wt, ["--quiet", "-m", `fix: address the Opus review (round ${claim.round})`, "-m", commitBody(cap(last, 1500) || "See the diff.", "Made by a local Cursor agent through `mushi work --followups`.")], o.log);
+    await commitWithHooks(wt, ["--quiet", "-m", `fix: address the Opus review (round ${claim.round})`, "-m", commitBody(cap(last, 1500) || "See the diff.", `Made by a local ${spec.label} agent through \`mushi work --followups\`.`)], o.log);
     const sha = await git(wt, ["rev-parse", "HEAD"]);
     o.onStage?.("push");
     await pushWithHooks(wt, ["--quiet", "origin", `HEAD:refs/heads/${claim.branch}`], o.log);
@@ -897,10 +1020,15 @@ async function installDeps(wt, log) {
   const cmd = installCommand((f) => existsSync(join2(wt, f)));
   if (!cmd) return;
   log(`  deps: ${cmd[0]} ${cmd[1][0]} (so the agent can run tests and the commit hooks work)`);
-  let r = await runProc(cmd[0], cmd[1], { cwd: wt, timeoutMs: 10 * 6e4 });
-  if (r.code !== 0) r = await runProc(cmd[0], cmd[1], { cwd: wt, timeoutMs: 10 * 6e4 });
+  const [bin, args] = windowsShim(cmd, process.platform);
+  let r = await runProc(bin, args, { cwd: wt, timeoutMs: 10 * 6e4 });
+  if (r.code !== 0) r = await runProc(bin, args, { cwd: wt, timeoutMs: 10 * 6e4 });
   if (r.code !== 0) log(`  deps: install failed twice, the agent works without them (${failureTail(r, 300)})`);
 }
+function windowsShim(cmd, platform) {
+  if (platform !== "win32") return cmd;
+  return ["cmd.exe", ["/d", "/s", "/c", cmd[0], ...cmd[1]]];
+}
 function isMissingModuleFailure(message) {
   return /ERR_MODULE_NOT_FOUND|Cannot find (package|module)/.test(message);
 }
@@ -927,41 +1055,37 @@ async function pushWithHooks(wt, args, log) {
     log("  push: the hook passed the second time, so the first failure was this machine, not the change");
   }
 }
-function cursorSignInState(p) {
-  if (p.code === null && /\bENOENT\b/.test(p.stderr)) return "missing";
-  if (p.timedOut || p.code === null) return "unknown";
-  const out = stripVTControlCharacters(`${p.stdout}
-${p.stderr}`);
-  if (/\bnot\s+(?:logged|signed)\s+in\b|\blogged\s+out\b/i.test(out)) return "signed_out";
-  if (p.code === 0 && /\b(?:logged|signed)\s+in\b/i.test(out)) return "signed_in";
-  return "unknown";
-}
 var CURSOR_STATUS_TIMEOUT_MS = 9e4;
 var CURSOR_STATUS_RETRY_DELAY_MS = 5e3;
-async function checkCursorSignIn(run = runProc, wait = (ms) => new Promise((r) => setTimeout(r, ms))) {
+async function checkAgentSignIn(agent, run = runProc, wait = (ms) => new Promise((r) => setTimeout(r, ms))) {
+  const spec = agentSpec(agent);
   let last = { state: "unknown", detail: "not checked", output: "" };
   for (let attempt = 0; attempt < 2; attempt++) {
     if (attempt > 0) await wait(CURSOR_STATUS_RETRY_DELAY_MS);
-    const p = await run("cursor-agent", ["status"], { timeoutMs: CURSOR_STATUS_TIMEOUT_MS });
-    const state = cursorSignInState(p);
-    const detail = p.timedOut ? `timed out after ${CURSOR_STATUS_TIMEOUT_MS / 1e3} s` : stripVTControlCharacters(`${p.stdout}
+    const p = await run(spec.bin, spec.status, { timeoutMs: CURSOR_STATUS_TIMEOUT_MS });
+    const state = spec.signInState(p);
+    const detail = p.timedOut ? `timed out after ${CURSOR_STATUS_TIMEOUT_MS / 1e3} s` : stripVTControlCharacters2(`${p.stdout}
 ${p.stderr}`).trim().split("\n")[0]?.slice(0, 200) || `exit ${p.code}`;
-    last = { state, detail, output: stripVTControlCharacters(`${p.stdout}
+    last = { state, detail, output: stripVTControlCharacters2(`${p.stdout}
 ${p.stderr}`).slice(0, 2e3) };
     if (state === "signed_in" || state === "missing") break;
   }
   return last;
 }
-async function preflight(repoDir, warn) {
-  const signIn = await checkCursorSignIn();
+function checkCursorSignIn(run, wait) {
+  return checkAgentSignIn("cursor", run, wait);
+}
+async function preflight(repoDir, warn, agent = "cursor") {
+  const spec = agentSpec(agent);
+  const signIn = await checkAgentSignIn(agent);
   if (signIn.state === "missing") {
-    throw new MushiCliError("E_FILE_NOT_FOUND", "The Cursor CLI (cursor-agent) is not installed or not on PATH.", "Install it: https://cursor.com/cli");
+    throw new MushiCliError("E_FILE_NOT_FOUND", `${spec.label} (${spec.bin}) is not installed or not on PATH.`, spec.install);
   }
   if (signIn.state === "signed_out") {
-    throw new MushiCliError("E_AUTH_MISSING", "The Cursor CLI is not signed in.", "Run: cursor-agent login");
+    throw new MushiCliError("E_AUTH_MISSING", `${spec.label} (${spec.bin}) is not signed in.`, spec.login);
   }
   if (signIn.state === "unknown") {
-    warn(`Could not confirm the Cursor CLI sign-in (${signIn.detail}); continuing. If it is signed out, the agent stops at once: run cursor-agent login.`);
+    warn(`Could not confirm the ${spec.label} sign-in (${signIn.detail}); continuing. If it is signed out, the agent stops at once: ${spec.login.replace(/^Run: /, "run ")}.`);
   }
   const gh = await runProc("gh", ["auth", "status"], { timeoutMs: 3e4 });
   if (gh.code !== 0) throw new MushiCliError("E_AUTH_MISSING", "gh is not signed in.", "Run: gh auth login");
@@ -978,15 +1102,19 @@ async function requireWriteScope(cfg) {
   const problem = missingWriteScope(scopes, cfg.projectId);
   if (problem) throw new MushiCliError("E_AUTH_MISSING", problem, `mushi login --upgrade-scope${cfg.projectId ? ` --project-id ${cfg.projectId}` : ""}`);
 }
+function stopLine(agent, left, what) {
+  const spec = agentSpec(agent);
+  return `Stopped: the ${spec.label} agent could not run (out of usage or signed out). ${left} ${what}${left === 1 ? "" : "s"} left untouched and can be picked up again; the run was closed without a retry cooldown. Check: ${spec.bin} ${spec.status.join(" ")}`;
+}
 function registerWorkCommands(program) {
-  program.command("work").description("Fix reports with a coding agent on this machine (local Cursor CLI); pushes and opens the draft PR with your git and gh").option("--repo-dir <path>", "A clone of the app repo (only worktrees are created in it); not with --daemon").option("--project <id>", "Project id (overrides MUSHI_PROJECT_ID)").option("--agent <name>", "Local agent: cursor", "cursor").option("--model <id>", "Model for the agent (cursor-agent --list-models)").option("--max <n>", "Reports per run", "3").option("--report <id>", "Work on this report only").option("--followups", 'Instead of new reports: fix the Opus "fix first" findings on PRs mushi work opened, and push to them').option("--keep", "Keep the worktree after the run").option("--dry-run", "Show what would run; change nothing").option("--json", "Machine-readable JSON output").option("--daemon", "Run as a local worker: register this machine, send a heartbeat every 60 s, take the console's lane settings and claim reports (set up with `mushi worker install`)").option("--worker-config <path>", "With --daemon: the lanes file (default ~/.config/mushi/worker.json)").action(async (opts) => {
-    if (opts.agent !== "cursor") throw new MushiCliError("E_INVALID_INPUT", `Unknown agent "${opts.agent}".`, "Only --agent cursor is supported.");
+  program.command("work").description("Fix reports with a coding agent on this machine (the Cursor CLI or Claude Code); pushes and opens the draft PR with your git and gh").option("--repo-dir <path>", "A clone of the app repo (only worktrees are created in it); not with --daemon").option("--project <id>", "Project id (overrides MUSHI_PROJECT_ID)").option("--agent <name>", "Local agent: cursor (cursor-agent, default) or claude (Claude Code, claude -p); with --daemon, overrides the worker config's agent").option("--model <id>", "Model for the agent (cursor: cursor-agent --list-models; claude: opus, sonnet, haiku or a claude-\u2026 id)").option("--max <n>", "Reports per run", "3").option("--report <id>", "Work on this report only").option("--followups", 'Instead of new reports: fix the Opus "fix first" findings on PRs mushi work opened, and push to them').option("--keep", "Keep the worktree after the run").option("--dry-run", "Show what would run; change nothing").option("--json", "Machine-readable JSON output").option("--daemon", "Run as a local worker: register this machine, send a heartbeat every 60 s, take the console's lane settings and claim reports (set up with `mushi worker install`)").option("--worker-config <path>", "With --daemon: the lanes file (default ~/.config/mushi/worker.json)").action(async (opts) => {
+    const agent = parseLocalAgent(opts.agent);
     if (opts.daemon) {
       if (opts.repoDir || opts.report || opts.followups) {
         throw new MushiCliError("E_INVALID_INPUT", "--daemon takes its lanes and clones from the worker config, not from --repo-dir, --report or --followups.", "mushi worker install");
       }
-      const { runDaemon: runDaemon2 } = await import("./daemon-FN3VM4R6.js");
-      await runDaemon2({ configPath: opts.workerConfig });
+      const { runDaemon: runDaemon2 } = await import("./daemon-VC4WW5GU.js");
+      await runDaemon2({ configPath: opts.workerConfig, ...opts.agent !== void 0 ? { agent } : {} });
       return;
     }
     if (!opts.repoDir) throw new MushiCliError("E_INVALID_INPUT", "mushi work needs --repo-dir <clone>.", "mushi work --repo-dir ~/src/my-app");
@@ -1012,18 +1140,22 @@ function registerWorkCommands(program) {
         if (!due.length) log("No pull request is waiting for a follow-up.");
         return;
       }
-      await preflight(repoDir, warn);
+      await preflight(repoDir, warn, agent);
       await requireWriteScope(cfg);
       const results2 = [];
       for (const f of due) {
         if (interruptedBy()) break;
         log(`follow-up ${f.prUrl ?? f.fixId}`);
-        const r = await followUpOne(api, f, { repoDir, agent: "cursor", model: opts.model, keep: opts.keep, log }).catch((err) => ({
+        const r = await followUpOne(api, f, { repoDir, agent, model: opts.model, keep: opts.keep, log }).catch((err) => ({
           fixId: f.fixId,
           outcome: `failed: ${err instanceof Error ? err.message : String(err)}`
         }));
         log(`  \u2192 ${r.outcome}`);
         results2.push(r);
+        if (r.agentUnavailable) {
+          warn(stopLine(agent, due.length - results2.length, "pull request"));
+          break;
+        }
       }
       if (results2.some((r) => r.outcome.startsWith("failed:"))) process.exitCode = 1;
       if (opts.json) process.stdout.write(`${JSON.stringify({ results: results2 }, null, 2)}
@@ -1032,20 +1164,20 @@ function registerWorkCommands(program) {
     }
     const picked = await pickReports(api, { max, reportId, projectId: cfg.projectId });
     if (opts.dryRun) {
-      const plan = picked.map((d) => ({ reportId: d.id, severity: d.severity ?? null, summary: d.summary, branch: branchNameFor(d.id, d.category) }));
+      const plan = picked.map((d) => ({ reportId: d.id, severity: d.severity ?? null, summary: d.summary, branch: branchNameFor(d.id, d.category, agent) }));
       if (opts.json) process.stdout.write(`${JSON.stringify({ dryRun: true, plan }, null, 2)}
 `);
       else for (const p of plan) log(`would fix ${p.reportId} [${p.severity ?? "?"}] ${cap(p.summary, 80)} \u2192 ${p.branch}`);
       if (!plan.length) log("Nothing to work on.");
       return;
     }
-    await preflight(repoDir, warn);
+    await preflight(repoDir, warn, agent);
     await requireWriteScope(cfg);
     const results = [];
     for (const d of picked) {
       if (interruptedBy()) break;
       log(`report ${d.id}: ${cap(d.summary, 80)}`);
-      const r = await workOne(api, d, { repoDir, agent: "cursor", model: opts.model, keep: opts.keep, log }).catch((err) => ({
+      const r = await workOne(api, d, { repoDir, agent, model: opts.model, keep: opts.keep, log }).catch((err) => ({
         reportId: d.id,
         result: "failed",
         failureKind: "infra",
@@ -1053,6 +1185,10 @@ function registerWorkCommands(program) {
       }));
       log(`  \u2192 ${r.outcome}${r.prUrl ? ` ${r.prUrl}` : ""}`);
       results.push(r);
+      if (r.agentUnavailable) {
+        warn(stopLine(agent, picked.length - results.length, "report"));
+        break;
+      }
     }
     if (results.some((r) => r.result === "failed")) process.exitCode = 1;
     if (opts.json) process.stdout.write(`${JSON.stringify({ results }, null, 2)}
@@ -1283,12 +1419,17 @@ async function auditPass(api, claimId, o) {
       return "error";
     }
   };
-  const ask = async (model, prompt) => runProc("cursor-agent", ["-p", "--mode", "ask", "--trust", "--output-format", "text", "--workspace", wt, ...model ? ["--model", model] : [], prompt], {
-    cwd: wt,
-    env: agentEnv(process.env, empty),
-    timeoutMs: ASK_TIMEOUT_MS,
-    signal: o.signal
-  });
+  const agent = o.agent ?? "cursor";
+  const ask = async (model, prompt) => {
+    const inv = agentRun(agent, { mode: "ask", workspace: wt, model, prompt });
+    return runProc(inv.cmd, inv.args, {
+      cwd: wt,
+      env: agentEnv(process.env, empty),
+      timeoutMs: ASK_TIMEOUT_MS,
+      signal: o.signal,
+      ...inv.input !== void 0 ? { input: inv.input } : {}
+    });
+  };
   let filed = 0;
   let held = 0;
   try {
@@ -1315,7 +1456,7 @@ async function auditPass(api, claimId, o) {
     const proposed = await ask(o.model, proposePrompt(screen, state.pass));
     if (o.signal?.aborted) return { result: "stopped", detail: `stopped (lost the lease) while reading ${screen}` };
     if (proposed.timedOut) return { result: "timeout", failureKind: "code", detail: `the model did not answer about ${screen} within ${ASK_TIMEOUT_MS / 6e4} min` };
-    if (proposed.code !== 0) return { result: "failed", failureKind: "infra", detail: `cursor-agent exited ${proposed.code}: ${failureTail(proposed, 200)}` };
+    if (proposed.code !== 0) return { result: "failed", failureKind: "infra", detail: `${agentSpec(agent).bin} exited ${proposed.code}: ${failureTail(proposed, 200)}` };
     const proposals = parseProposals(proposed.stdout);
     let reproduced = 0;
     let vetoes = 0;
@@ -1497,17 +1638,15 @@ async function resolveConflict(t, o) {
       o.log(`  conflicts in ${files.length} file(s): ${files.slice(0, 6).join(", ")}${files.length > 6 ? ", \u2026" : ""}`);
       const empty = join4(tmpdir3(), `mushi-conflict-${process.pid}`);
       mkdirSync3(empty, { recursive: true });
-      const run = await runProc(
-        "cursor-agent",
-        ["-p", "--force", "--trust", "--output-format", "text", "--workspace", wt, ...o.model ? ["--model", o.model] : [], conflictPromptLocal({ repo: t.repo, prNumber: t.prNumber, base, files })],
-        { cwd: wt, env: agentEnv(process.env, empty), timeoutMs: CONFLICT_AGENT_TIMEOUT_MS, signal: o.signal }
-      );
+      const agent = o.agent ?? "cursor";
+      const inv = agentRun(agent, { mode: "edit", workspace: wt, model: o.model, prompt: conflictPromptLocal({ repo: t.repo, prNumber: t.prNumber, base, files }) });
+      const run = await runProc(inv.cmd, inv.args, { cwd: wt, env: agentEnv(process.env, empty), timeoutMs: CONFLICT_AGENT_TIMEOUT_MS, signal: o.signal, ...inv.input !== void 0 ? { input: inv.input } : {} });
       if (o.signal?.aborted) {
         keep = true;
         return { result: "stopped", detail: `stopped (lost the lease); the worktree is kept in ${wt}` };
       }
       if (run.timedOut) return { result: "timeout", failureKind: "code", detail: `the agent did not finish within ${CONFLICT_AGENT_TIMEOUT_MS / 6e4} min` };
-      if (run.code !== 0) return { result: "failed", failureKind: classifyFailure(failureTail(run, 300), "agent"), detail: `cursor-agent exited ${run.code}: ${failureTail(run, 200)}` };
+      if (run.code !== 0) return { result: "failed", failureKind: classifyFailure(failureTail(run, 300), "agent"), detail: `${agentSpec(agent).bin} exited ${run.code}: ${failureTail(run, 200)}` };
       agentNote = run.stdout.trim().split("\n").filter((l) => l.trim()).slice(-3).join(" ").slice(0, 300) || "the agent resolved the conflicts";
       if ((await mergeHead()).code !== 0) return { result: "refused", detail: "the merge is no longer in progress (the agent committed, aborted or reset it)" };
       if (await git(wt, ["rev-parse", "HEAD"]) !== t.headSha) return { result: "refused", detail: "HEAD moved during the agent run" };
@@ -1643,7 +1782,7 @@ async function runFreshEyesClaim(t, opts) {
 
 // src/worker/cursor-login.ts
 import { spawn as spawn3 } from "child_process";
-import { stripVTControlCharacters as stripVTControlCharacters2 } from "util";
+import { stripVTControlCharacters as stripVTControlCharacters3 } from "util";
 
 // src/radar/secret-patterns.ts
 var SECRET_PATTERNS = [
@@ -1759,7 +1898,7 @@ var POLL_MS = 5e3;
 var FINAL = /* @__PURE__ */ new Set(["signed_in", "wrong_account", "failed", "expired"]);
 var LINK_RE = /https:\/\/(?:www\.)?cursor\.com\/[A-Za-z0-9/._~%?&=:+-]+/;
 function findLoginLink(text) {
-  return stripVTControlCharacters2(text).match(LINK_RE)?.[0] ?? null;
+  return stripVTControlCharacters3(text).match(LINK_RE)?.[0] ?? null;
 }
 function spawnCursorLogin() {
   const child = spawn3("cursor-agent", ["login"], { env: { ...process.env, NO_OPEN_BROWSER: "1" }, stdio: ["ignore", "pipe", "pipe"] });
@@ -1804,7 +1943,7 @@ var realDeps = () => ({
   sleep: (ms) => new Promise((r) => setTimeout(r, ms))
 });
 function signedInAccount(p) {
-  const out = stripVTControlCharacters2(`${p.stdout}
+  const out = stripVTControlCharacters3(`${p.stdout}
 ${p.stderr}`);
   return out.match(/\b(?:logged|signed)\s+in\s+as\s+([^\s]+@[^\s]+)/i)?.[1]?.replace(/[.,;)]+$/, "").toLowerCase() ?? null;
 }
@@ -1873,7 +2012,7 @@ function createCursorLogin(partial) {
       d.log(`worker: Cursor signed in as ${who ? maskEmail(who) : "another account"}, not ${maskEmail(account)}; lanes take nothing.`);
       return set("wrong_account", { detail: `Signed in as ${who ? maskEmail(who) : "another account"}, not ${maskEmail(account)}. Start again and approve with the right account.` });
     }
-    const said = stripVTControlCharacters2(`${st.stdout}
+    const said = stripVTControlCharacters3(`${st.stdout}
 ${st.stderr}`).trim().split("\n")[0] ?? "";
     return set("failed", { detail: `After the sign-in, cursor-agent status did not confirm an account${said ? `: "${said.slice(0, 120)}"` : ""}.` });
   }
@@ -2082,6 +2221,7 @@ function validateWorkerConfig(raw) {
   if (c.version !== 1) fail("version must be 1");
   if (c.endpoint !== void 0 && (typeof c.endpoint !== "string" || !/^https?:\/\//.test(c.endpoint))) fail("endpoint must be an http(s) URL");
   if (c.cursorAccount !== void 0 && (typeof c.cursorAccount !== "string" || !/^[^\s@]{1,100}@[^\s@]{1,100}$/.test(c.cursorAccount))) fail("cursorAccount must be the account's email address");
+  if (c.agent !== void 0 && (typeof c.agent !== "string" || !LOCAL_AGENTS.includes(c.agent))) fail(`agent must be one of ${LOCAL_AGENTS.join(", ")}`);
   if (!Array.isArray(c.lanes) || c.lanes.length === 0) fail("list at least one lane");
   if (c.lanes.length > 20) fail("at most 20 lanes");
   const names = /* @__PURE__ */ new Set();
@@ -2110,6 +2250,7 @@ function validateWorkerConfig(raw) {
     version: 1,
     ...typeof c.endpoint === "string" ? { endpoint: c.endpoint } : {},
     ...typeof c.cursorAccount === "string" ? { cursorAccount: c.cursorAccount } : {},
+    ...typeof c.agent === "string" ? { agent: c.agent } : {},
     lanes
   };
 }
@@ -2130,7 +2271,7 @@ var IDLE_MS = 15 * 6e4;
 var BACKOFF_MS = 2 * 6e4;
 var INFRA_BACKOFF_MS = 6e4;
 var INFRA_BACKOFF_MAX_MS = 30 * 6e4;
-var AGENT_UNAVAILABLE = /ActionRequiredError|Increase limits|usage limit|out of (?:usage|credits)|Cannot use this model/i;
+var AGENT_UNAVAILABLE_WAIT_MS = 30 * 6e4;
 var GH_CHECK_MS = 5 * 6e4;
 var CURSOR_CHECK_MS = 20 * 6e4;
 function infraBackoffMs(streak) {
@@ -2139,6 +2280,10 @@ function infraBackoffMs(streak) {
 function machineFailed(result, failureKind, detail) {
   return result === "failed" && failureKind === "infra" || AGENT_UNAVAILABLE.test(detail);
 }
+function modelFor(agent, model) {
+  if (!model) return void 0;
+  return agent === "claude" && !isClaudeModel(model) ? void 0 : model;
+}
 var KEY_REFUSALS_TO_STOP = 3;
 function createDaemon(cfg, deps) {
   const lanes = cfg.lanes.map((local) => ({
@@ -2165,6 +2310,12 @@ function createDaemon(cfg, deps) {
   let lastReadings = null;
   let stopped = null;
   let account = deps.cursorAccount;
+  const agent = deps.agent ?? "cursor";
+  const model = (m) => {
+    const use = modelFor(agent, m);
+    if (m && !use) once(`model:${m}`, null, `the lane model ${m} is not a ${agentSpec(agent).label} model; using ${agentSpec(agent).label}'s default`);
+    return use;
+  };
   const reported = /* @__PURE__ */ new Set();
   const pending = /* @__PURE__ */ new Set();
   const agents = () => lanes.reduce((n, l) => n + l.running.size + (l.followup ? 1 : 0), 0);
@@ -2246,7 +2397,15 @@ function createDaemon(cfg, deps) {
       claims: lanes.flatMap((l) => [...l.running.keys()])
     };
   }
-  function afterRun(lane, failedOnMachine) {
+  function afterRun(lane, failedOnMachine, agentDown = false) {
+    if (agentDown) {
+      const until = deps.now() + AGENT_UNAVAILABLE_WAIT_MS;
+      for (const l of lanes) {
+        l.nextClaimAt = Math.max(l.nextClaimAt, until);
+        l.nextFollowupAt = Math.max(l.nextFollowupAt, until);
+      }
+      say(lane, `  the ${agentSpec(agent).label} agent could not run (out of usage or signed out): no lane claims for ${AGENT_UNAVAILABLE_WAIT_MS / 6e4} min`);
+    }
     if (!failedOnMachine) {
       lane.infraStreak = 0;
       return;
@@ -2262,8 +2421,8 @@ function createDaemon(cfg, deps) {
     lane.running.set(claim.id, ac);
     lane.state = "working";
     const t0 = deps.now();
-    const model = claim.model ?? lane.config?.model ?? void 0;
-    const track = newRun(claim.id, "fix", { reportId: claim.report.id, model, now: t0, stage: "prepare" });
+    const runModel = model(claim.model ?? lane.config?.model);
+    const track = newRun(claim.id, "fix", { reportId: claim.report.id, model: runModel, now: t0, stage: "prepare" });
     lane.tracks.set(claim.id, track);
     say(lane, `claimed ${claim.report.id.slice(0, 8)}: ${(claim.report.summary ?? "").slice(0, 80)}`);
     const run = (async () => {
@@ -2271,8 +2430,8 @@ function createDaemon(cfg, deps) {
       try {
         out = await deps.workOne(api, claim.report, {
           repoDir: lane.local.repoDir,
-          agent: "cursor",
-          model,
+          agent,
+          model: runModel,
           log: (l) => {
             pushLog(track, l);
             say(lane, l.trim());
@@ -2292,7 +2451,7 @@ function createDaemon(cfg, deps) {
       if (out.result === "failed") lane.counters.errors++;
       lane.last = `${claim.report.id.slice(0, 8)} \u2192 ${out.outcome}`.slice(0, 160);
       say(lane, `  \u2192 ${out.outcome}${out.prUrl ? ` ${out.prUrl}` : ""}`);
-      afterRun(lane, machineFailed(out.result, out.failureKind, out.outcome));
+      afterRun(lane, machineFailed(out.result, out.failureKind, out.outcome), out.agentUnavailable === true);
       const done = await deps.call(`/v1/worker/claims/${claim.id}/done`, {
         method: "POST",
         body: JSON.stringify({
@@ -2339,7 +2498,7 @@ function createDaemon(cfg, deps) {
       if (out.result === "failed") lane.counters.errors++;
       lane.last = `${out.result}: ${out.detail}`.slice(0, 160);
       say(lane, `  \u2192 ${out.result}: ${out.detail}`);
-      afterRun(lane, machineFailed(out.result, out.failureKind, out.detail));
+      afterRun(lane, machineFailed(out.result, out.failureKind, out.detail), out.result === "failed" && AGENT_UNAVAILABLE.test(out.detail));
       const done = await deps.call(`/v1/worker/claims/${claimId}/done`, {
         method: "POST",
         body: JSON.stringify({
@@ -2373,8 +2532,8 @@ function createDaemon(cfg, deps) {
     say(lane, `follow-up ${f.prUrl ?? f.fixId}`);
     const run = deps.followUpOne(api, f, {
       repoDir: lane.local.repoDir,
-      agent: "cursor",
-      model: lane.config?.model ?? void 0,
+      agent,
+      model: model(lane.config?.model),
       log: (l) => {
         pushLog(track, l);
         say(lane, l.trim());
@@ -2386,6 +2545,7 @@ function createDaemon(cfg, deps) {
       if (/^failed/.test(r.outcome)) lane.counters.errors++;
       lane.last = `follow-up \u2192 ${r.outcome}`.slice(0, 160);
       say(lane, `  \u2192 ${r.outcome}`);
+      if (r.agentUnavailable) afterRun(lane, true, true);
     }).catch((err) => {
       lane.counters.errors++;
       say(lane, `  follow-up error: ${err instanceof Error ? err.message : String(err)}`);
@@ -2467,7 +2627,7 @@ function createDaemon(cfg, deps) {
         return;
       }
       const k = parsed.value;
-      const model = k.model ?? lane.config?.model ?? void 0;
+      const jobModel = model(k.model ?? lane.config?.model);
       if (k.kind === "fix" && (c.mode === "fix" || c.mode === "skill")) {
         startRun(lane, k.raw);
       } else if (k.kind === "conflict" && c.mode === "conflicts") {
@@ -2477,7 +2637,7 @@ function createDaemon(cfg, deps) {
           k.id,
           "conflict",
           `conflict ${t.repo}#${t.prNumber} (${t.headRef} at ${t.headSha.slice(0, 7)})`,
-          (signal, log) => (deps.resolveConflict ?? resolveConflict)(t, { repoDir: lane.local.repoDir, model, log, signal })
+          (signal, log) => (deps.resolveConflict ?? resolveConflict)(t, { repoDir: lane.local.repoDir, agent, model: jobModel, log, signal })
         );
       } else if (k.kind === "audit" && c.mode === "audit") {
         startJob(
@@ -2485,7 +2645,7 @@ function createDaemon(cfg, deps) {
           k.id,
           "audit",
           `audit pass (${k.audit.findingsLeft} finding(s) left this hour)`,
-          (signal, log) => (deps.auditPass ?? auditPass)(api, k.id, { repoDir: lane.local.repoDir, laneName: lane.local.name, model, reviewModel: k.audit.reviewModel, log, signal })
+          (signal, log) => (deps.auditPass ?? auditPass)(api, k.id, { repoDir: lane.local.repoDir, laneName: lane.local.name, agent, model: jobModel, reviewModel: model(k.audit.reviewModel) ?? null, log, signal })
         );
       } else if (k.kind === "fresh_eyes" && deps.freshEyes) {
         const run = deps.freshEyes;
@@ -2706,6 +2866,8 @@ function createHostReadings(o) {
 }
 async function runDaemon(opts = {}) {
   const cfg = loadWorkerConfig(opts.configPath);
+  const agent = opts.agent ?? cfg.agent ?? "cursor";
+  const cursorAccount = agent === "cursor" ? cfg.cursorAccount : void 0;
   const cli = loadConfig();
   const key = readWorkerKey(cli.apiKey);
   const endpoint = cfg.endpoint ?? process.env["MUSHI_API_ENDPOINT"] ?? cli.endpoint;
@@ -2731,8 +2893,14 @@ async function runDaemon(opts = {}) {
   }
   const conf = { apiKey: key, endpoint };
   let wake = () => void 0;
-  const readings = createHostReadings({ cursorAccount: cfg.cursorAccount, now: () => Date.now(), log: (l) => process.stdout.write(`${l}
-`) });
+  const readings = createHostReadings({
+    ...cursorAccount ? { cursorAccount } : {},
+    // The account slot of the readings (and the heartbeat's `cursor` field) holds whichever agent runs.
+    ...agent === "cursor" ? {} : { checkCursor: () => checkAgentSignIn(agent) },
+    now: () => Date.now(),
+    log: (l) => process.stdout.write(`${l}
+`)
+  });
   const live = { agents: () => 0 };
   const cursorLogin = createCursorLogin({
     now: () => Date.now(),
@@ -2751,9 +2919,9 @@ async function runDaemon(opts = {}) {
     readings: () => readings.read(),
     recheck: () => readings.recheck(),
     notReady,
-    ...cfg.cursorAccount ? { cursorAccount: cfg.cursorAccount } : {},
-    setCursorAccount: (a) => readings.setAccount(a),
-    cursorLogin,
+    ...cursorAccount ? { cursorAccount } : {},
+    agent,
+    ...agent === "cursor" ? { setCursorAccount: (a) => readings.setAccount(a), cursorLogin } : {},
     now: () => Date.now(),
     log: (l) => process.stdout.write(`${l}
 `),
@@ -2764,7 +2932,7 @@ async function runDaemon(opts = {}) {
   });
   live.agents = daemon.agents;
   onInterrupt((signal) => daemon.shutdown(signal));
-  process.stdout.write(`mushi worker: ${cfg.lanes.length} lane(s) on ${platform}; heartbeat every ${HEARTBEAT_MS / 1e3} s. Stop with Ctrl-C or systemctl --user stop mushi-worker.
+  process.stdout.write(`mushi worker: ${cfg.lanes.length} lane(s) on ${platform}, agent ${agentSpec(agent).label} (${agentSpec(agent).bin}); heartbeat every ${HEARTBEAT_MS / 1e3} s. Stop with Ctrl-C or systemctl --user stop mushi-worker.
 `);
   while (!daemon.stopped) {
     await daemon.tick().catch((err) => process.stdout.write(`worker: tick failed: ${err instanceof Error ? err.message : String(err)}
@@ -2794,6 +2962,7 @@ export {
   hashHostId,
   UnsupportedHostError,
   collectHeartbeat,
+  parseLocalAgent,
   MODEL_RE,
   LANE_NAME_RE,
   WORKER_CONFIG_PATH,
@@ -2802,6 +2971,7 @@ export {
   loadWorkerConfig,
   infraBackoffMs,
   machineFailed,
+  modelFor,
   createDaemon,
   workerHostId,
   readWorkerKey,

package/dist/{chunk-B5USMAHY.js → chunk-GLA6OXI3.js}

@@ -9,10 +9,10 @@ import {
   requireUuid,
   saveConfig,
   savedSdkKeyFor
-} from "./chunk-PAL6GBXT.js";
+} from "./chunk-TFNFJXCK.js";
 import {
   MUSHI_MCP_PIN_SPEC
-} from "./chunk-SC376RQS.js";
+} from "./chunk-R4ZRRD4B.js";
 import {
   assertEndpoint,
   normalizeEndpoint

package/dist/{chunk-KGZXODOG.js → chunk-MRQEXRAP.js}

@@ -1,6 +1,6 @@
 import {
   MUSHI_CLI_VERSION
-} from "./chunk-XNC2T2WO.js";
+} from "./chunk-5DQLHMVZ.js";
 import {
   assertEndpoint,
   normalizeEndpoint

package/dist/chunk-R4ZRRD4B.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+
+// src/version.ts
+var MUSHI_CLI_VERSION = true ? "0.36.1" : "0.0.0-dev";
+var MUSHI_MCP_PIN_SPEC = "@mushi-mushi/mcp@0.30.7";
+
+export {
+  MUSHI_CLI_VERSION,
+  MUSHI_MCP_PIN_SPEC
+};

package/dist/{chunk-PAL6GBXT.js → chunk-TFNFJXCK.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   MUSHI_CLI_VERSION
-} from "./chunk-SC376RQS.js";
+} from "./chunk-R4ZRRD4B.js";
 import {
   CLOUD_API_ENDPOINT,
   normalizeEndpoint
@@ -771,6 +771,7 @@ export {
   getAbortSignal,
   isKeychainEnabled,
   trySaveKeyToKeychain,
+  tryLoadKeyFromKeychain,
   syncKeychainAfterKeyChange,
   trySaveWorkerKey,
   tryLoadWorkerKey,

package/dist/{connect-NZ2RNS7F.js → connect-PJ2KR2FI.js}

@@ -2,10 +2,10 @@
 import {
   resolveSdkEnvKey,
   runConnect
-} from "./chunk-B5USMAHY.js";
+} from "./chunk-GLA6OXI3.js";
 import "./chunk-KOBEOGNF.js";
-import "./chunk-PAL6GBXT.js";
-import "./chunk-SC376RQS.js";
+import "./chunk-TFNFJXCK.js";
+import "./chunk-R4ZRRD4B.js";
 import "./chunk-LGGE3LH7.js";
 export {
   resolveSdkEnvKey,

package/dist/{connect-MOD2FT6S.js → connect-X5OPJFCR.js}

@@ -6,10 +6,10 @@ import {
   saveConfig,
   savedSdkKeyFor,
   waitForIngestReady
-} from "./chunk-KGZXODOG.js";
+} from "./chunk-MRQEXRAP.js";
 import {
   MUSHI_MCP_PIN_SPEC
-} from "./chunk-XNC2T2WO.js";
+} from "./chunk-5DQLHMVZ.js";
 import {
   detectFramework,
   envVarsToWrite,

package/dist/{daemon-FN3VM4R6.js → daemon-VC4WW5GU.js}

@@ -6,12 +6,13 @@ import {
   cursorStateFor,
   infraBackoffMs,
   machineFailed,
+  modelFor,
   readWorkerKey,
   runDaemon,
   workerHostId
-} from "./chunk-YAVF3ZUN.js";
-import "./chunk-PAL6GBXT.js";
-import "./chunk-SC376RQS.js";
+} from "./chunk-D3ABBB6H.js";
+import "./chunk-TFNFJXCK.js";
+import "./chunk-R4ZRRD4B.js";
 import "./chunk-LGGE3LH7.js";
 export {
   assertWorkerKey,
@@ -20,6 +21,7 @@ export {
   cursorStateFor,
   infraBackoffMs,
   machineFailed,
+  modelFor,
   readWorkerKey,
   runDaemon,
   workerHostId

package/dist/index.js

@@ -22,7 +22,7 @@ import {
   sanitizeEndpoint,
   sanitizeProjectId,
   writeMcpServerEntry
-} from "./chunk-B5USMAHY.js";
+} from "./chunk-GLA6OXI3.js";
 import {
   FRAMEWORKS,
   detectFramework,
@@ -44,12 +44,13 @@ import {
   hashHostId,
   loadWorkerConfig,
   nodeHostIO,
+  parseLocalAgent,
   readMachineId,
   readWorkerKey,
   registerUxCommands,
   registerWorkCommands,
   validateWorkerConfig
-} from "./chunk-YAVF3ZUN.js";
+} from "./chunk-D3ABBB6H.js";
 import {
   CONFIG_PATH,
   MushiCliError,
@@ -85,13 +86,14 @@ import {
   setGlobalOutputFormat,
   syncKeychainAfterKeyChange,
   tryDeleteWorkerKey,
+  tryLoadKeyFromKeychain,
   trySaveKeyToKeychain,
   trySaveWorkerKey
-} from "./chunk-PAL6GBXT.js";
+} from "./chunk-TFNFJXCK.js";
 import {
   MUSHI_CLI_VERSION,
   MUSHI_MCP_PIN_SPEC
-} from "./chunk-SC376RQS.js";
+} from "./chunk-R4ZRRD4B.js";
 import {
   CLOUD_API_ENDPOINT,
   CLOUD_MCP_OAUTH_URL,
@@ -426,6 +428,17 @@ function printAuthFailed(reason, detail) {
   console.log("");
 }
 
+// src/env-key-override.ts
+function envKeyOverrideLines(env, savedKey, platform = process.platform) {
+  const envKey = env.MUSHI_API_KEY?.trim();
+  if (!envKey || savedKey && envKey === savedKey) return [];
+  const where = platform === "win32" ? 'Remove it under Windows Settings \u2192 System \u2192 About \u2192 Advanced system settings \u2192 Environment Variables, or open a new terminal after `[Environment]::SetEnvironmentVariable("MUSHI_API_KEY", $null, "User")` in PowerShell.' : "Remove the `export MUSHI_API_KEY=\u2026` line from your shell profile, or run `unset MUSHI_API_KEY` in this terminal.";
+  return [
+    `\u26A0 MUSHI_API_KEY is set in your environment (${envKey.slice(0, 12)}\u2026), and it overrides ${savedKey ? `the saved key (${savedKey.slice(0, 12)}\u2026)` : "the saved key"}.`,
+    `  Commands in this terminal use the environment key. ${where}`
+  ];
+}
+
 // src/login.ts
 function getPostLoginBannerMessage(opts) {
   if (opts.suppressPostLoginBanner) return null;
@@ -673,8 +686,10 @@ error: Could not create project: ${err instanceof Error ? err.message : String(e
     if (opts.upgradeScope) {
       console.log(`  \u2713 Full-scope CLI key saved (${apiKey.slice(0, 12)}\u2026)`);
       console.log(`    Scopes: report:write \xB7 mcp:read \xB7 mcp:write \u2014 SDK + MCP + admin CLI (incl. writes) all work with this key`);
+      for (const line of envKeyOverrideLines(process.env, apiKey)) console.log(`  ${line}`);
     } else {
       console.log(`  \u2713 CLI key saved (${apiKey.slice(0, 12)}\u2026)`);
+      for (const line of envKeyOverrideLines(process.env, apiKey)) console.log(`  ${line}`);
       console.log(`    Scopes: report:write \xB7 mcp:read \u2014 SDK ingest + MCP read tools.`);
       console.log(`    Admin writes (mushi work, fix merge, billing cap, pipeline start) need: mushi login --upgrade-scope${chosenProjectId ? ` --project-id ${chosenProjectId}` : ""}`);
     }
@@ -1594,7 +1609,7 @@ async function checkOnboardingStatus(config, _consoleBase, cwd, doFetch = global
 }
 async function checkVersionDrift(cwd, doFetch) {
   const checks = [];
-  const { MUSHI_CLI_VERSION: MUSHI_CLI_VERSION2 } = await import("./version-X5ZV5IMP.js");
+  const { MUSHI_CLI_VERSION: MUSHI_CLI_VERSION2 } = await import("./version-5GNUKBUB.js");
   if (MUSHI_CLI_VERSION2 === "0.0.0-dev") return checks;
   const parse2 = (v) => {
     const m = v.replace(/^[~^]/, "").match(/^(\d+)\.(\d+)\.(\d+)/);
@@ -2567,7 +2582,7 @@ async function maybeOfferConnect(credentials, options, _consoleBase) {
   if (p.isCancel(answer) || !answer) return;
   const endpoint = resolveCloudEndpoint(options.endpoint);
   try {
-    const { runConnect: runConnect2 } = await import("./connect-NZ2RNS7F.js");
+    const { runConnect: runConnect2 } = await import("./connect-PJ2KR2FI.js");
     const saved = loadConfig();
     const result = await runConnect2(
       {
@@ -2631,6 +2646,8 @@ async function maybeSendTestReport(credentials, options) {
         projectId: credentials.projectId,
         description: "Test report from the mushi-mushi setup wizard",
         category: "other",
+        // Never the project's first real report or its activation (first-report.ts).
+        metadata: { source: "cli_wizard" },
         reporterToken: `wizard-${randomUUID()}`,
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
         environment: {
@@ -2912,6 +2929,7 @@ Useful after 'mushi login' to confirm credentials are correct.`).action(async (o
           console.log("    Mint one on the console MCP page, or run `mushi login`.");
         }
       }
+      for (const line of envKeyOverrideLines(process.env, tryLoadKeyFromKeychain() ?? void 0)) console.log(`  ${line}`);
     }
   });
   program2.command("ping").description("Check connectivity to the Mushi backend").option("--json", "Machine-readable JSON output").action(async (opts) => {
@@ -13521,7 +13539,7 @@ function printLanes(cfg) {
 }
 function registerWorkerCommands(program2) {
   const worker = program2.command("worker").description("Set up and read the local worker (`mushi work --daemon`): lanes, key and service");
-  worker.command("install").description("Write the lanes file, store a worker key (worker:run) and the service that runs `mushi work --daemon`; prints everything and asks first").option("--lanes-conf <path>", "Import lane-v4's lanes.conf (name profile clone projectId model mode)").option("--clone-root <dir>", "With --lanes-conf: the folder that holds the clones", join12(homedir(), ".cache", "mushi-work")).option("--lane <name>", "One lane: its name").option("--project <id>", "One lane: its app id").option("--repo-dir <path>", "One lane: the clone it works in").option("--model <id>", "One lane: its model when it first registers (the console can change it)").option("--stop-at <time>", "Every lane stops taking reports at this time when it first registers (ISO, e.g. 2026-10-31T14:59:00Z); change it in the console later").option("--cursor-account <email>", "Spend only this Cursor account: a CLI signed in as anyone else counts as signed out").option("--endpoint <url>", "API endpoint (default: the CLI login's)").option("--key-stdin", "Read a worker key made in the console (Workers tab) from stdin instead of creating one").option("--no-service", "Write the lanes file and key only").option("--yes", "Do not ask before writing").option("--dry-run", "Print what would be written; write nothing").action(async (opts) => {
+  worker.command("install").description("Write the lanes file, store a worker key (worker:run) and the service that runs `mushi work --daemon`; prints everything and asks first").option("--lanes-conf <path>", "Import lane-v4's lanes.conf (name profile clone projectId model mode)").option("--clone-root <dir>", "With --lanes-conf: the folder that holds the clones", join12(homedir(), ".cache", "mushi-work")).option("--lane <name>", "One lane: its name").option("--project <id>", "One lane: its app id").option("--repo-dir <path>", "One lane: the clone it works in").option("--model <id>", "One lane: its model when it first registers (the console can change it)").option("--stop-at <time>", "Every lane stops taking reports at this time when it first registers (ISO, e.g. 2026-10-31T14:59:00Z); change it in the console later").option("--cursor-account <email>", "Spend only this Cursor account: a CLI signed in as anyone else counts as signed out").option("--agent <name>", "The coding agent every lane runs: cursor (default) or claude (Claude Code, signed in with claude auth login)").option("--endpoint <url>", "API endpoint (default: the CLI login's)").option("--key-stdin", "Read a worker key made in the console (Workers tab) from stdin instead of creating one").option("--no-service", "Write the lanes file and key only").option("--yes", "Do not ask before writing").option("--dry-run", "Print what would be written; write nothing").action(async (opts) => {
     const cli = loadConfig();
     const endpoint = opts.endpoint ?? process.env["MUSHI_API_ENDPOINT"] ?? cli.endpoint;
     let stopAt = null;
@@ -13531,7 +13549,8 @@ function registerWorkerCommands(program2) {
       stopAt = new Date(t).toISOString();
     }
     const lanes = lanesFromOptions(opts).map((l) => stopAt ? { ...l, initial: { ...l.initial, stop_at: stopAt } } : l);
-    const cfg = validateWorkerConfig({ version: 1, ...endpoint ? { endpoint } : {}, ...opts.cursorAccount ? { cursorAccount: opts.cursorAccount } : {}, lanes });
+    const agent = opts.agent === void 0 ? void 0 : parseLocalAgent(opts.agent);
+    const cfg = validateWorkerConfig({ version: 1, ...endpoint ? { endpoint } : {}, ...opts.cursorAccount ? { cursorAccount: opts.cursorAccount } : {}, ...agent ? { agent } : {}, lanes });
     const projectIds = [...new Set(cfg.lanes.map((l) => l.projectId))];
     const node = process.execPath;
     const cli0 = cliPath();
@@ -13539,7 +13558,8 @@ function registerWorkerCommands(program2) {
     const service = !opts.service ? null : platform === "win32" ? { kind: "task", args: windowsTaskArgs({ node, cli: cli0 }) } : platform === "linux" ? { kind: "systemd", unit: systemdUnit({ node, cli: cli0, path: process.env["PATH"] ?? "/usr/local/bin:/usr/bin:/bin" }) } : null;
     console.log(`Lanes (${WORKER_CONFIG_PATH}):`);
     printLanes(cfg);
-    if (cfg.cursorAccount) console.log(`Cursor: spends only ${cfg.cursorAccount}; signed in as anyone else, the worker waits.`);
+    if (cfg.agent === "claude") console.log("Agent: Claude Code (claude -p) on the plan it is signed in to; lane models that are not Claude ids are not used.");
+    if (cfg.cursorAccount && cfg.agent !== "claude") console.log(`Cursor: spends only ${cfg.cursorAccount}; signed in as anyone else, the worker waits.`);
     const keySource = process.env["MUSHI_WORKER_KEY"] ? "MUSHI_WORKER_KEY" : opts.keyStdin ? "stdin" : `a new worker key for ${projectIds.length} app(s), made with your CLI login`;
     console.log(`
 Key: ${keySource}; stored in ${isKeychainEnabled() ? "the OS keychain" : `${WORKER_KEY_PATH} (mode 0600; no keychain here)`}. It can only take reports and record their fixes.`);

package/dist/init.js

@@ -25,10 +25,10 @@ import {
   saveConfig,
   savedSdkKeyFor,
   trySaveKeyToKeychain
-} from "./chunk-KGZXODOG.js";
+} from "./chunk-MRQEXRAP.js";
 import {
   MUSHI_CLI_VERSION
-} from "./chunk-XNC2T2WO.js";
+} from "./chunk-5DQLHMVZ.js";
 import {
   FRAMEWORKS,
   detectFramework,
@@ -2127,7 +2127,7 @@ async function maybeOfferConnect(credentials, options, _consoleBase) {
   if (p.isCancel(answer) || !answer) return;
   const endpoint = resolveCloudEndpoint(options.endpoint);
   try {
-    const { runConnect } = await import("./connect-MOD2FT6S.js");
+    const { runConnect } = await import("./connect-X5OPJFCR.js");
     const saved = loadConfig();
     const result = await runConnect(
       {
@@ -2191,6 +2191,8 @@ async function maybeSendTestReport(credentials, options) {
         projectId: credentials.projectId,
         description: "Test report from the mushi-mushi setup wizard",
         category: "other",
+        // Never the project's first real report or its activation (first-report.ts).
+        metadata: { source: "cli_wizard" },
         reporterToken: `wizard-${randomUUID()}`,
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
         environment: {

package/dist/{version-X5ZV5IMP.js → version-5GNUKBUB.js}

@@ -2,7 +2,7 @@
 import {
   MUSHI_CLI_VERSION,
   MUSHI_MCP_PIN_SPEC
-} from "./chunk-SC376RQS.js";
+} from "./chunk-R4ZRRD4B.js";
 export {
   MUSHI_CLI_VERSION,
   MUSHI_MCP_PIN_SPEC

package/dist/version.d.ts

@@ -14,6 +14,6 @@ declare const MUSHI_CLI_VERSION: string;
  * setup refreshes the pin. Synced to packages/mcp/package.json by
  * `scripts/sync-mcp-pin.mjs` — never hand-edit the version.
  */
-declare const MUSHI_MCP_PIN_SPEC = "@mushi-mushi/mcp@0.30.4";
+declare const MUSHI_MCP_PIN_SPEC = "@mushi-mushi/mcp@0.30.7";
 
 export { MUSHI_CLI_VERSION, MUSHI_MCP_PIN_SPEC };

package/dist/version.js

@@ -1,7 +1,7 @@
 import {
   MUSHI_CLI_VERSION,
   MUSHI_MCP_PIN_SPEC
-} from "./chunk-XNC2T2WO.js";
+} from "./chunk-5DQLHMVZ.js";
 export {
   MUSHI_CLI_VERSION,
   MUSHI_MCP_PIN_SPEC

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@mushi-mushi/cli",
-  "version": "0.35.7",
+  "version": "0.36.1",
   "license": "MIT",
-  "description": "Mushi Mushi CLI: SDK setup, MCP wiring, triage. The bug mediator for AI-built apps: plain-English diagnosis + a ready fix, in your editor.",
+  "description": "Mushi Mushi CLI: SDK setup, MCP wiring, triage. Bug fixing for AI-built apps: plain-English diagnosis + a ready fix, in your editor.",
   "bin": {
     "mushi": "./dist/index.js"
   },

package/dist/chunk-SC376RQS.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-
-// src/version.ts
-var MUSHI_CLI_VERSION = true ? "0.35.7" : "0.0.0-dev";
-var MUSHI_MCP_PIN_SPEC = "@mushi-mushi/mcp@0.30.4";
-
-export {
-  MUSHI_CLI_VERSION,
-  MUSHI_MCP_PIN_SPEC
-};

package/dist/chunk-XNC2T2WO.js

@@ -1,8 +0,0 @@
-// src/version.ts
-var MUSHI_CLI_VERSION = true ? "0.35.7" : "0.0.0-dev";
-var MUSHI_MCP_PIN_SPEC = "@mushi-mushi/mcp@0.30.4";
-
-export {
-  MUSHI_CLI_VERSION,
-  MUSHI_MCP_PIN_SPEC
-};