muonroi-cli 1.8.0 → 1.8.3

package/dist/src/orchestrator/token-counter.test.js

@@ -1,57 +0,0 @@
-import { afterEach, describe, expect, it } from "vitest";
-import { __forceFallbackForTests, countTokens, isTokenizerReady, setProviderHint } from "./token-counter.js";
-describe("token-counter", () => {
-    afterEach(() => {
-        __forceFallbackForTests(false);
-        setProviderHint(null);
-    });
-    it("returns 0 for empty input", () => {
-        expect(countTokens("")).toBe(0);
-    });
-    it("uses BPE tokenizer when available — code is denser than chars/4", () => {
-        __forceFallbackForTests(false);
-        expect(isTokenizerReady()).toBe(true);
-        // A short code-like string of 20 chars: chars/4 = 5, BPE typically 6–10.
-        const code = "const x = foo(bar);";
-        const bpe = countTokens(code);
-        const heuristic = Math.ceil(code.length / 4);
-        // BPE for code is generally >= heuristic (code uses more, denser tokens).
-        expect(bpe).toBeGreaterThanOrEqual(heuristic - 1);
-        // And it should NOT be a wild over-count.
-        expect(bpe).toBeLessThan(heuristic * 3);
-    });
-    it("falls back to chars/4 when forced", () => {
-        __forceFallbackForTests(true);
-        expect(countTokens("hello world")).toBe(Math.ceil("hello world".length / 4));
-        expect(isTokenizerReady()).toBe(false);
-    });
-    it("BPE is closer to ground truth on prose vs chars/4", () => {
-        // English prose: chars/4 typically overcounts. BPE gives a smaller number.
-        __forceFallbackForTests(false);
-        const prose = "The quick brown fox jumps over the lazy dog. Repeated several times for a longer sample.";
-        const bpe = countTokens(prose);
-        const heuristic = Math.ceil(prose.length / 4);
-        expect(bpe).toBeLessThan(heuristic);
-    });
-    it("applies the deepseek correction multiplier (~+5%) on top of cl100k_base", () => {
-        __forceFallbackForTests(false);
-        const text = "function add(a, b) { return a + b; }".repeat(10);
-        setProviderHint(null);
-        const baseline = countTokens(text);
-        setProviderHint("deepseek");
-        const adjusted = countTokens(text);
-        // Multiplier of 1.05 must round up — adjusted is strictly greater than baseline.
-        expect(adjusted).toBeGreaterThan(baseline);
-        expect(adjusted).toBe(Math.ceil(baseline * 1.05));
-    });
-    it("unknown providers get no correction (multiplier = 1)", () => {
-        __forceFallbackForTests(false);
-        const text = "hello world this is some sample text for tokenization";
-        setProviderHint(null);
-        const baseline = countTokens(text);
-        setProviderHint("some-unknown-provider");
-        const adjusted = countTokens(text);
-        expect(adjusted).toBe(baseline);
-    });
-});
-//# sourceMappingURL=token-counter.test.js.map

package/dist/src/orchestrator/tool-args-hash.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/orchestrator/tool-args-hash.test.js

@@ -1,105 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { canonicalizeBashCommand, hashToolArgs } from "./tool-args-hash.js";
-describe("canonicalizeBashCommand", () => {
-    it("strips trailing pipe + tail/head/grep", () => {
-        expect(canonicalizeBashCommand("bunx vitest run | tail -20")).toBe("bunx vitest run");
-        expect(canonicalizeBashCommand("bunx vitest run | head -10")).toBe("bunx vitest run");
-        expect(canonicalizeBashCommand("bunx vitest run | grep FAIL")).toBe("bunx vitest run");
-    });
-    it("strips stderr merge + redirect", () => {
-        expect(canonicalizeBashCommand("bunx vitest run 2>&1 | tail -5")).toBe("bunx vitest run");
-        expect(canonicalizeBashCommand("bunx vitest run > /tmp/out.log")).toBe("bunx vitest run");
-        expect(canonicalizeBashCommand("bunx vitest run >> /tmp/out.log")).toBe("bunx vitest run");
-    });
-    it("strips leading cd && prefix", () => {
-        expect(canonicalizeBashCommand("cd /d/Personal/Core/muonroi-cli && bunx vitest run | tail -5")).toBe("bunx vitest run");
-        expect(canonicalizeBashCommand('cd "D:/Personal/Core/muonroi-cli" && bunx vitest')).toBe("bunx vitest");
-    });
-    it("collapses whitespace", () => {
-        expect(canonicalizeBashCommand("bunx    vitest   run")).toBe("bunx vitest run");
-    });
-    it("does not strip when no redirection present", () => {
-        expect(canonicalizeBashCommand("git status")).toBe("git status");
-    });
-});
-describe("hashToolArgs", () => {
-    // Phase 5 BUG-F+G: verification commands now return `verify:` sentinel
-    // hashes with a per-call nonce so they NEVER collide with each other (each
-    // re-run of typecheck is a fresh progress marker, not a loop signal).
-    // We pick a non-verification cosmetic-variant set (npm-style install) to
-    // assert the original collapse behaviour still works.
-    it("collapses cosmetic bash variations to one hash (non-verification)", () => {
-        const variants = [
-            { command: "bun add zod | tail -20" },
-            { command: "bun add zod 2>&1" },
-            { command: "bun add zod > /tmp/out.log" },
-            { command: "cd /d/Personal/Core/muonroi-cli && bun add zod" },
-        ];
-        const hashes = new Set(variants.map((v) => hashToolArgs("bash", v)));
-        expect(hashes.size).toBe(1);
-    });
-    // Verification commands NEVER collide — every call must return a unique hash
-    // so the pattern detector skips them (edit→typecheck→fix is normal work).
-    it("verification commands produce unique hashes per call", () => {
-        const a = hashToolArgs("bash", { command: "bunx vitest run | tail -20" });
-        const b = hashToolArgs("bash", { command: "bunx vitest run | head -10" });
-        expect(a).not.toBe(b);
-        expect(a.startsWith("verify:")).toBe(true);
-        expect(b.startsWith("verify:")).toBe(true);
-    });
-    it("distinguishes substantively different non-verify bash commands", () => {
-        const a = hashToolArgs("bash", { command: "git status" });
-        const b = hashToolArgs("bash", { command: "git log -5" });
-        expect(a).not.toBe(b);
-    });
-    it("hashes non-bash tools by stable JSON of args", () => {
-        const a = hashToolArgs("read_file", { file_path: "a.ts", start_line: 1 });
-        const b = hashToolArgs("read_file", { start_line: 1, file_path: "a.ts" });
-        expect(a).toBe(b);
-    });
-    it("different args produce different hashes for same tool", () => {
-        const a = hashToolArgs("read_file", { file_path: "a.ts" });
-        const b = hashToolArgs("read_file", { file_path: "b.ts" });
-        expect(a).not.toBe(b);
-    });
-    it("hash is namespaced by tool name", () => {
-        const a = hashToolArgs("bash", { command: "x" });
-        const b = hashToolArgs("read_file", { command: "x" });
-        expect(a.startsWith("bash:")).toBe(true);
-        expect(b.startsWith("read_file:")).toBe(true);
-        expect(a).not.toBe(b);
-    });
-    it("collapses edit_file calls on same file regardless of old/new string", () => {
-        // Real session 39884b072b5f scenario — agent edited the same file 7 times
-        // with different old_string each attempt. Generic JSON hash kept them
-        // distinct; the dedicated file_path hash now collapses them.
-        const variants = [
-            { file_path: "src/ee/export.ts", old_string: "@ts-expect-error", new_string: "@ts-ignore" },
-            { file_path: "src/ee/export.ts", old_string: "  @ts-expect-error", new_string: "// @ts-ignore" },
-            { file_path: "src/ee/export.ts", old_string: "    const mod", new_string: "// @ts-ignore\n    const mod" },
-        ];
-        const hashes = new Set(variants.map((v) => hashToolArgs("edit_file", v)));
-        expect(hashes.size).toBe(1);
-    });
-    it("distinguishes edit_file on different files", () => {
-        const a = hashToolArgs("edit_file", { file_path: "src/a.ts", old_string: "x", new_string: "y" });
-        const b = hashToolArgs("edit_file", { file_path: "src/b.ts", old_string: "x", new_string: "y" });
-        expect(a).not.toBe(b);
-    });
-    it("normalizes path separators (D:\\foo vs D:/foo collapse)", () => {
-        const win = hashToolArgs("edit_file", { file_path: "D:\\Personal\\Core\\file.ts", old_string: "x" });
-        const posix = hashToolArgs("edit_file", { file_path: "D:/Personal/Core/file.ts", old_string: "x" });
-        expect(win).toBe(posix);
-    });
-    it("write_file uses same file-path hash as edit_file (cross-tool overwrite loops collapse separately)", () => {
-        const e = hashToolArgs("edit_file", { file_path: "a.ts" });
-        const w = hashToolArgs("write_file", { file_path: "a.ts" });
-        // Same file, but namespaced by tool — overwrite-loop and edit-loop are
-        // tracked separately so a legitimate "edit then verify-via-write" doesn't
-        // trip the guard, but 5 repeated write_file does.
-        expect(e).not.toBe(w);
-        expect(e.startsWith("edit_file:")).toBe(true);
-        expect(w.startsWith("write_file:")).toBe(true);
-    });
-});
-//# sourceMappingURL=tool-args-hash.test.js.map

package/dist/src/orchestrator/tool-args-repair.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/orchestrator/tool-args-repair.test.js

@@ -1,136 +0,0 @@
-/**
- * Regression for Qwen3-30B malformed tool-call args observed in sessions
- *   080fe2fcbf24 and 11bb9218f605 (2026-05-26).
- *
- * Each describe block locks one observed failure mode plus controls that
- * the repair must NOT corrupt valid JSON, ambiguous patterns outside open
- * strings, or unrelated malformations.
- */
-import { describe, expect, it } from "vitest";
-import { _internals, repairToolCallArgs } from "./tool-args-repair.js";
-describe("repairToolCallArgs — observed Qwen samples", () => {
-    it("repairs session 11bb9218f605: missing close-quote + trailing brace + </tool_call>", () => {
-        // Raw input as seen in interaction_logs.tool_call.argsPreview for the
-        // 3 consecutive grep failures.
-        const raw = '{"pattern": "catch\\\\s*\\\\{[^}]*\\\\}, "path": "src", "include": "*.ts"}}\n</tool_call>';
-        const result = repairToolCallArgs(raw);
-        if (!result.ok)
-            throw new Error(`expected ok, got: ${JSON.stringify(result)}`);
-        expect(result.value).toEqual({
-            pattern: "catch\\s*\\{[^}]*\\}",
-            path: "src",
-            include: "*.ts",
-        });
-        // Confirm the repair pipeline applied the expected transforms.
-        expect(result.transforms).toContain("strip-native-tags");
-        expect(result.transforms).toContain("strip-trailing-braces");
-        expect(result.transforms).toContain("insert-missing-close-quote");
-    });
-    it("repairs session 080fe2fcbf24: missing close-quote + space-after-comma", () => {
-        const raw = '{"pattern": "catch\\\\s*\\\\{\\\\s*\\\\}, "path": ".", "include": "*.ts"}';
-        const result = repairToolCallArgs(raw);
-        if (!result.ok)
-            throw new Error(`expected ok, got: ${JSON.stringify(result)}`);
-        expect(result.value).toEqual({
-            pattern: "catch\\s*\\{\\s*\\}",
-            path: ".",
-            include: "*.ts",
-        });
-        expect(result.transforms).toContain("insert-missing-close-quote");
-    });
-});
-describe("repairToolCallArgs — must NOT corrupt valid input", () => {
-    it("returns fast-path with no transforms on already-valid JSON", () => {
-        const valid = '{"pattern": "catch\\\\s*\\\\{[^}]*\\\\}", "path": "src"}';
-        const result = repairToolCallArgs(valid);
-        if (!result.ok)
-            throw new Error("valid JSON must parse on fast path");
-        expect(result.value).toEqual({ pattern: "catch\\s*\\{[^}]*\\}", path: "src" });
-        expect(result.transforms).toEqual([]);
-    });
-    it("does not insert a quote when \\\\} appears outside an open string", () => {
-        // Object body contains `\\}` only inside a properly-closed string; the
-        // comma + key that follows is at the top level, not a malformed string.
-        // Note: the input below is intentionally NOT malformed — repair must be
-        // a no-op (initial parse succeeds).
-        const valid = '{"a": "x\\\\}", "b": "y"}';
-        const result = repairToolCallArgs(valid);
-        if (!result.ok)
-            throw new Error("valid JSON must parse");
-        expect(result.transforms).toEqual([]);
-    });
-    it("refuses to repair when more than 5 extra trailing braces (input too damaged)", () => {
-        const raw = '{"a": 1}}}}}}}}';
-        const result = repairToolCallArgs(raw);
-        expect(result.ok).toBe(false);
-    });
-    it("refuses to repair empty / non-string inputs", () => {
-        expect(repairToolCallArgs("").ok).toBe(false);
-        // @ts-expect-error — runtime guard for non-string
-        expect(repairToolCallArgs(null).ok).toBe(false);
-        // @ts-expect-error — runtime guard for non-string
-        expect(repairToolCallArgs(undefined).ok).toBe(false);
-    });
-    it("refuses to repair inputs > 50KB (out-of-scope adversarial)", () => {
-        const big = `{"x": "${"y".repeat(60_000)}"}`;
-        const result = repairToolCallArgs(big);
-        expect(result.ok).toBe(false);
-    });
-    it("returns ok=false (not throw) on totally unrelated garbage", () => {
-        expect(repairToolCallArgs("this is not json at all").ok).toBe(false);
-        expect(repairToolCallArgs("<xml>foo</xml>").ok).toBe(false);
-    });
-});
-describe("stripNativeFormatLeak", () => {
-    const { stripNativeFormatLeak } = _internals;
-    it("strips trailing </tool_call>", () => {
-        expect(stripNativeFormatLeak('{"a": 1}\n</tool_call>')).toBe('{"a": 1}');
-    });
-    it("strips trailing </tool_calls> plural variant", () => {
-        expect(stripNativeFormatLeak('{"a": 1}</tool_calls>')).toBe('{"a": 1}');
-    });
-    it("strips trailing <|tool_call_end|> Qwen sentinel", () => {
-        expect(stripNativeFormatLeak('{"a": 1}<|tool_call_end|>')).toBe('{"a": 1}');
-    });
-    it("only strips at end — interior occurrences are preserved (data, not control)", () => {
-        expect(stripNativeFormatLeak('{"description": "see </tool_call> in docs"}')).toBe('{"description": "see </tool_call> in docs"}');
-    });
-    it("is case-insensitive on the tag", () => {
-        expect(stripNativeFormatLeak('{"a": 1}</TOOL_CALL>')).toBe('{"a": 1}');
-    });
-});
-describe("stripUnbalancedTrailingBraces", () => {
-    const { stripUnbalancedTrailingBraces } = _internals;
-    it("strips a single extra trailing brace", () => {
-        expect(stripUnbalancedTrailingBraces('{"a": 1}}')).toBe('{"a": 1}');
-    });
-    it("does not strip when braces are balanced", () => {
-        expect(stripUnbalancedTrailingBraces('{"a": {"b": 1}}')).toBe('{"a": {"b": 1}}');
-    });
-    it("does not count braces inside string values", () => {
-        // 2 `{` open, 1 `}` close, plus literal `{` in string — must NOT touch.
-        expect(stripUnbalancedTrailingBraces('{"x": "{{{"}')).toBe('{"x": "{{{"}');
-    });
-    it("respects escape sequences inside strings", () => {
-        // `\\}` inside a string is one regex character, not a brace.
-        expect(stripUnbalancedTrailingBraces('{"x": "a\\\\}b"}')).toBe('{"x": "a\\\\}b"}');
-    });
-});
-describe("insertMissingCloseQuote", () => {
-    const { insertMissingCloseQuote } = _internals;
-    it('inserts close-quote after \\\\} when followed by `, "key"`', () => {
-        const before = '{"a": "x\\\\}, "b": 1}';
-        const after = insertMissingCloseQuote(before);
-        expect(after).toBe('{"a": "x\\\\}", "b": 1}');
-    });
-    it("handles \\\\] terminator", () => {
-        const before = '{"a": "x\\\\], "b": 1}';
-        const after = insertMissingCloseQuote(before);
-        expect(after).toBe('{"a": "x\\\\]", "b": 1}');
-    });
-    it("returns input unchanged when no inside-string match", () => {
-        const balanced = '{"a": "x", "b": 1}';
-        expect(insertMissingCloseQuote(balanced)).toBe(balanced);
-    });
-});
-//# sourceMappingURL=tool-args-repair.test.js.map

package/dist/src/orchestrator/tool-loop-askcard.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/orchestrator/tool-loop-askcard.test.js

@@ -1,71 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { planLoopCapAskcard } from "./tool-loop-askcard.js";
-describe("planLoopCapAskcard", () => {
-    it("early tier (< 0.5× ceiling): default Continue, no warning", () => {
-        const r = planLoopCapAskcard({ stepNumber: 5, naturalCeiling: 12 });
-        expect(r.tier).toBe("early");
-        expect(r.defaultIndex).toBe(0);
-        expect(r.optionLabels[0]).toMatch(/Continue/);
-        expect(r.optionValues[0]).toBe("continue");
-        expect(r.overageMultiplier).toBeNull();
-        // no warning emoji on the Continue label
-        expect(r.optionLabels[0]).not.toMatch(/⚠/);
-    });
-    it("normal tier (0.5×–2× ceiling): default Stop, no warning, Continue first", () => {
-        const r = planLoopCapAskcard({ stepNumber: 18, naturalCeiling: 12 });
-        expect(r.tier).toBe("normal");
-        expect(r.defaultIndex).toBe(1);
-        expect(r.optionLabels[0]).toBe("Continue (let agent try)");
-        expect(r.optionLabels[1]).toBe("Stop and answer");
-        expect(r.overageMultiplier).toBeNull();
-    });
-    it("overBudget tier (2×–5× ceiling): Continue carries the overage multiplier, default Stop", () => {
-        // The storyflow_ui case: step 29 / ceiling 12 = 2.4×
-        const r = planLoopCapAskcard({ stepNumber: 29, naturalCeiling: 12 });
-        expect(r.tier).toBe("overBudget");
-        expect(r.defaultIndex).toBe(1);
-        expect(r.optionLabels[0]).toMatch(/⚠ 2\.4× past natural budget/);
-        expect(r.optionLabels[1]).toMatch(/Stop and answer \(recommended\)/);
-        expect(r.overageMultiplier).toBe("2.4");
-        // order preserved: Continue at 0, Stop at 1
-        expect(r.optionValues).toEqual(["continue", "stop"]);
-    });
-    it("extreme tier (> 5× ceiling): Stop FIRST in the array, Continue labelled expensive", () => {
-        // session 1f29e238 — step 77 / ceiling 6 = 12.8×
-        const r = planLoopCapAskcard({ stepNumber: 77, naturalCeiling: 6 });
-        expect(r.tier).toBe("extreme");
-        expect(r.defaultIndex).toBe(0);
-        expect(r.optionLabels[0]).toMatch(/Stop and answer \(recommended\)/);
-        expect(r.optionLabels[1]).toMatch(/⚠ 12\.8× over budget — expensive/);
-        expect(r.optionValues).toEqual(["stop", "continue"]); // ORDER REVERSED at extreme
-        expect(r.overageMultiplier).toBe("12.8");
-    });
-    it("tier boundaries are open-on-the-lower-side (ratio==2 → normal; ratio==5 → overBudget; ratio==0.5 → normal)", () => {
-        // ratio === 2.0 exactly → still normal (the > 2 gate excludes 2.0)
-        expect(planLoopCapAskcard({ stepNumber: 24, naturalCeiling: 12 }).tier).toBe("normal");
-        // ratio === 5.0 exactly → still overBudget (the > 5 gate excludes 5.0)
-        expect(planLoopCapAskcard({ stepNumber: 60, naturalCeiling: 12 }).tier).toBe("overBudget");
-        // ratio === 0.5 exactly → normal (the < 0.5 gate excludes 0.5)
-        expect(planLoopCapAskcard({ stepNumber: 6, naturalCeiling: 12 }).tier).toBe("normal");
-    });
-    it("falls back to step-threshold heuristic when naturalCeiling is missing", () => {
-        const early = planLoopCapAskcard({ stepNumber: 8 });
-        expect(early.tier).toBe("early");
-        expect(early.defaultIndex).toBe(0);
-        const normal = planLoopCapAskcard({ stepNumber: 22 });
-        expect(normal.tier).toBe("normal");
-        expect(normal.defaultIndex).toBe(1);
-        // boundary: step === 15 → still early
-        expect(planLoopCapAskcard({ stepNumber: 15 }).tier).toBe("early");
-        // step === 16 → normal
-        expect(planLoopCapAskcard({ stepNumber: 16 }).tier).toBe("normal");
-        // step === 0 → normal (no early credit for nothing)
-        expect(planLoopCapAskcard({ stepNumber: 0 }).tier).toBe("normal");
-    });
-    it("treats naturalCeiling=0 the same as undefined (no multiplier possible)", () => {
-        const r = planLoopCapAskcard({ stepNumber: 30, naturalCeiling: 0 });
-        expect(r.overageMultiplier).toBeNull();
-        expect(r.tier).toBe("normal");
-    });
-});
-//# sourceMappingURL=tool-loop-askcard.test.js.map

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

@@ -1 +0,0 @@
-export {};

package/dist/src/orchestrator/tool-loop-cap.test.js

@@ -1,176 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { createToolLoopCapPredicate, DEFAULT_TOOL_LOOP_BUMP } from "./tool-loop-cap.js";
-function steps(n) {
-    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) {
-    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, commands) {
-        const verdicts = [];
-        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,
-        }));
-    });
-});
-//# sourceMappingURL=tool-loop-cap.test.js.map

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

@@ -1 +0,0 @@
-export {};