muonroi-cli 1.8.1 → 1.8.4

package/dist/src/orchestrator/text-tool-call-detector.test.js

@@ -1,147 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { detectTextEmittedToolCall, parseDsmlToolCalls } from "./text-tool-call-detector.js";
-describe("detectTextEmittedToolCall", () => {
-    it("detects the Cline/Roo <read_file><path> dialect (live deepseek failure)", () => {
-        // Verbatim shape from storyflow_ui A/B session 905d564dbde4: after a
-        // destructive edit, deepseek emitted this as plain assistant text to
-        // re-read the file — the CLI returned it as the final answer and the turn
-        // was silently wasted with a broken file left behind.
-        const text = `Let me restore the file properly.
-
-<read_file>
-<path>src/app/screens/story-list/story-list.component.html</path>
-</read_file>`;
-        const r = detectTextEmittedToolCall(text);
-        expect(r.detected).toBe(true);
-        expect(r.tool).toBe("read_file");
-    });
-    it("detects write_to_file / execute_command / apply_diff blocks", () => {
-        expect(detectTextEmittedToolCall("<write_to_file>\n<path>a.ts</path>\n<content>x</content>\n</write_to_file>").detected).toBe(true);
-        expect(detectTextEmittedToolCall("<execute_command>\n<command>npm test</command>\n</execute_command>").detected).toBe(true);
-        expect(detectTextEmittedToolCall("<apply_diff>\n<path>a.ts</path>\n<diff>...</diff>\n</apply_diff>").detected).toBe(true);
-    });
-    it("detects an empty-but-closed tool block (open immediately closed)", () => {
-        expect(detectTextEmittedToolCall("here:\n<read_file></read_file>").detected).toBe(true);
-    });
-    it("detects builtin tool names emitted as text (<bash>, <grep>) — live deepseek <bash> leak", () => {
-        const r = detectTextEmittedToolCall("Starting:\n<bash>\nfind /workspace -name '*.html'\n</bash>");
-        expect(r.detected).toBe(true);
-        expect(r.tool).toBe("bash");
-        expect(detectTextEmittedToolCall("<grep>\n<pattern>foo</pattern>\n</grep>").detected).toBe(true);
-        expect(detectTextEmittedToolCall("<delegate>\n<agent>explore</agent>\n</delegate>").detected).toBe(true);
-    });
-    it("does NOT fire on a bare inline mention of bash (no invocation shape)", () => {
-        expect(detectTextEmittedToolCall("Run the build with the <bash> tool to verify.").detected).toBe(false);
-        expect(detectTextEmittedToolCall("I used bash to run the tests; they pass.").detected).toBe(false);
-    });
-    it("detects generic native wrappers (Qwen <tool_call>, Anthropic <invoke name=>)", () => {
-        expect(detectTextEmittedToolCall('<tool_call>{"name":"read_file"}</tool_call>').detected).toBe(true);
-        expect(detectTextEmittedToolCall('<invoke name="read_file"><parameter name="path">a</parameter></invoke>').detected).toBe(true);
-        expect(detectTextEmittedToolCall("<function_calls>...").detected).toBe(true);
-    });
-    it("detects the DeepSeek-native DSML leak (│invoke …) and extracts the tool name", () => {
-        // Live: storyflow_ui explore-A/B, deepseek T3 (session 799f0508e830) emitted
-        // this as text and made no real tool call → empty, silent turn. The generic
-        // <invoke matcher misses it because `<` is followed by the U+FF5C sentinel.
-        const text = `<│tool_calls>
-<│invoke name="read_file">
-<│parameter name="file_path" string="true">src/app/foo.html</│parameter>
-</│invoke>
-</│tool_calls>`;
-        const r = detectTextEmittedToolCall(text);
-        expect(r.detected).toBe(true);
-        expect(r.tool).toBe("read_file");
-    });
-    it("detects the newer DeepSeek DSML format with │ DSML │ sentinel (2026-06-23+ leak)", () => {
-        // Newer DSML format where the model inserts "DSML" text between bars:
-        //   <│ DSML │invoke name="read_file">...</│ DSML │invoke>
-        const text = `<│tool_calls>
-<│ DSML │invoke name="read_file">
-<│ DSML │parameter name="file_path" string="true">D:\\sources\\Core\\muonroi-cli\\biome.json</│ DSML │parameter>
-</│ DSML │invoke>
-</│tool_calls>`;
-        const r = detectTextEmittedToolCall(text);
-        expect(r.detected).toBe(true);
-        expect(r.tool).toBe("read_file");
-    });
-    it("detects the double-bar DeepSeek DSML format with ｜｜ sentinel", () => {
-        const text = `<｜｜DSML｜｜tool_calls>
-<｜｜DSML｜｜invoke name="read_file">
-<｜｜DSML｜｜parameter name="file_path" string="true">src/app/foo.html</｜｜DSML｜｜parameter>
-</｜｜DSML｜｜invoke>
-</｜｜DSML｜｜tool_calls>`;
-        const r = detectTextEmittedToolCall(text);
-        expect(r.detected).toBe(true);
-        expect(r.tool).toBe("read_file");
-    });
-    it("parses double-bar DSML blocks with ｜｜ DSML ｜｜ sentinel format", () => {
-        const text = `<｜｜DSML｜｜invoke name="read_file">
-<｜｜DSML｜｜parameter name="file_path" string="true">src/app/foo.html</｜｜DSML｜｜parameter>
-</｜｜DSML｜｜invoke>`;
-        const calls = parseDsmlToolCalls(text);
-        expect(calls).toHaveLength(1);
-        expect(calls[0].name).toBe("read_file");
-        expect(calls[0].args.file_path).toBe("src/app/foo.html");
-    });
-    it("parses DSML blocks with │ DSML │ sentinel format", () => {
-        const text = `<│ DSML │invoke name="read_file">
-<│ DSML │parameter name="file_path" string="true">src/app.ts</│ DSML │parameter>
-</│ DSML │invoke>`;
-        const calls = parseDsmlToolCalls(text);
-        expect(calls).toHaveLength(1);
-        expect(calls[0].name).toBe("read_file");
-        expect(calls[0].args.file_path).toBe("src/app.ts");
-    });
-    it("does NOT fire on a bare inline mention of a tool name (no invocation shape)", () => {
-        // Precision: a prose mention must not be flagged — it would wrongly mark a
-        // legitimate final answer as a broken tool call.
-        expect(detectTextEmittedToolCall("Use the <read_file> tool to view the source.").detected).toBe(false);
-        expect(detectTextEmittedToolCall("The read_file and edit_file tools handle this.").detected).toBe(false);
-        expect(detectTextEmittedToolCall("I edited the file and ran the tests; everything passes.").detected).toBe(false);
-    });
-    it("parseDsmlToolCalls extracts name + args from the DSML block (for targeted re-steer)", () => {
-        const text = `<│tool_calls>
-<│invoke name="read_file">
-<│parameter name="file_path" string="true">src/app/foo.html</│parameter>
-<│parameter name="start_line" string="false">25</│parameter>
-</│invoke>
-</│tool_calls>`;
-        const calls = parseDsmlToolCalls(text);
-        expect(calls).toHaveLength(1);
-        expect(calls[0].name).toBe("read_file");
-        expect(calls[0].args.file_path).toBe("src/app/foo.html");
-        expect(calls[0].args.start_line).toBe("25");
-    });
-    it("parseDsmlToolCalls handles multiple invoke blocks and returns [] for non-DSML text", () => {
-        const text = `<│invoke name="read_file"><│parameter name="file_path">a.ts</│parameter></│invoke><│invoke name="edit_file"><│parameter name="path">b.ts</│parameter></│invoke>`;
-        const calls = parseDsmlToolCalls(text);
-        expect(calls.map((c) => c.name)).toEqual(["read_file", "edit_file"]);
-        expect(parseDsmlToolCalls("just a normal answer")).toEqual([]);
-    });
-    it("does NOT fire on ordinary prose / code answers", () => {
-        expect(detectTextEmittedToolCall("Final number: 16").detected).toBe(false);
-        expect(detectTextEmittedToolCall("```ts\nconst a = readFile(path);\n```").detected).toBe(false);
-        expect(detectTextEmittedToolCall("").detected).toBe(false);
-        // Angular template with self-closing/nested tags must not match a tool tag.
-        expect(detectTextEmittedToolCall('<span *ngIf="!story.cover" class="placeholder">{{ title }}</span>').detected).toBe(false);
-    });
-    it("detects and parses Gemini-style ASCII DSML leak with spaces and standard pipes", () => {
-        const text = `Tôi cần xác nhận ecosystem có những extension gì trước khi sửa - không đoán, phải đọc source thật.
-
-< | | DSML | | tool_calls>
-< | | DSML | | invoke name="mcp_filesystem__search_files">
-< | | DSML | | parameter name="pattern" string="true">Serilog</ | | DSML | | parameter>
-< | | DSML | | parameter name="path" string="true">D:\\sources\\Core\\muonroi-building-block\\src</ | | DSML | | parameter>
-</ | | DSML | | invoke>
-</ | | DSML | | tool_calls>`;
-        const r = detectTextEmittedToolCall(text);
-        expect(r.detected).toBe(true);
-        expect(r.tool).toBe("mcp_filesystem__search_files");
-        const calls = parseDsmlToolCalls(text);
-        expect(calls).toHaveLength(1);
-        expect(calls[0].name).toBe("mcp_filesystem__search_files");
-        expect(calls[0].args.pattern).toBe("Serilog");
-        expect(calls[0].args.path).toBe("D:\\sources\\Core\\muonroi-building-block\\src");
-    });
-});
-//# sourceMappingURL=text-tool-call-detector.test.js.map

package/dist/src/orchestrator/token-counter.test.d.ts

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

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 {};