agent-yes 1.287.0 → 1.288.0

package/ts/autoRetry.bun.spec.ts

@@ -0,0 +1,123 @@
+import { describe, expect, it } from "bun:test";
+import {
+  AUTO_RETRY_MAX_DELAY_SECS,
+  AUTO_RETRY_REASON_FALLBACK,
+  AUTO_RETRY_REASONS,
+  autoRetryBackoffMs,
+  buildAutoRetryMessage,
+  classifyAutoRetryReason,
+  formatDurationSecs,
+  shouldFireRetry,
+} from "./autoRetry.ts";
+import { loadSharedCliDefaults } from "./configShared.ts";
+
+describe("autoRetryBackoffMs", () => {
+  it("doubles 8,16,32,…,256 then caps", () => {
+    expect(autoRetryBackoffMs(0)).toBe(8_000);
+    expect(autoRetryBackoffMs(1)).toBe(16_000);
+    expect(autoRetryBackoffMs(2)).toBe(32_000);
+    expect(autoRetryBackoffMs(3)).toBe(64_000);
+    expect(autoRetryBackoffMs(4)).toBe(128_000);
+    expect(autoRetryBackoffMs(5)).toBe(256_000);
+  });
+
+  it("caps at the max delay and never overflows for large streaks", () => {
+    expect(autoRetryBackoffMs(6)).toBe(AUTO_RETRY_MAX_DELAY_SECS * 1000);
+    expect(autoRetryBackoffMs(50)).toBe(AUTO_RETRY_MAX_DELAY_SECS * 1000);
+    expect(Number.isFinite(autoRetryBackoffMs(1000))).toBe(true);
+  });
+});
+
+describe("shouldFireRetry", () => {
+  it("requires ready + not working + past the idle window", () => {
+    // Busy — never fire even if otherwise ready and quiet.
+    expect(shouldFireRetry(true, true, 10_000, 5_000)).toBe(false);
+    // Not at a recognized ready prompt — don't fire.
+    expect(shouldFireRetry(false, false, 10_000, 5_000)).toBe(false);
+    // Ready and idle, but the quiet window hasn't elapsed yet (user may still
+    // be mid-typing) — defer.
+    expect(shouldFireRetry(false, true, 4_999, 5_000)).toBe(false);
+    // Ready, idle, and past the quiet window — fire.
+    expect(shouldFireRetry(false, true, 5_000, 5_000)).toBe(true);
+    expect(shouldFireRetry(false, true, 10_000, 5_000)).toBe(true);
+  });
+});
+
+describe("classifyAutoRetryReason", () => {
+  it("maps real banners to inert paraphrases", () => {
+    expect(classifyAutoRetryReason("● API Error: 529 Overloaded")).toBe(AUTO_RETRY_REASONS[0]);
+    expect(classifyAutoRetryReason("API Error: Response stalled mid-stream.")).toBe(
+      AUTO_RETRY_REASONS[1],
+    );
+    expect(classifyAutoRetryReason("API Error: Connection closed mid-response.")).toBe(
+      AUTO_RETRY_REASONS[2],
+    );
+    expect(classifyAutoRetryReason("Claude usage limit reached")).toBe(AUTO_RETRY_REASONS[3]);
+    expect(classifyAutoRetryReason("You are being rate-limited")).toBe(AUTO_RETRY_REASONS[4]);
+    expect(classifyAutoRetryReason("API Error: 503 Service Unavailable")).toBe(
+      AUTO_RETRY_REASON_FALLBACK,
+    );
+  });
+});
+
+describe("formatDurationSecs", () => {
+  it("renders s / m / h forms", () => {
+    expect(formatDurationSecs(0)).toBe("0s");
+    expect(formatDurationSecs(45)).toBe("45s");
+    expect(formatDurationSecs(60)).toBe("1m");
+    expect(formatDurationSecs(200)).toBe("3m20s");
+    expect(formatDurationSecs(3600)).toBe("1h");
+    expect(formatDurationSecs(3900)).toBe("1h05m");
+    expect(formatDurationSecs(8 * 3600)).toBe("8h");
+  });
+});
+
+describe("buildAutoRetryMessage", () => {
+  it("is one line and carries attempt/reason/backoff context + ignore clause", () => {
+    const msg = buildAutoRetryMessage(3, AUTO_RETRY_REASONS[0], 45, 64);
+    expect(msg).not.toContain("\n");
+    expect(msg.startsWith("retry [")).toBe(true);
+    expect(msg).toContain("#3");
+    expect(msg).toContain("45s ago");
+    expect(msg).toContain("in 1m04s");
+    expect(msg).toContain("giving up after 8h");
+    expect(msg).toContain("ignore it");
+  });
+
+  // Self-trigger guard: the message is typed into the PTY and stays visible in
+  // the transcript, so if it ever matched a CLI's own screen-scrape patterns
+  // it would re-arm the retry loop (autoRetry), block the streak reset, kill
+  // the session (fatal), or fake a state (working/enter/needsInput). Mirrors
+  // rs/src/config.rs test_auto_retry_message_is_inert_against_all_cli_patterns.
+  it("never matches any CLI's screen-scrape patterns", async () => {
+    const clis = await loadSharedCliDefaults();
+    expect(Object.keys(clis).length).toBeGreaterThan(0);
+    for (const [cliName, conf] of Object.entries(clis)) {
+      for (const reason of AUTO_RETRY_REASONS) {
+        const cases: [number, number, number][] = [
+          [1, 0, 8],
+          [5, 500, 128],
+          [12, 30_000, 256],
+        ];
+        for (const [attempt, since, next] of cases) {
+          const msg = buildAutoRetryMessage(attempt, reason, since, next);
+          const groups: [string, RegExp[] | undefined][] = [
+            ["autoRetry", conf.autoRetry],
+            ["fatal", conf.fatal],
+            ["enter", conf.enter],
+            ["working", conf.working],
+            ["needsInput", conf.needsInput],
+          ];
+          for (const [kind, patterns] of groups) {
+            for (const rx of patterns ?? []) {
+              expect(
+                rx.test(msg),
+                `retry message must not match ${cliName}.${kind} /${rx}/: ${msg}`,
+              ).toBe(false);
+            }
+          }
+        }
+      }
+    }
+  });
+});

package/ts/badges.bun.spec.ts

@@ -0,0 +1,187 @@
+import { describe, expect, it } from "bun:test";
+import {
+  badgeDef,
+  badgeLabel,
+  BADGE_DEFS,
+  matchBadges,
+  TYPING_BADGE,
+  type BadgeDef,
+} from "./badges.ts";
+
+describe("matchBadges", () => {
+  it("matches goal-active when the /goal status line is on screen", () => {
+    const lines = ["some output", "/goal active (42s)", "more output"];
+    expect(matchBadges(lines)).toEqual(["goal-active"]);
+  });
+
+  it("is case-insensitive", () => {
+    expect(matchBadges(["/GOAL ACTIVE (1s)"])).toEqual(["goal-active"]);
+  });
+
+  it("returns empty when nothing matches", () => {
+    expect(matchBadges(["just some regular CLI output", "nothing special here"])).toEqual([]);
+  });
+
+  it("returns empty for an empty screen", () => {
+    expect(matchBadges([])).toEqual([]);
+  });
+
+  it("matches across a join boundary between lines (pattern spans the joined text)", () => {
+    // Sanity: matchBadges joins lines with \n before testing, so a pattern that
+    // doesn't care about line boundaries still finds a hit split across two lines.
+    const defs: BadgeDef[] = [{ id: "spans", label: "x", title: "t", pattern: /foo\nbar/ }];
+    expect(matchBadges(["foo", "bar"], defs)).toEqual(["spans"]);
+  });
+
+  it("supports custom def sets independent of the built-in BADGE_DEFS", () => {
+    const defs: BadgeDef[] = [
+      { id: "custom-error", label: "err", title: "custom error banner", pattern: /FATAL: boom/ },
+    ];
+    expect(matchBadges(["FATAL: boom"], defs)).toEqual(["custom-error"]);
+    expect(matchBadges(["FATAL: boom"])).toEqual([]); // not in the default set
+  });
+
+  it("can match multiple badges at once, in def order", () => {
+    const defs: BadgeDef[] = [
+      { id: "a", label: "a", title: "a", pattern: /alpha/ },
+      { id: "b", label: "b", title: "b", pattern: /beta/ },
+    ];
+    expect(matchBadges(["alpha and beta both here"], defs)).toEqual(["a", "b"]);
+  });
+
+  it("matches session-limit when claude's usage-limit banner is on screen", () => {
+    expect(matchBadges(["You've hit your session limit · resets 9:50pm (Asia/Tokyo)"])).toEqual([
+      "session-limit",
+    ]);
+  });
+
+  it("matches with or without the apostrophe (straight ', curly ’, or none)", () => {
+    expect(matchBadges(["You've hit your session limit"])).toEqual(["session-limit"]);
+    expect(matchBadges(["Youve hit your session limit"])).toEqual(["session-limit"]);
+  });
+
+  it("does not match an unrelated 'limit' mention", () => {
+    expect(matchBadges(["rate limit exceeded, please slow down"])).toEqual([]);
+  });
+
+  it("matches retrying on claude's self-retry backoff banner", () => {
+    expect(
+      matchBadges(["✻ Waiting for API response · will retry in 2m 17s · check your network"]),
+    ).toEqual(["retrying"]);
+  });
+
+  it("matches retrying across a line-wrapped banner (joined text)", () => {
+    expect(
+      matchBadges(["✻ Waiting for API response ·", "will retry in 45s · check your network"]),
+    ).toEqual(["retrying"]);
+  });
+
+  it("does not light retrying for a normal in-flight wait (no 'will retry')", () => {
+    expect(matchBadges(["✻ Waiting for API response… (esc to interrupt)"])).toEqual([]);
+  });
+
+  it("does not light retrying for an agent merely discussing retries (anchored to the banner)", () => {
+    expect(matchBadges(["the client will retry in 5 seconds with backoff"])).toEqual([]);
+  });
+});
+
+describe("dynamic footer counters", () => {
+  // Real footer lines captured from live agents (`ay tail`), singular and plural.
+  it("matches the shell counter and carries the footer text on the wire", () => {
+    expect(
+      matchBadges([
+        "  ⏸ manual mode on · 1 shell · ctrl+t to hide tasks · ← for agents · ↓ to manage",
+      ]),
+    ).toEqual(["shells:1 shell"]);
+    expect(matchBadges(["  ⏸ manual mode on · 4 shells · ↓ to manage"])).toEqual([
+      "shells:4 shells",
+    ]);
+  });
+
+  it("matches the monitor counter", () => {
+    expect(
+      matchBadges(["  ⏸ manual mode on · 3 monitors · esc to interrupt · ↓ to manage"]),
+    ).toEqual(["monitors:3 monitors"]);
+    expect(matchBadges(["  ⏸ manual mode on · 1 monitor · ↓ to manage"])).toEqual([
+      "monitors:1 monitor",
+    ]);
+  });
+
+  it("matches the background-agents counter (← N agents) at end of line", () => {
+    expect(matchBadges(["  ⏸ manual mode on · ? for shortcuts · ← 3 agents"])).toEqual([
+      "bg-agents:3 agents",
+    ]);
+  });
+
+  it("does not light bg-agents on the plain '← for agents' hint (no count)", () => {
+    expect(matchBadges(["  ⏸ manual mode on · ctrl+t to hide tasks · ← for agents"])).toEqual([]);
+  });
+
+  it("matches the PR chip", () => {
+    expect(matchBadges(["  ⏸ manual mode on · PR #310"])).toEqual(["pr:PR #310"]);
+    expect(matchBadges(["  ⏸ manual mode on · PR #229 · esc to interrupt"])).toEqual([
+      "pr:PR #229",
+    ]);
+  });
+
+  it("is anchored to footer chrome — prose mentions don't match", () => {
+    expect(
+      matchBadges([
+        "I opened 4 shells and 2 monitors while checking PR #310 today",
+        "there are 3 agents running",
+      ]),
+    ).toEqual([]);
+  });
+
+  it("can light several counters on one footer line", () => {
+    expect(
+      matchBadges(["  ⏸ manual mode on · 2 shells · 3 monitors · PR #12 · ← 5 agents"]),
+    ).toEqual(["shells:2 shells", "monitors:3 monitors", "bg-agents:5 agents", "pr:PR #12"]);
+  });
+});
+
+describe("badgeDef", () => {
+  it("looks up a built-in definition by id", () => {
+    expect(badgeDef("goal-active")).toBe(BADGE_DEFS[0]);
+  });
+
+  it("returns undefined for an unknown id", () => {
+    expect(badgeDef("does-not-exist")).toBeUndefined();
+  });
+
+  it("resolves a dynamic id by the part before the ':'", () => {
+    expect(badgeDef("shells:4 shells")?.id).toBe("shells");
+  });
+
+  it("resolves the time-derived typing badge even though it isn't in BADGE_DEFS", () => {
+    expect(badgeDef("typing")).toBe(TYPING_BADGE);
+    expect(BADGE_DEFS).not.toContain(TYPING_BADGE);
+  });
+});
+
+describe("badgeLabel", () => {
+  it("returns the static label for a plain id", () => {
+    expect(badgeLabel("goal-active")).toBe("goal");
+    expect(badgeLabel("typing")).toBe("typing");
+  });
+
+  it("substitutes the captured footer text into a dynamic label", () => {
+    expect(badgeLabel("shells:1 shell")).toBe("1 shell");
+    expect(badgeLabel("shells:4 shells")).toBe("4 shells");
+    expect(badgeLabel("pr:PR #310")).toBe("PR #310");
+  });
+
+  it("falls back to the raw id for an unknown badge", () => {
+    expect(badgeLabel("some-future-flag")).toBe("some-future-flag");
+  });
+});
+
+describe("TYPING_BADGE", () => {
+  it("is never produced by screen matching (its pattern can't match)", () => {
+    // Presence is derived from the stdin-activity marker, not the rendered
+    // screen — matchBadges must never surface it, even against text mentioning
+    // typing. A screen can't cause a false 'user is typing' chip.
+    expect(matchBadges(["the user is typing a lot right now", "typing typing typing"])).toEqual([]);
+    expect(TYPING_BADGE.pattern.test("typing")).toBe(false);
+  });
+});

package/ts/buildRustArgs.bun.spec.ts

@@ -0,0 +1,351 @@
+#!/usr/bin/env bun test
+import { describe, expect, it } from "bun:test";
+import { buildRustArgs } from "./buildRustArgs";
+
+const SUPPORTED_CLIS = [
+  "claude",
+  "glm",
+  "pi",
+  "codex",
+  "copilot",
+  "cursor",
+  "grok",
+  "qwen",
+  "auggie",
+  "amp",
+  "opencode",
+  "dsh",
+  "dsh-tui",
+  "dsh-legacy",
+];
+
+// Helper: simulate argv as [node, script, ...userArgs]
+function argv(...userArgs: string[]): string[] {
+  return ["node", "/path/to/claude-yes", ...userArgs];
+}
+
+describe("buildRustArgs", () => {
+  // ─── Core: CLI name passed via --cli= flag ─────────────────────────
+  // The CLI name is passed via --cli= flag at the start, so it doesn't
+  // get mixed with trailing positional args (which are prompt text).
+
+  describe("CLI name is passed via --cli= flag", () => {
+    it("prepends --cli= flag before other args", () => {
+      const result = buildRustArgs(argv("--timeout", "1h"), "claude", SUPPORTED_CLIS);
+      expect(result).toEqual(["--cli=claude", "--timeout", "1h"]);
+    });
+
+    it("prepends --cli= flag before multiple flags", () => {
+      const result = buildRustArgs(
+        argv("--timeout", "30s", "--verbose", "--robust", "true"),
+        "claude",
+        SUPPORTED_CLIS,
+      );
+      expect(result).toEqual(["--cli=claude", "--timeout", "30s", "--verbose", "--robust", "true"]);
+    });
+
+    it("--cli= is the first element", () => {
+      const result = buildRustArgs(argv("--timeout", "5m"), "codex", SUPPORTED_CLIS);
+      expect(result[0]).toBe("--cli=codex");
+    });
+  });
+
+  // ─── Regression: flags must not be swallowed ───────────────────────
+
+  describe("regression: flags are preserved alongside --cli=", () => {
+    it("--timeout is preserved", () => {
+      const result = buildRustArgs(argv("--timeout", "1h"), "claude", SUPPORTED_CLIS);
+      expect(result).toContain("--timeout");
+      expect(result).toContain("1h");
+    });
+
+    it("--verbose is preserved", () => {
+      const result = buildRustArgs(argv("--verbose"), "claude", SUPPORTED_CLIS);
+      expect(result).toContain("--verbose");
+    });
+
+    it("-c (continue) flag is preserved", () => {
+      const result = buildRustArgs(argv("-c"), "claude", SUPPORTED_CLIS);
+      expect(result).toContain("-c");
+    });
+
+    it("all flags are preserved in complex invocation", () => {
+      const result = buildRustArgs(
+        argv("--timeout", "1h", "--verbose", "-c", "--robust", "true"),
+        "claude",
+        SUPPORTED_CLIS,
+      );
+      for (const flag of ["--timeout", "--verbose", "-c", "--robust"]) {
+        expect(result).toContain(flag);
+      }
+      expect(result[0]).toBe("--cli=claude");
+    });
+  });
+
+  // ─── --rust flag filtering ─────────────────────────────────────────
+
+  describe("--rust flag is filtered out", () => {
+    it("removes --rust from args", () => {
+      const result = buildRustArgs(argv("--rust", "--timeout", "30s"), "claude", SUPPORTED_CLIS);
+      expect(result).not.toContain("--rust");
+      expect(result).toContain("--timeout");
+    });
+
+    it("removes --rust= variant from args", () => {
+      const result = buildRustArgs(argv("--rust=true", "--verbose"), "claude", SUPPORTED_CLIS);
+      expect(result).not.toContain("--rust=true");
+      expect(result).toContain("--verbose");
+    });
+
+    it("removes --rust regardless of position", () => {
+      const result = buildRustArgs(
+        argv("--verbose", "--rust", "--timeout", "5m"),
+        "claude",
+        SUPPORTED_CLIS,
+      );
+      expect(result).not.toContain("--rust");
+      expect(result).toEqual(["--cli=claude", "--verbose", "--timeout", "5m"]);
+    });
+  });
+
+  // ─── CLI name detection in args ────────────────────────────────────
+
+  describe("does not duplicate CLI name if already in args", () => {
+    it("hoists a positional CLI name into a leading --cli= flag", () => {
+      const result = buildRustArgs(argv("--timeout", "30s", "claude"), "claude", SUPPORTED_CLIS);
+      expect(result).toEqual(["--cli=claude", "--timeout", "30s"]);
+      expect(result.filter((a) => a.includes("claude"))).toHaveLength(1);
+    });
+
+    it("skips --cli= when --cli= flag is already used", () => {
+      const result = buildRustArgs(
+        argv("--cli=codex", "--timeout", "30s"),
+        "claude",
+        SUPPORTED_CLIS,
+      );
+      expect(result).toEqual(["--cli=codex", "--timeout", "30s"]);
+      expect(result).not.toContain("--cli=claude");
+    });
+
+    it("skips --cli= when --cli flag is used (separate value)", () => {
+      const result = buildRustArgs(
+        argv("--cli", "codex", "--timeout", "30s"),
+        "claude",
+        SUPPORTED_CLIS,
+      );
+      expect(result).toEqual(["--cli", "codex", "--timeout", "30s"]);
+      expect(result).not.toContain("--cli=claude");
+    });
+
+    it("detects any supported CLI name in args", () => {
+      for (const cli of ["codex", "copilot", "cursor", "grok"]) {
+        const result = buildRustArgs(argv("--timeout", "1m", cli), "claude", SUPPORTED_CLIS);
+        expect(result).not.toContain("--cli=claude");
+        expect(result[0]).toBe(`--cli=${cli}`);
+        expect(result).toContain("--timeout");
+      }
+    });
+  });
+
+  // ─── Regression: agent-yes flags AFTER a positional CLI name ───────
+  // `ay <cli> --cwd <dir>` is the documented form. The CLI name must be hoisted
+  // to a leading --cli= flag, otherwise clap's trailing_var_arg swallows --cwd
+  // and forwards it to the target CLI (which errors on the unknown option).
+
+  describe("regression: flags after a positional CLI name are not swallowed", () => {
+    it("hoists CLI name so --cwd is parsed by agent-yes, not forwarded", () => {
+      const result = buildRustArgs(
+        argv("claude", "--cwd", "../qa1", "--", "do", "the", "thing"),
+        "claude",
+        SUPPORTED_CLIS,
+      );
+      expect(result).toEqual(["--cli=claude", "--cwd", "../qa1", "--", "do", "the", "thing"]);
+    });
+
+    it("works for the ay generic entry (cliFromScript undefined)", () => {
+      const result = buildRustArgs(argv("codex", "--cwd", "/tmp/x"), undefined, SUPPORTED_CLIS);
+      expect(result).toEqual(["--cli=codex", "--cwd", "/tmp/x"]);
+    });
+
+    it("does not treat a supported-CLI word after -- as the CLI selector", () => {
+      const result = buildRustArgs(
+        argv("--cwd", "/tmp/x", "--", "ask", "claude"),
+        "claude",
+        SUPPORTED_CLIS,
+      );
+      expect(result).toEqual(["--cli=claude", "--cwd", "/tmp/x", "--", "ask", "claude"]);
+    });
+  });
+
+  // ─── Swarm mode ────────────────────────────────────────────────────
+
+  describe("swarm mode skips CLI name", () => {
+    it("does not add --cli= when --swarm is present", () => {
+      const result = buildRustArgs(argv("--swarm", "my-topic"), "claude", SUPPORTED_CLIS);
+      expect(result).toEqual(["--swarm", "my-topic"]);
+      expect(result).not.toContain("--cli=claude");
+    });
+
+    it("does not add --cli= when --swarm= is present", () => {
+      const result = buildRustArgs(argv("--swarm=my-topic"), "claude", SUPPORTED_CLIS);
+      expect(result).toEqual(["--swarm=my-topic"]);
+      expect(result).not.toContain("--cli=claude");
+    });
+
+    it("does not add --cli= for bare --swarm", () => {
+      const result = buildRustArgs(argv("--swarm"), "claude", SUPPORTED_CLIS);
+      expect(result).toEqual(["--swarm"]);
+      expect(result).not.toContain("--cli=claude");
+    });
+  });
+
+  // ─── No CLI from script name ───────────────────────────────────────
+
+  describe("no CLI from script name (agent-yes / ay)", () => {
+    it("returns raw args when cliFromScript is undefined", () => {
+      const result = buildRustArgs(argv("--timeout", "30s"), undefined, SUPPORTED_CLIS);
+      expect(result).toEqual(["--timeout", "30s"]);
+    });
+
+    it("returns raw args when cliFromScript is empty string", () => {
+      const result = buildRustArgs(argv("--timeout", "30s"), "", SUPPORTED_CLIS);
+      expect(result).toEqual(["--timeout", "30s"]);
+    });
+  });
+
+  // ─── Edge cases ────────────────────────────────────────────────────
+
+  describe("edge cases", () => {
+    it("handles no user args at all", () => {
+      const result = buildRustArgs(["node", "/path/to/claude-yes"], "claude", SUPPORTED_CLIS);
+      expect(result).toEqual(["--cli=claude"]);
+    });
+
+    it("handles -- prompt separator correctly", () => {
+      const result = buildRustArgs(
+        argv("--timeout", "1h", "--", "do", "the", "thing"),
+        "claude",
+        SUPPORTED_CLIS,
+      );
+      expect(result).toEqual(["--cli=claude", "--timeout", "1h", "--", "do", "the", "thing"]);
+    });
+
+    it("handles -p prompt flag", () => {
+      const result = buildRustArgs(argv("-p", "hello world"), "claude", SUPPORTED_CLIS);
+      expect(result).toEqual(["--cli=claude", "-p", "hello world"]);
+    });
+
+    it("preserves args with hyphen values (e.g. negative numbers)", () => {
+      const result = buildRustArgs(argv("--some-flag", "-1"), "claude", SUPPORTED_CLIS);
+      expect(result).toEqual(["--cli=claude", "--some-flag", "-1"]);
+    });
+
+    it("handles multiple --rust flags (all filtered)", () => {
+      const result = buildRustArgs(argv("--rust", "--rust", "--verbose"), "claude", SUPPORTED_CLIS);
+      expect(result).toEqual(["--cli=claude", "--verbose"]);
+    });
+
+    it("does not treat --swarm-topic as --swarm", () => {
+      const result = buildRustArgs(argv("--swarm-topic", "my-topic"), "claude", SUPPORTED_CLIS);
+      // --swarm-topic is NOT --swarm, so --cli= should still be added
+      expect(result[0]).toBe("--cli=claude");
+    });
+
+    it("does not treat --cli-like strings inside values as CLI names", () => {
+      const result = buildRustArgs(argv("-p", "use claude to fix"), undefined, SUPPORTED_CLIS);
+      // "claude" appears inside a value, but since cliFromScript is undefined, nothing added
+      expect(result).toEqual(["-p", "use claude to fix"]);
+    });
+
+    it("bare words (prompt without --) are passed through for Rust to handle", () => {
+      const result = buildRustArgs(
+        argv("rebuild", "and", "analyze", "problems"),
+        "claude",
+        SUPPORTED_CLIS,
+      );
+      expect(result).toEqual(["--cli=claude", "rebuild", "and", "analyze", "problems"]);
+    });
+  });
+
+  // ─── Real-world command scenarios ──────────────────────────────────
+
+  describe("real-world scenarios", () => {
+    it("claude-yes --rust --timeout 1h (the original failing case)", () => {
+      const result = buildRustArgs(argv("--rust", "--timeout", "1h"), "claude", SUPPORTED_CLIS);
+      expect(result).toEqual(["--cli=claude", "--timeout", "1h"]);
+    });
+
+    it("claude-yes --rust --timeout 30s --verbose", () => {
+      const result = buildRustArgs(
+        argv("--rust", "--timeout", "30s", "--verbose"),
+        "claude",
+        SUPPORTED_CLIS,
+      );
+      expect(result).toEqual(["--cli=claude", "--timeout", "30s", "--verbose"]);
+    });
+
+    it("claude-yes --rust -c (continue session)", () => {
+      const result = buildRustArgs(argv("--rust", "-c"), "claude", SUPPORTED_CLIS);
+      expect(result).toEqual(["--cli=claude", "-c"]);
+    });
+
+    it("codex-yes --rust --timeout 5m -- fix all bugs", () => {
+      const result = buildRustArgs(
+        argv("--rust", "--timeout", "5m", "--", "fix", "all", "bugs"),
+        "codex",
+        SUPPORTED_CLIS,
+      );
+      expect(result).toEqual(["--cli=codex", "--timeout", "5m", "--", "fix", "all", "bugs"]);
+    });
+
+    it("agent-yes --rust claude --timeout 1h (explicit CLI in args)", () => {
+      const result = buildRustArgs(
+        argv("--rust", "claude", "--timeout", "1h"),
+        undefined,
+        SUPPORTED_CLIS,
+      );
+      // cliFromScript is undefined (agent-yes); the positional CLI name is hoisted
+      // to --cli= so --timeout isn't swallowed by clap's trailing_var_arg.
+      expect(result).toEqual(["--cli=claude", "--timeout", "1h"]);
+    });
+
+    it("agent-yes --rust --swarm my-project --timeout 1h", () => {
+      const result = buildRustArgs(
+        argv("--rust", "--swarm", "my-project", "--timeout", "1h"),
+        "claude",
+        SUPPORTED_CLIS,
+      );
+      // Swarm mode: no CLI name added
+      expect(result).toEqual(["--swarm", "my-project", "--timeout", "1h"]);
+      expect(result).not.toContain("--cli=claude");
+    });
+
+    it("codex-yes --rust --timeout 2m --verbose -p 'hello'", () => {
+      const result = buildRustArgs(
+        argv("--rust", "--timeout", "2m", "--verbose", "-p", "hello"),
+        "codex",
+        SUPPORTED_CLIS,
+      );
+      expect(result).toEqual(["--cli=codex", "--timeout", "2m", "--verbose", "-p", "hello"]);
+    });
+
+    it("claude-yes --rust --auto=no --timeout 10m", () => {
+      const result = buildRustArgs(
+        argv("--rust", "--auto=no", "--timeout", "10m"),
+        "claude",
+        SUPPORTED_CLIS,
+      );
+      expect(result).toEqual(["--cli=claude", "--auto=no", "--timeout", "10m"]);
+    });
+
+    it("cy rebuild and analyze problems (bare prompt words)", () => {
+      const result = buildRustArgs(
+        argv("rebuild", "and", "analyze", "problems"),
+        "claude",
+        SUPPORTED_CLIS,
+      );
+      // CLI passed via --cli=, bare words passed through for Rust to interpret as prompt
+      expect(result).toEqual(["--cli=claude", "rebuild", "and", "analyze", "problems"]);
+    });
+  });
+});