muonroi-cli 1.7.2 → 1.8.1

package/dist/src/ui/utils/text.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { stripStrayModelMacros } from "./text.js";
+import { stripInvisibleChars, stripStrayModelMacros } from "./text.js";
 describe("stripStrayModelMacros", () => {
     it("strips a trailing \\confidence{NN} macro and the blank line before it", () => {
         const input = "Root cause: parseInt radix.\n\nFix: use radix 10.\n\n\\confidence{85}";
@@ -20,4 +20,28 @@ describe("stripStrayModelMacros", () => {
         expect(stripStrayModelMacros("")).toBe("");
     });
 });
+describe("stripInvisibleChars", () => {
+    it("strips zero-width spaces (U+200B)", () => {
+        expect(stripInvisibleChars("hello\u200Bworld")).toBe("helloworld");
+    });
+    it("strips soft hyphen (U+00AD)", () => {
+        expect(stripInvisibleChars("hy\u00ADphen")).toBe("hyphen");
+    });
+    it("strips BOM (U+FEFF)", () => {
+        expect(stripInvisibleChars("\uFEFFHello")).toBe("Hello");
+    });
+    it("strips BiDi overrides (U+202E)", () => {
+        expect(stripInvisibleChars("abc\u202Edef")).toBe("abcdef");
+    });
+    it("strips C0 controls except \\t \\n \\r", () => {
+        expect(stripInvisibleChars("a\u0001b\rc\td")).toBe("ab\rc\td");
+    });
+    it("keeps normal text unchanged (fast path)", () => {
+        const normal = "Hello world, how are you?";
+        expect(stripInvisibleChars(normal)).toBe(normal);
+    });
+    it("handles empty string", () => {
+        expect(stripInvisibleChars("")).toBe("");
+    });
+});
 //# sourceMappingURL=text.test.js.map

package/dist/src/ui/utils/tools.js

@@ -27,7 +27,9 @@ export function toolArgs(tc) {
     try {
         const a = JSON.parse(tc.function.arguments);
         if (tc.function.name === "bash")
-            return String(a.command || "").replace(/\n/g, " ").trim();
+            return String(a.command || "")
+                .replace(/\n/g, " ")
+                .trim();
         if (tc.function.name === "read_file" || tc.function.name === "write_file" || tc.function.name === "edit_file")
             return String(a.file_path || a.path || "");
         if (describeMcpFsTool(tc.function.name)) {

package/dist/src/usage/cost-log.js

@@ -14,7 +14,7 @@
 import { promises as fs } from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { projectCostUSD } from "./estimator.js";
+import { projectCostUSD, sanitizeInputTokens } from "./estimator.js";
 function muonroiHome(homeOverride) {
     return homeOverride ?? process.env.MUONROI_CLI_HOME ?? path.join(os.homedir(), ".muonroi-cli");
 }
@@ -57,7 +57,7 @@ export async function meteredGenerate(args, fn) {
     const startedAt = Date.now();
     try {
         const { result, actualInputTokens, actualOutputTokens, cachedInputTokens, stepCount } = await fn();
-        const inTok = actualInputTokens ?? estIn;
+        const inTok = sanitizeInputTokens(actualInputTokens, estIn);
         const outTok = actualOutputTokens ?? Math.max(1, Math.ceil(estOut / 4));
         const usd = projectCostUSD(args.provider, args.model, inTok, outTok);
         await appendCostLog({

package/dist/src/usage/estimator.d.ts

@@ -10,6 +10,20 @@
  * Acceptable for cap projection only -- not for billing reconciliation.
  */
 export declare function estimateTokensFromChars(chars: number): number;
+/**
+ * Sanitize an actual input-token count by comparing it to the estimated
+ * (chars/4) count. Some providers (SiliconFlow, possibly others) return
+ * implausibly low `prompt_tokens` (e.g. 10) regardless of actual prompt size,
+ * which under-reports cost and inflates apparent cache-hit ratios.
+ *
+ * Rules:
+ *   - When `actual === undefined`: return `estimated` (no data = use estimate).
+ *   - When `actual === 0`: return 0 (preserve mock / failed-call semantics).
+ *   - When `estimated > 0` and `actual < estimated * 0.1`: the value is likely
+ *     bogus — return `estimated` so cost projections stay accurate.
+ *   - Otherwise: return `actual` as-is.
+ */
+export declare function sanitizeInputTokens(actual: number | undefined, estimated: number): number;
 /**
  * Project the USD cost of a request given token estimates and the static pricing table.
  * Returns 0 for unknown provider/model -- caller decides how to handle (ledger treats as 0 risk).

package/dist/src/usage/estimator.js

@@ -13,6 +13,28 @@ import { lookupPricing } from "../providers/pricing.js";
 export function estimateTokensFromChars(chars) {
     return Math.ceil(chars / 4);
 }
+/**
+ * Sanitize an actual input-token count by comparing it to the estimated
+ * (chars/4) count. Some providers (SiliconFlow, possibly others) return
+ * implausibly low `prompt_tokens` (e.g. 10) regardless of actual prompt size,
+ * which under-reports cost and inflates apparent cache-hit ratios.
+ *
+ * Rules:
+ *   - When `actual === undefined`: return `estimated` (no data = use estimate).
+ *   - When `actual === 0`: return 0 (preserve mock / failed-call semantics).
+ *   - When `estimated > 0` and `actual < estimated * 0.1`: the value is likely
+ *     bogus — return `estimated` so cost projections stay accurate.
+ *   - Otherwise: return `actual` as-is.
+ */
+export function sanitizeInputTokens(actual, estimated) {
+    if (actual === undefined)
+        return estimated;
+    if (actual === 0)
+        return 0;
+    if (estimated > 0 && actual < estimated * 0.1)
+        return estimated;
+    return actual;
+}
 /**
  * Project the USD cost of a request given token estimates and the static pricing table.
  * Returns 0 for unknown provider/model -- caller decides how to handle (ledger treats as 0 risk).

package/dist/src/utils/__tests__/compaction-caps.test.d.ts

@@ -0,0 +1,21 @@
+/**
+ * src/utils/__tests__/compaction-caps.test.ts
+ *
+ * G4 regression guard for the token-thrift compaction caps.
+ *
+ * The compaction caps themselves are wired correctly (cost-leak-b3/b4 specs
+ * cover the algorithm; the *-tui specs cover the live wiring). The hole this
+ * file closes is DRIFT: nothing pinned the PRODUCTION DEFAULT knob values, and
+ * the fast cost-leak specs drive `compactSubAgentMessages` with HARDCODED
+ * options (thresholdChars: 60_000, keepLastTurns: 1) that are decoupled from
+ * the real getters. So a regression that widens a default (e.g. reverting the
+ * Phase C5 40_000 back to 200_000, or fat-fingering a clamp range) would sail
+ * past the entire fast suite and only be caught by the slow ~30-120s TUI specs.
+ *
+ * Part 1 pins each getter's documented contract (default / clamp / honor).
+ * Part 2 feeds the REAL getter outputs into the compactor over a synthetic
+ * load sized BETWEEN the default threshold and a plausible widened drift, so a
+ * default-value regression fails behaviourally too — not just at the value
+ * assertion.
+ */
+export {};

package/dist/src/utils/__tests__/compaction-caps.test.js

@@ -0,0 +1,187 @@
+/**
+ * src/utils/__tests__/compaction-caps.test.ts
+ *
+ * G4 regression guard for the token-thrift compaction caps.
+ *
+ * The compaction caps themselves are wired correctly (cost-leak-b3/b4 specs
+ * cover the algorithm; the *-tui specs cover the live wiring). The hole this
+ * file closes is DRIFT: nothing pinned the PRODUCTION DEFAULT knob values, and
+ * the fast cost-leak specs drive `compactSubAgentMessages` with HARDCODED
+ * options (thresholdChars: 60_000, keepLastTurns: 1) that are decoupled from
+ * the real getters. So a regression that widens a default (e.g. reverting the
+ * Phase C5 40_000 back to 200_000, or fat-fingering a clamp range) would sail
+ * past the entire fast suite and only be caught by the slow ~30-120s TUI specs.
+ *
+ * Part 1 pins each getter's documented contract (default / clamp / honor).
+ * Part 2 feeds the REAL getter outputs into the compactor over a synthetic
+ * load sized BETWEEN the default threshold and a plausible widened drift, so a
+ * default-value regression fails behaviourally too — not just at the value
+ * assertion.
+ */
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { compactSubAgentMessages, cumulativeMessageChars } from "../../orchestrator/subagent-compactor.js";
+import { getSubAgentBudgetChars, getSubAgentCompactKeepLast, getSubAgentCompactThresholdChars, getTopLevelCompactKeepLast, getTopLevelCompactThresholdChars, getTopLevelToolBudgetChars, loadUserSettings, } from "../settings.js";
+const ENV_KEYS = [
+    "MUONROI_SUB_AGENT_BUDGET_CHARS",
+    "MUONROI_SUBAGENT_COMPACT_THRESHOLD_CHARS",
+    "MUONROI_SUBAGENT_COMPACT_KEEP_LAST",
+    "MUONROI_TOP_LEVEL_COMPACT_THRESHOLD_CHARS",
+    "MUONROI_TOP_LEVEL_COMPACT_KEEP_LAST",
+    "MUONROI_TOP_LEVEL_TOOL_BUDGET_CHARS",
+];
+const saved = {};
+beforeEach(() => {
+    for (const k of ENV_KEYS) {
+        saved[k] = process.env[k];
+        delete process.env[k];
+    }
+});
+afterEach(() => {
+    for (const k of ENV_KEYS) {
+        if (saved[k] === undefined)
+            delete process.env[k];
+        else
+            process.env[k] = saved[k];
+    }
+});
+describe("compaction cap getters — production contract (G4 drift guard)", () => {
+    describe("compact thresholds & keepLast (Phase C5 defaults — no user-settings layer)", () => {
+        it("return the documented defaults when env is unset", () => {
+            expect(getSubAgentCompactThresholdChars()).toBe(40_000);
+            expect(getSubAgentCompactKeepLast()).toBe(3);
+            expect(getTopLevelCompactThresholdChars()).toBe(100_000);
+            expect(getTopLevelCompactKeepLast()).toBe(5);
+        });
+        it("clamp out-of-range env back to the default", () => {
+            process.env.MUONROI_SUBAGENT_COMPACT_THRESHOLD_CHARS = "999999999"; // > 500_000
+            expect(getSubAgentCompactThresholdChars()).toBe(40_000);
+            process.env.MUONROI_SUBAGENT_COMPACT_THRESHOLD_CHARS = "1000"; // < 20_000
+            expect(getSubAgentCompactThresholdChars()).toBe(40_000);
+            process.env.MUONROI_SUBAGENT_COMPACT_KEEP_LAST = "0"; // < 1
+            expect(getSubAgentCompactKeepLast()).toBe(3);
+            process.env.MUONROI_SUBAGENT_COMPACT_KEEP_LAST = "99"; // > 20
+            expect(getSubAgentCompactKeepLast()).toBe(3);
+            process.env.MUONROI_TOP_LEVEL_COMPACT_THRESHOLD_CHARS = "10000"; // < 50_000
+            expect(getTopLevelCompactThresholdChars()).toBe(100_000);
+            process.env.MUONROI_TOP_LEVEL_COMPACT_KEEP_LAST = "99"; // > 30
+            expect(getTopLevelCompactKeepLast()).toBe(5);
+        });
+        it("honor valid in-range env overrides", () => {
+            process.env.MUONROI_SUBAGENT_COMPACT_THRESHOLD_CHARS = "60000";
+            expect(getSubAgentCompactThresholdChars()).toBe(60_000);
+            process.env.MUONROI_SUBAGENT_COMPACT_KEEP_LAST = "5";
+            expect(getSubAgentCompactKeepLast()).toBe(5);
+            process.env.MUONROI_TOP_LEVEL_COMPACT_THRESHOLD_CHARS = "250000";
+            expect(getTopLevelCompactThresholdChars()).toBe(250_000);
+            process.env.MUONROI_TOP_LEVEL_COMPACT_KEEP_LAST = "8";
+            expect(getTopLevelCompactKeepLast()).toBe(8);
+        });
+    });
+    describe("budget getters (env override → user-settings → default)", () => {
+        it("getSubAgentBudgetChars: default 240_000 when env unset and no user override", () => {
+            // Deterministic on a clean checkout / CI (no user-settings.json). When a
+            // dev machine HAS an explicit override the getter must honor it instead —
+            // the default-drift case is what CI guards.
+            const override = loadUserSettings().subAgentBudgetChars;
+            if (typeof override === "number" && override >= 20_000 && override <= 5_000_000) {
+                expect(getSubAgentBudgetChars()).toBe(Math.floor(override));
+            }
+            else {
+                expect(getSubAgentBudgetChars()).toBe(240_000);
+            }
+        });
+        it("getTopLevelToolBudgetChars: default 400_000 when env unset and no user override", () => {
+            const override = loadUserSettings().topLevelToolBudgetChars;
+            if (typeof override === "number" && override >= 50_000 && override <= 10_000_000) {
+                expect(getTopLevelToolBudgetChars()).toBe(Math.floor(override));
+            }
+            else {
+                expect(getTopLevelToolBudgetChars()).toBe(400_000);
+            }
+        });
+        it("honor valid in-range env overrides (env short-circuits user-settings)", () => {
+            process.env.MUONROI_SUB_AGENT_BUDGET_CHARS = "300000";
+            expect(getSubAgentBudgetChars()).toBe(300_000);
+            process.env.MUONROI_TOP_LEVEL_TOOL_BUDGET_CHARS = "800000";
+            expect(getTopLevelToolBudgetChars()).toBe(800_000);
+        });
+        it("reject out-of-range env (result stays within the documented range)", () => {
+            process.env.MUONROI_SUB_AGENT_BUDGET_CHARS = "999999999"; // > 5_000_000
+            const sub = getSubAgentBudgetChars();
+            expect(sub).not.toBe(999_999_999);
+            expect(sub).toBeGreaterThanOrEqual(20_000);
+            expect(sub).toBeLessThanOrEqual(5_000_000);
+            process.env.MUONROI_TOP_LEVEL_TOOL_BUDGET_CHARS = "1000"; // < 50_000
+            const top = getTopLevelToolBudgetChars();
+            expect(top).not.toBe(1000);
+            expect(top).toBeGreaterThanOrEqual(50_000);
+            expect(top).toBeLessThanOrEqual(10_000_000);
+        });
+    });
+});
+/**
+ * Build N tool turns (assistant tool-call + tool result), each result
+ * `resultChars` long, using a tool name that is NOT high-value (so the
+ * compactor is allowed to elide it). Mirrors the cost-leak-b3 message shape.
+ */
+function buildToolTurns(n, resultChars) {
+    const msgs = [
+        { role: "system", content: "You are the Explore sub-agent." },
+        { role: "user", content: "trace auth wiring" },
+    ];
+    for (let i = 0; i < n; i++) {
+        const id = `c${i}`;
+        msgs.push({
+            role: "assistant",
+            content: [{ type: "tool-call", toolCallId: id, toolName: "fake_read", input: { path: `/tmp/${id}.txt` } }],
+        });
+        msgs.push({
+            role: "tool",
+            content: [
+                {
+                    type: "tool-result",
+                    toolCallId: id,
+                    toolName: "fake_read",
+                    output: { type: "text", value: "x".repeat(resultChars) },
+                },
+            ],
+        });
+    }
+    return msgs;
+}
+describe("compaction fires with the REAL default getter values (G4 behavioural guard)", () => {
+    // Load sized BETWEEN the default thresholds (40K sub / 100K top) and a
+    // plausible widened drift (200K). So: with the real defaults it compacts;
+    // if a default were reverted to 200_000 the load would fall below threshold
+    // and these assertions would fail — catching drift behaviourally.
+    it("sub-agent: default threshold (40K) elides older tool results on a ~120K load", () => {
+        const messages = buildToolTurns(6, 20_000); // ~120K cumulative, 6 tool turns
+        const cumulative = cumulativeMessageChars(messages);
+        expect(cumulative).toBeGreaterThan(40_000);
+        expect(cumulative).toBeLessThan(200_000);
+        const compacted = compactSubAgentMessages(messages, {
+            thresholdChars: getSubAgentCompactThresholdChars(),
+            keepLastTurns: getSubAgentCompactKeepLast(),
+        });
+        expect(compacted).not.toBe(messages); // identity differs → compaction happened
+        const before = JSON.stringify(messages).length;
+        const after = JSON.stringify(compacted).length;
+        expect(after).toBeLessThan(before);
+        expect(JSON.stringify(compacted)).toContain("elided by sub-agent compactor");
+    });
+    it("top-level: default threshold (100K) elides older tool results on a ~160K load", () => {
+        const messages = buildToolTurns(8, 20_000); // ~160K cumulative, 8 tool turns
+        const cumulative = cumulativeMessageChars(messages);
+        expect(cumulative).toBeGreaterThan(100_000);
+        expect(cumulative).toBeLessThan(200_000);
+        const compacted = compactSubAgentMessages(messages, {
+            thresholdChars: getTopLevelCompactThresholdChars(),
+            keepLastTurns: getTopLevelCompactKeepLast(),
+            label: "top-level",
+        });
+        expect(compacted).not.toBe(messages);
+        expect(JSON.stringify(compacted).length).toBeLessThan(JSON.stringify(messages).length);
+        expect(JSON.stringify(compacted)).toContain("elided by top-level compactor");
+    });
+});
+//# sourceMappingURL=compaction-caps.test.js.map

package/dist/src/utils/__tests__/llm-deadline-abort.test.d.ts

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

package/dist/src/utils/__tests__/llm-deadline-abort.test.js

@@ -0,0 +1,33 @@
+/**
+ * withDeadlineRace abort-grace: a provider that ignores its abortSignal mid-call
+ * must not keep the caller blocked until the (minutes-long) wall-clock deadline.
+ * When the user-abort signal fires, the race rejects within a short grace window.
+ */
+import { describe, expect, it } from "vitest";
+import { withDeadlineRace } from "../llm-deadline.js";
+describe("withDeadlineRace — abort grace", () => {
+    it("rejects shortly after abort even when fn() never settles", async () => {
+        const ac = new AbortController();
+        const neverSettles = () => new Promise(() => { }); // simulates a stalled provider
+        const start = Date.now();
+        setTimeout(() => ac.abort(new Error("user pressed Esc")), 40);
+        await expect(withDeadlineRace(neverSettles, 60_000, "test", ac.signal, 80)).rejects.toThrow(/aborted by user/);
+        // Must unblock far before the 60s deadline.
+        expect(Date.now() - start).toBeLessThan(2_000);
+    });
+    it("rejects immediately when the signal is already aborted", async () => {
+        const ac = new AbortController();
+        ac.abort(new Error("already cancelled"));
+        const neverSettles = () => new Promise(() => { });
+        await expect(withDeadlineRace(neverSettles, 60_000, "test", ac.signal, 50)).rejects.toThrow(/aborted by user/);
+    });
+    it("returns the fn() result when it settles before any abort", async () => {
+        const ac = new AbortController();
+        await expect(withDeadlineRace(() => Promise.resolve("ok"), 60_000, "test", ac.signal, 80)).resolves.toBe("ok");
+    });
+    it("still enforces the wall-clock deadline when no signal is passed (back-compat)", async () => {
+        const neverSettles = () => new Promise(() => { });
+        await expect(withDeadlineRace(neverSettles, 60, "test")).rejects.toThrow(/deadline/);
+    });
+});
+//# sourceMappingURL=llm-deadline-abort.test.js.map

package/dist/src/utils/__tests__/llm-deadline.test.js

@@ -1,11 +1,23 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { withDeadlineRace, withTimeoutSignal } from "../llm-deadline.js";
+async function advanceTimersAsync(ms) {
+    if (typeof vi.advanceTimersByTimeAsync === "function") {
+        await vi.advanceTimersByTimeAsync(ms);
+    }
+    else {
+        vi.advanceTimersByTime(ms);
+        // Flush microtasks in Bun/older Node
+        for (let i = 0; i < 20; i++) {
+            await Promise.resolve();
+        }
+    }
+}
 describe("withDeadlineRace", () => {
     beforeEach(() => vi.useFakeTimers());
     afterEach(() => vi.useRealTimers());
     it("resolves with the value when fn settles before the deadline", async () => {
         const p = withDeadlineRace(async () => "ok", 1000, "test-call");
-        await vi.advanceTimersByTimeAsync(10);
+        await advanceTimersAsync(10);
         await expect(p).resolves.toBe("ok");
     });
     it("rejects with a labelled timeout error when fn exceeds the deadline", async () => {
@@ -14,7 +26,7 @@ describe("withDeadlineRace", () => {
         // of whether the underlying SDK honours its abort signal.
         const p = withDeadlineRace(() => new Promise(() => { }), 500, "plan_debate");
         const assertion = expect(p).rejects.toThrow(/plan_debate exceeded 500ms deadline/);
-        await vi.advanceTimersByTimeAsync(600);
+        await advanceTimersAsync(600);
         await assertion;
     });
 });
@@ -29,7 +41,7 @@ describe("withTimeoutSignal", () => {
     it("aborts the signal once the timeout elapses", async () => {
         const { signal } = withTimeoutSignal(undefined, 200);
         expect(signal.aborted).toBe(false);
-        await vi.advanceTimersByTimeAsync(250);
+        await advanceTimersAsync(250);
         expect(signal.aborted).toBe(true);
     });
     it("aborts immediately when the parent signal is already aborted", () => {
@@ -49,7 +61,7 @@ describe("withTimeoutSignal", () => {
     it("cleanup clears the timer so the signal never aborts afterwards", async () => {
         const { signal, cleanup } = withTimeoutSignal(undefined, 200);
         cleanup();
-        await vi.advanceTimersByTimeAsync(500);
+        await advanceTimersAsync(500);
         expect(signal.aborted).toBe(false);
     });
 });

package/dist/src/utils/__tests__/logger.test.d.ts

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

package/dist/src/utils/__tests__/logger.test.js

@@ -0,0 +1,115 @@
+import * as fs from "fs";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { logger, redactObject, redactSecrets } from "../logger.js";
+vi.mock("fs", () => ({
+    appendFileSync: vi.fn(),
+    existsSync: vi.fn(() => true),
+    mkdirSync: vi.fn(),
+}));
+function setTuiActive(active) {
+    globalThis.__muonroiTuiActive = active;
+}
+function clearTuiActive() {
+    delete globalThis.__muonroiTuiActive;
+}
+describe("logger utility", () => {
+    let logSpy;
+    let warnSpy;
+    let errorSpy;
+    beforeEach(() => {
+        logSpy = vi.spyOn(console, "log").mockImplementation(() => undefined);
+        warnSpy = vi.spyOn(console, "warn").mockImplementation(() => undefined);
+        errorSpy = vi.spyOn(console, "error").mockImplementation(() => undefined);
+        vi.mocked(fs.appendFileSync).mockClear();
+        vi.mocked(fs.existsSync).mockClear();
+        vi.mocked(fs.existsSync).mockReturnValue(true);
+        vi.mocked(fs.mkdirSync).mockClear();
+        clearTuiActive();
+    });
+    afterEach(() => {
+        logSpy.mockRestore();
+        warnSpy.mockRestore();
+        errorSpy.mockRestore();
+        clearTuiActive();
+    });
+    describe("redactSecrets", () => {
+        it("redacts openai keys", () => {
+            const msg = "sending request with key sk-proj12345678901234567890123456";
+            expect(redactSecrets(msg)).toBe("sending request with key [REDACTED_API_KEY]");
+        });
+        it("redacts google keys", () => {
+            const msg = "sending request with key AIzaSyA1B2C3D4E5F6G7H8I9J0K1L2M3N4O5P6Q";
+            expect(redactSecrets(msg)).toBe("sending request with key [REDACTED_API_KEY]");
+        });
+        it("redacts xai keys", () => {
+            const msg = "sending request with key xai-proj12345678901234567890123456";
+            expect(redactSecrets(msg)).toBe("sending request with key [REDACTED_API_KEY]");
+        });
+    });
+    describe("redactObject", () => {
+        it("redacts sensitive fields in an object recursively", () => {
+            const raw = {
+                name: "test",
+                apiKey: "sk-proj1234567890",
+                nested: {
+                    secretToken: "some-secret",
+                    plainVal: "hello",
+                },
+                arr: ["item1", "sk-proj12345678901234567890123456"],
+            };
+            const expected = {
+                name: "test",
+                apiKey: "[REDACTED]",
+                nested: {
+                    secretToken: "[REDACTED]",
+                    plainVal: "hello",
+                },
+                arr: ["item1", "[REDACTED_API_KEY]"],
+            };
+            expect(redactObject(raw)).toEqual(expected);
+        });
+    });
+    describe("logger functionality in CLI mode", () => {
+        it("logs info messages to console.log", () => {
+            logger.info("cli", "test message", { val: 42 });
+            expect(logSpy).toHaveBeenCalledTimes(1);
+            const callArg = logSpy.mock.calls[0][0];
+            expect(callArg).toContain("[INFO]");
+            expect(callArg).toContain("[CLI]");
+            expect(callArg).toContain("test message");
+            expect(callArg).toContain('{"val":42}');
+        });
+        it("logs warn messages to console.warn", () => {
+            logger.warn("orchestrator", "warning message");
+            expect(warnSpy).toHaveBeenCalledTimes(1);
+            const callArg = warnSpy.mock.calls[0][0];
+            expect(callArg).toContain("[WARN]");
+            expect(callArg).toContain("[ORCHESTRATOR]");
+            expect(callArg).toContain("warning message");
+        });
+        it("logs error messages to console.error", () => {
+            logger.error("storage", "error message");
+            expect(errorSpy).toHaveBeenCalledTimes(1);
+            const callArg = errorSpy.mock.calls[0][0];
+            expect(callArg).toContain("[ERROR]");
+            expect(callArg).toContain("[STORAGE]");
+            expect(callArg).toContain("error message");
+        });
+    });
+    describe("logger functionality in TUI mode", () => {
+        it("does not log to console, but appends to debug.log", () => {
+            setTuiActive(true);
+            logger.info("ui", "render component", { id: "main" });
+            expect(logSpy).not.toHaveBeenCalled();
+            expect(fs.appendFileSync).toHaveBeenCalledTimes(1);
+            const filePath = vi.mocked(fs.appendFileSync).mock.calls[0][0];
+            const logContent = vi.mocked(fs.appendFileSync).mock.calls[0][1];
+            expect(filePath).toContain("debug.log");
+            expect(logContent).toContain("[INFO]");
+            expect(logContent).toContain("[UI]");
+            expect(logContent).toContain("render component");
+            expect(logContent).toContain('{"id":"main"}');
+        });
+    });
+});
+//# sourceMappingURL=logger.test.js.map

package/dist/src/utils/__tests__/settings-agent-first.test.d.ts

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

package/dist/src/utils/__tests__/settings-agent-first.test.js

@@ -0,0 +1,48 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+describe("UserSettings.agentFirst", () => {
+    const tmpHome = path.join(os.tmpdir(), `muonroi-cli-agentfirst-${process.pid}-${Date.now()}`);
+    const origHome = process.env.HOME;
+    const origUserProfile = process.env.USERPROFILE;
+    let saveUserSettings;
+    let loadUserSettings;
+    beforeEach(async () => {
+        fs.mkdirSync(tmpHome, { recursive: true });
+        process.env.HOME = tmpHome;
+        process.env.USERPROFILE = tmpHome;
+        vi.resetModules();
+        const mod = await import("../settings.js");
+        saveUserSettings = mod.saveUserSettings;
+        loadUserSettings = mod.loadUserSettings;
+        const settingsPath = path.join(tmpHome, ".muonroi-cli", "user-settings.json");
+        if (fs.existsSync(settingsPath))
+            fs.rmSync(settingsPath, { force: true });
+    });
+    afterEach(() => {
+        fs.rmSync(tmpHome, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
+        if (origHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = origHome;
+        if (origUserProfile === undefined)
+            delete process.env.USERPROFILE;
+        else
+            process.env.USERPROFILE = origUserProfile;
+    });
+    it("persists agentFirst, maxToolRounds, hardMaxToolRounds, maxLlmCallsPerTurn", () => {
+        saveUserSettings({
+            agentFirst: true,
+            maxToolRounds: 150,
+            hardMaxToolRounds: 250,
+            maxLlmCallsPerTurn: 80,
+        });
+        const loaded = loadUserSettings();
+        expect(loaded.agentFirst).toBe(true);
+        expect(loaded.maxToolRounds).toBe(150);
+        expect(loaded.hardMaxToolRounds).toBe(250);
+        expect(loaded.maxLlmCallsPerTurn).toBe(80);
+    });
+});
+//# sourceMappingURL=settings-agent-first.test.js.map

package/dist/src/utils/install-manager.d.ts

@@ -49,6 +49,7 @@ export declare function getReleaseTargetForPlatform(platform?: NodeJS.Platform,
 export declare function loadScriptInstallMetadata(homeDir?: string): ScriptInstallMetadata | null;
 export declare function saveScriptInstallMetadata(metadata: ScriptInstallMetadata, homeDir?: string): void;
 export declare function getScriptInstallContext(homeDir?: string): ScriptInstallContext | null;
+export declare function fetchLatestGitTag(gitDir: string): Promise<string | null>;
 export declare function fetchLatestReleaseVersion(): Promise<string | null>;
 export declare function parseChecksumsFile(contents: string): Map<string, string>;
 /**