muonroi-cli 1.4.0 → 1.4.1

package/src/orchestrator/tool-loop-cap.test.ts

@@ -1,193 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { createToolLoopCapPredicate, DEFAULT_TOOL_LOOP_BUMP } from "./tool-loop-cap.js";
-
-function steps(n: number): { steps: ReadonlyArray<unknown> } {
-  return { steps: Array.from({ length: n }, () => ({})) };
-}
-
-/**
- * Build a steps array where each step has a single bash tool call. Used by
- * the pattern-detector tests below. Pass an array of commands — one per step.
- */
-function bashSteps(commands: string[]): { steps: ReadonlyArray<unknown> } {
-  return {
-    steps: commands.map((command) => ({
-      toolCalls: [{ toolName: "bash", input: { command } }],
-    })),
-  };
-}
-
-describe("createToolLoopCapPredicate — cap guard", () => {
-  it("returns false while step count is below cap", async () => {
-    const stop = createToolLoopCapPredicate({ initialCap: 100 });
-    expect(await stop(steps(0))).toBe(false);
-    expect(await stop(steps(50))).toBe(false);
-    expect(await stop(steps(99))).toBe(false);
-  });
-
-  it("hard-stops at the cap when no ask handler is wired (legacy headless)", async () => {
-    const stop = createToolLoopCapPredicate({ initialCap: 10 });
-    expect(await stop(steps(10))).toBe(true);
-  });
-
-  it("continue verdict raises the cap by the default bump (50) and resumes", async () => {
-    const ask = vi.fn().mockResolvedValueOnce("continue").mockResolvedValueOnce("stop");
-    const stop = createToolLoopCapPredicate({ initialCap: 100, ask });
-    expect(await stop(steps(100))).toBe(false);
-    expect(ask).toHaveBeenCalledWith({ kind: "cap", stepNumber: 100, cap: 100, bumpBy: DEFAULT_TOOL_LOOP_BUMP });
-    expect(await stop(steps(149))).toBe(false);
-    expect(ask).toHaveBeenCalledTimes(1);
-    expect(await stop(steps(150))).toBe(true);
-    expect(ask).toHaveBeenLastCalledWith({ kind: "cap", stepNumber: 150, cap: 150, bumpBy: DEFAULT_TOOL_LOOP_BUMP });
-  });
-
-  it("respects custom bumpBy", async () => {
-    const ask = vi.fn().mockResolvedValueOnce("continue").mockResolvedValueOnce("stop");
-    const stop = createToolLoopCapPredicate({ initialCap: 10, bumpBy: 5, ask });
-    expect(await stop(steps(10))).toBe(false);
-    expect(await stop(steps(14))).toBe(false);
-    expect(await stop(steps(15))).toBe(true);
-    expect(ask).toHaveBeenLastCalledWith({ kind: "cap", stepNumber: 15, cap: 15, bumpBy: 5 });
-  });
-
-  it("stop verdict halts without bumping the cap", async () => {
-    const ask = vi.fn().mockResolvedValue("stop");
-    const stop = createToolLoopCapPredicate({ initialCap: 5, ask });
-    expect(await stop(steps(5))).toBe(true);
-    expect(ask).toHaveBeenCalledOnce();
-  });
-});
-
-describe("createToolLoopCapPredicate — pattern guard", () => {
-  // Each call to stop(...) must show monotonically-growing step counts because
-  // the predicate only processes the newly-added tail. We simulate streamText's
-  // behaviour by calling stop after each new step.
-  async function feed(stop: (s: { steps: ReadonlyArray<unknown> }) => Promise<boolean>, commands: string[]) {
-    const verdicts: boolean[] = [];
-    for (let i = 1; i <= commands.length; i++) {
-      verdicts.push(await stop(bashSteps(commands.slice(0, i))));
-    }
-    return verdicts;
-  }
-
-  it("does not fire when patterns vary", async () => {
-    const ask = vi.fn();
-    const stop = createToolLoopCapPredicate({ initialCap: 1000, ask });
-    await feed(stop, ["git status", "ls -la", "git log -5", "bun run build", "cat README.md"]);
-    expect(ask).not.toHaveBeenCalled();
-  });
-
-  // Phase 5 BUG-F+G: verification commands (vitest/tsc/test/lint) are now
-  // exempt from pattern detection — agents re-run them as part of normal
-  // edit→typecheck→fix cycles, and counting them as loop tripped the askcard
-  // on legitimate work. We swap to git diff invocations for the same scenario.
-  it("fires when 3-of-5 bash calls collapse to the same canonical hash", async () => {
-    const ask = vi.fn().mockResolvedValue("stop");
-    const stop = createToolLoopCapPredicate({ initialCap: 1000, ask });
-    const verdicts = await feed(stop, [
-      "ls -la",
-      "cat package.json",
-      "git diff HEAD",
-      "git diff HEAD > /tmp/diff.txt",
-      "git diff HEAD 2>&1",
-    ]);
-    expect(ask).toHaveBeenCalledOnce();
-    expect(ask).toHaveBeenCalledWith({
-      kind: "pattern",
-      toolName: "bash",
-      count: 3,
-      windowSize: 5,
-      stepNumber: 5,
-      naturalCeiling: undefined,
-    });
-    expect(verdicts[verdicts.length - 1]).toBe(true);
-  });
-
-  it("continue verdict clears the ring and resumes", async () => {
-    const ask = vi.fn().mockResolvedValueOnce("continue");
-    const stop = createToolLoopCapPredicate({ initialCap: 1000, ask });
-    // Fire pattern detection on call 3.
-    const v1 = await feed(stop, ["git diff HEAD | head", "git diff HEAD | tail", "git diff HEAD > /tmp/x"]);
-    expect(ask).toHaveBeenCalledOnce();
-    // Continue → ring cleared → 3 more identical calls should NOT fire again
-    // (one-shot per session).
-    await feed(stop, ["git diff HEAD | wc -l", "git diff HEAD | grep diff", "git diff HEAD > /tmp/y"]);
-    expect(ask).toHaveBeenCalledOnce();
-    expect(v1.every((v) => v === false)).toBe(true);
-  });
-
-  it("respects custom patternWindow / patternThreshold", async () => {
-    const ask = vi.fn().mockResolvedValue("stop");
-    const stop = createToolLoopCapPredicate({
-      initialCap: 1000,
-      ask,
-      patternWindow: 3,
-      patternThreshold: 2,
-    });
-    await feed(stop, ["git status", "git diff HEAD", "git diff HEAD > /tmp/x"]);
-    expect(ask).toHaveBeenCalledOnce();
-    expect(ask).toHaveBeenCalledWith({
-      kind: "pattern",
-      toolName: "bash",
-      count: 2,
-      windowSize: 3,
-      stepNumber: 3,
-      naturalCeiling: undefined,
-    });
-  });
-
-  it("does not fire without an ask handler (headless safety)", async () => {
-    const stop = createToolLoopCapPredicate({ initialCap: 1000 });
-    const verdicts = await feed(stop, ["git diff HEAD | head", "git diff HEAD | tail", "git diff HEAD > /tmp/x"]);
-    expect(verdicts.every((v) => v === false)).toBe(true);
-  });
-
-  // Phase 5 BUG-F — verification commands MUST NOT trigger the pattern guard
-  // even when run 5x in a row (edit→typecheck→fix iteration is normal work).
-  it("does NOT fire when verification commands are repeated", async () => {
-    const ask = vi.fn().mockResolvedValue("stop");
-    const stop = createToolLoopCapPredicate({ initialCap: 1000, ask });
-    await feed(stop, ["bunx tsc --noEmit", "bunx tsc --noEmit", "bunx tsc --noEmit", "bunx tsc --noEmit"]);
-    expect(ask).not.toHaveBeenCalled();
-  });
-
-  // Phase 5 BUG-G — pipe-native tools (grep, sed, awk, jq, find) preserve
-  // their pipe chain in the canonical form because the pipe IS the query.
-  // Three legitimately-different grep filter chains on the same file should
-  // NOT collide.
-  it("does NOT fire when grep pipe-chains differ on the same target", async () => {
-    const ask = vi.fn().mockResolvedValue("stop");
-    const stop = createToolLoopCapPredicate({ initialCap: 1000, ask });
-    await feed(stop, [
-      'grep -n "^import " src/index.ts | head -60',
-      'grep -n "^import " src/index.ts | wc -l',
-      'grep -n "^import " src/index.ts | grep -v type',
-    ]);
-    expect(ask).not.toHaveBeenCalled();
-  });
-
-  // Phase 5 BUG-H — pattern info carries stepNumber + naturalCeiling so the
-  // UI can pick a context-aware default action.
-  it("propagates stepNumber and naturalCeiling to the ask handler", async () => {
-    const ask = vi.fn().mockResolvedValue("stop");
-    const stop = createToolLoopCapPredicate({
-      initialCap: 1000,
-      ask,
-      naturalCeiling: 18,
-    });
-    await feed(stop, [
-      "git diff HEAD",
-      "git diff HEAD | head",
-      "ls",
-      "git diff HEAD | wc -l", // <- pattern fires here (3 git-diffs in window)
-      "git diff HEAD > /tmp/x",
-    ]);
-    expect(ask).toHaveBeenCalledWith(
-      expect.objectContaining({
-        kind: "pattern",
-        stepNumber: 4,
-        naturalCeiling: 18,
-      }),
-    );
-  });
-});

package/src/orchestrator/tool-loop-cap.ts

@@ -1,174 +0,0 @@
-/**
- * src/orchestrator/tool-loop-cap.ts
- *
- * Pure factory for the AI-SDK `stopWhen` predicate that backs two related
- * "agent is going off the rails" guards:
- *
- *  1. **Cap guard** — when the streamText loop hits the cap, ask the user
- *     whether to bump the cap (+50 default) or stop.
- *  2. **Pattern guard (Fix #1)** — when the last 5 tool calls have ≥ 3 with
- *     the same canonical args hash (e.g. agent ran `bunx vitest | tail -5`,
- *     `bunx vitest | head -10`, `bunx vitest | grep FAIL` in a row), ask
- *     the user whether to continue or stop *before* the cap runs out.
- *
- * Both guards are surfaced through the same `ask` callback using a tagged
- * union (`kind: "cap" | "pattern"`) so callers can route to the right askcard
- * phase. The pattern guard fires at most once per session — a single trip is
- * enough to break the loop; firing repeatedly would be noise.
- *
- * Extracted from message-processor.ts so we can unit-test the algorithm
- * without standing up a full streamText harness.
- */
-
-import { hashToolArgs } from "./tool-args-hash.js";
-
-export type ToolLoopCapAskInfo =
-  | { kind: "cap"; stepNumber: number; cap: number; bumpBy: number }
-  | {
-      kind: "pattern";
-      toolName: string;
-      count: number;
-      windowSize: number;
-      /** Step count at the time the pattern fired — drives default-action heuristic. */
-      stepNumber: number;
-      /** Resolved natural ceiling for the current (taskType, size). Optional — undefined when caller can't compute it. */
-      naturalCeiling?: number;
-    };
-
-export type ToolLoopCapAsk = (info: ToolLoopCapAskInfo) => Promise<"continue" | "stop">;
-
-export interface ToolLoopCapOptions {
-  initialCap: number;
-  bumpBy?: number;
-  ask?: ToolLoopCapAsk;
-  /** Override defaults — exposed for tests. */
-  patternWindow?: number;
-  patternThreshold?: number;
-  /**
-   * Natural step ceiling for the current (taskType, size). Passed to the ask
-   * handler so the askcard UI can pick a context-aware defaultIndex (continue
-   * early, stop late).
-   */
-  naturalCeiling?: number;
-}
-
-export const DEFAULT_TOOL_LOOP_BUMP = 50;
-export const DEFAULT_PATTERN_WINDOW = 5;
-export const DEFAULT_PATTERN_THRESHOLD = 3;
-
-// Minimal shape we need from an AI-SDK step. Kept loose because the SDK's
-// step type is generic over toolset and we don't want to fight types here.
-interface MinimalStep {
-  toolCalls?: ReadonlyArray<{ toolName?: string; input?: unknown; args?: unknown }>;
-}
-
-/**
- * Hash an entire step (all tool calls in order) so two parallel reads of
- * different files don't collide just because the first-positional call
- * happens to be identical. Phase 5 BUG-G (session f1a2a2a547db) — agent
- * issued 3 parallel-style steps reading layer16-clarity.ts + its test file;
- * detecting only `toolCalls[0]` hashed all 3 to the same value and tripped
- * the loop guard even though step-2 and step-4 also touched the test file.
- *
- * Skips `verify:` sentinel hashes — verification commands MUST NOT count
- * toward the pattern window (they're iteration markers, not loop signal).
- *
- * Returns null when the step has no usable tool calls.
- */
-function hashStep(step: MinimalStep | undefined): { hash: string; toolName: string } | null {
-  if (!step?.toolCalls?.length) return null;
-  const parts: string[] = [];
-  for (const tc of step.toolCalls) {
-    if (!tc?.toolName) continue;
-    const argsCandidate = tc.input !== undefined ? tc.input : tc.args;
-    const h = hashToolArgs(tc.toolName, argsCandidate);
-    // Verification calls — drop entirely from the step signature so they
-    // can't cause repeated edit+typecheck cycles to look identical.
-    if (h.startsWith("verify:")) continue;
-    parts.push(h);
-  }
-  if (parts.length === 0) return null;
-  const firstToolName = step.toolCalls.find((tc) => tc?.toolName)?.toolName ?? "unknown";
-  // Join with `|` — order-sensitive on purpose: a step doing [read A, read B]
-  // is distinct from [read B, read A] in tool-emission order, so collapsing
-  // them risks hiding a real loop where the agent reorders calls.
-  return { hash: parts.join("|"), toolName: firstToolName };
-}
-
-/**
- * Build the async stopWhen predicate.
- *
- *   - Pattern dup ≥ threshold in window → ask("pattern"); fire-once per session
- *   - `sn < cap`                        → false (keep going)
- *   - cap hit, no `ask`                 → true  (legacy hard-stop, batch / headless)
- *   - cap hit, ask=continue             → bump cap by `bumpBy`, return false
- *   - cap hit, ask=stop                 → true  (graceful halt)
- */
-export function createToolLoopCapPredicate(
-  opts: ToolLoopCapOptions,
-): (state: { steps: ReadonlyArray<unknown> }) => Promise<boolean> {
-  let cap = opts.initialCap;
-  const bumpBy = opts.bumpBy ?? DEFAULT_TOOL_LOOP_BUMP;
-  const ask = opts.ask;
-  const patternWindow = opts.patternWindow ?? DEFAULT_PATTERN_WINDOW;
-  const patternThreshold = opts.patternThreshold ?? DEFAULT_PATTERN_THRESHOLD;
-
-  // Pattern detector state — one-shot per session to avoid asking again after
-  // the user said "continue". The cap guard still catches the loop later.
-  const recent: { hash: string; toolName: string }[] = [];
-  let patternAskFired = false;
-  let lastSeenStepCount = 0;
-
-  return async ({ steps }) => {
-    const sn = steps.length;
-
-    // Pattern detector — examine the most recently-added step's tool calls.
-    // streamText calls stopWhen between steps, so `steps[sn-1]` is the step
-    // that just finished. Multiple stopWhen invocations may pass the same
-    // step length (e.g. compaction reruns); only process new growth.
-    if (ask && !patternAskFired && sn > lastSeenStepCount) {
-      lastSeenStepCount = sn;
-      const lastStep = steps[sn - 1] as MinimalStep | undefined;
-      const stepSig = hashStep(lastStep);
-      if (stepSig) {
-        // File edits (edit_file / write_file) are normal productive refinement on the same target.
-        // Do not let repeated edits on one file contribute to pattern-loop detection.
-        // This prevents false-positive stop warnings during legitimate iterative work
-        // (e.g. session df2dbb878984 and similar "edit same file 3x" flows).
-        // The max-tool-rounds cap still protects against true runaway loops.
-        if (stepSig.toolName === "edit_file" || stepSig.toolName === "write_file") {
-          // skip pattern accounting for fs edits
-        } else {
-          recent.push(stepSig);
-          if (recent.length > patternWindow) recent.shift();
-          const dupCount = recent.filter((r) => r.hash === stepSig.hash).length;
-          if (dupCount >= patternThreshold) {
-            patternAskFired = true; // one-shot regardless of verdict
-            const verdict = await ask({
-              kind: "pattern",
-              toolName: stepSig.toolName,
-              count: dupCount,
-              windowSize: recent.length,
-              stepNumber: sn,
-              naturalCeiling: opts.naturalCeiling,
-            });
-            if (verdict === "stop") return true;
-            // Continue → clear the ring so we don't immediately re-fire on the
-            // next call (user explicitly accepted; give them breathing room).
-            recent.length = 0;
-          }
-        }
-      }
-    }
-
-    // Cap guard — unchanged behaviour.
-    if (sn < cap) return false;
-    if (!ask) return true;
-    const verdict = await ask({ kind: "cap", stepNumber: sn, cap, bumpBy });
-    if (verdict === "continue") {
-      cap += bumpBy;
-      return false;
-    }
-    return true;
-  };
-}

package/src/orchestrator/tool-repetition-detector.test.ts

@@ -1,119 +0,0 @@
-/**
- * Regression for session 080fe2fcbf24 (2026-05-26): Qwen3-30B emitted the
- * same malformed grep args 4× consecutively, ate the TPM budget, then 429.
- *
- * Tests pin:
- *   - 1st + 2nd identical failures do NOT trigger (TRIGGER_RUN_LENGTH=3)
- *   - 3rd identical failure DOES trigger (shouldAbort=true)
- *   - 4th+ identical failures don't re-trigger (abortFired latch — caller
- *     decides whether to end; we shouldn't tell them to abort twice)
- *   - Different input resets the counter even with same tool
- *   - Different tool resets the counter
- *   - Different error message resets the counter (model might be recovering)
- *   - Null/empty sessionId is a no-op (so utility callers don't crash)
- *   - recordToolSuccess clears the run (mixed success/fail sequences reset)
- */
-import { afterEach, describe, expect, it } from "vitest";
-import {
-  _resetForTests,
-  buildToolRepetitionAbortMessage,
-  recordToolError,
-  recordToolSuccess,
-} from "./tool-repetition-detector.js";
-
-const SID = "sess-test";
-const MALFORMED_GREP_ARGS = {
-  pattern: "catch\\s*\\{\\s*\\},",
-  path: ".",
-  include: "*.ts",
-};
-const PARSE_ERROR =
-  'Invalid input for tool grep: JSON parsing failed: Text:  {"pattern": "catch\\\\s*\\\\{\\\\s*\\\\}, "path": ".", "include": "*.ts"}.\nError message: JSON Parse error: Expected \'}\'';
-
-describe("tool-repetition-detector", () => {
-  afterEach(() => _resetForTests());
-
-  it("does not trigger on the first two identical failures", () => {
-    const r1 = recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-    expect(r1).toEqual({ runLength: 1, shouldAbort: false });
-    const r2 = recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-    expect(r2).toEqual({ runLength: 2, shouldAbort: false });
-  });
-
-  it("triggers abort on the 3rd consecutive identical failure (session 080fe2fcbf24 case)", () => {
-    recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-    recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-    const r3 = recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-    expect(r3.runLength).toBe(3);
-    expect(r3.shouldAbort).toBe(true);
-  });
-
-  it("does not re-trigger abort on subsequent identical failures (one-shot latch)", () => {
-    recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-    recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-    const r3 = recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-    expect(r3.shouldAbort).toBe(true);
-    const r4 = recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-    expect(r4.runLength).toBe(4);
-    expect(r4.shouldAbort).toBe(false);
-  });
-
-  it("resets on different input (model is varying the args — that's progress)", () => {
-    recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-    recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-    const r3 = recordToolError(SID, "grep", { pattern: "different" }, PARSE_ERROR);
-    expect(r3).toEqual({ runLength: 1, shouldAbort: false });
-  });
-
-  it("resets on different tool name (a different call type is progress)", () => {
-    recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-    recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-    const r3 = recordToolError(SID, "read_file", MALFORMED_GREP_ARGS, PARSE_ERROR);
-    expect(r3).toEqual({ runLength: 1, shouldAbort: false });
-  });
-
-  it("resets on different error (model may be recovering — let it try)", () => {
-    recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-    recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-    const r3 = recordToolError(SID, "grep", MALFORMED_GREP_ARGS, "different error — file not found");
-    expect(r3).toEqual({ runLength: 1, shouldAbort: false });
-  });
-
-  it("isolates sessions (one session's loop does not affect another)", () => {
-    recordToolError("sess-A", "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-    recordToolError("sess-A", "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-    // sess-B is fresh.
-    const r = recordToolError("sess-B", "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-    expect(r).toEqual({ runLength: 1, shouldAbort: false });
-  });
-
-  it("no-ops when sessionId is null or empty (utility callers don't crash)", () => {
-    expect(recordToolError(null, "grep", {}, "err")).toEqual({ runLength: 1, shouldAbort: false });
-    expect(recordToolError("", "grep", {}, "err")).toEqual({ runLength: 1, shouldAbort: false });
-    expect(recordToolError(undefined, "grep", {}, "err")).toEqual({ runLength: 1, shouldAbort: false });
-  });
-
-  it("recordToolSuccess clears the run (mixed success/fail sequence)", () => {
-    recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-    recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-    recordToolSuccess(SID);
-    const r = recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-    expect(r).toEqual({ runLength: 1, shouldAbort: false });
-  });
-
-  it("buildToolRepetitionAbortMessage includes tool name, run count, and error snippet", () => {
-    const msg = buildToolRepetitionAbortMessage("grep", 3, PARSE_ERROR);
-    expect(msg).toContain('"grep"');
-    expect(msg).toContain("3 times in a row");
-    expect(msg).toContain("JSON parsing failed");
-    expect(msg.length).toBeLessThan(800);
-  });
-
-  it("buildToolRepetitionAbortMessage truncates and normalizes whitespace in the error preview", () => {
-    const giantErr = `${"x".repeat(2000)}\n\n\nmessy`;
-    const msg = buildToolRepetitionAbortMessage("bash", 5, giantErr);
-    expect(msg).toContain("5 times in a row");
-    expect(msg.length).toBeLessThan(800);
-    expect(msg).not.toMatch(/\n\n+/);
-  });
-});