muonroi-cli 1.7.1 → 1.8.0

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

@@ -20,22 +20,28 @@ import { spawn } from "node:child_process";
  * `process.argv[0]` itself. We sanitize the WHOLE args portion in one pass.
  */
 export function sanitizeArgvForResume(args, sessionId) {
-    if (!sessionId || !sessionId.trim()) {
+    if (!sessionId?.trim()) {
         throw new Error("sanitizeArgvForResume: sessionId is required");
     }
     const out = [];
     for (let i = 0; i < args.length; i++) {
         const a = args[i];
-        if (a === "-s" || a === "--session") {
+        if (a === "-s" || a === "--session" || a === "--mock-llm") {
             // skip the flag AND its value (if present and not another flag)
             const next = args[i + 1];
             if (next !== undefined && !next.startsWith("-"))
                 i++;
             continue;
         }
-        if (a.startsWith("--session=")) {
+        if (a.startsWith("--session=") || a.startsWith("--mock-llm=")) {
             continue; // skip the combined form
         }
+        // Transient launch-mode flags must NOT survive a resume — re-entering
+        // agent-mode (named-pipe transport) on a user-driven resume strands the
+        // child with no harness server. Drop them.
+        if (a === "--agent-mode") {
+            continue;
+        }
         out.push(a);
     }
     out.push("--session", sessionId);
@@ -60,12 +66,30 @@ export function relaunchWithSession(sessionId, opts = {}) {
     const exit = opts.onExit ?? ((code) => process.exit(code));
     const spawnImpl = opts.spawnFn ?? spawn;
     const args = sanitizeArgvForResume(argv.slice(1), sessionId);
+    // Tear down the current TUI and restore the terminal BEFORE spawning so the
+    // child inherits a clean TTY (no raw mode / mouse tracking / alt-screen).
+    if (opts.beforeSpawn) {
+        try {
+            opts.beforeSpawn();
+        }
+        catch (err) {
+            console.error(`[relaunch] beforeSpawn teardown failed: ${err?.message ?? err}`);
+        }
+    }
     const child = spawnImpl(exec, args, { stdio: "inherit", detached: false });
     child.once("error", (err) => {
         console.error(`[relaunch] spawn failed: ${err?.message ?? err}`);
         exit(1);
     });
-    // Hand the TTY to the child and exit cleanly. The child takes over rendering.
+    if (opts.supervise) {
+        // Stay alive until the child exits so any intermediate launcher (bun run
+        // wrapper / bin shim) keeps the terminal foreground for the child instead
+        // of letting the shell reclaim it mid-restart.
+        child.once("exit", (code) => exit(code ?? 0));
+        return;
+    }
+    // Legacy fast-handoff: exit the instant the child spawns. Correct only when
+    // there is no intervening launcher waiting on this process.
     child.once("spawn", () => exit(0));
 }
 //# sourceMappingURL=relaunch.js.map

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

@@ -40,6 +40,24 @@ describe("sanitizeArgvForResume", () => {
         expect(() => sanitizeArgvForResume([], "")).toThrow(/sessionId is required/);
         expect(() => sanitizeArgvForResume([], "  ")).toThrow(/sessionId is required/);
     });
+    it("strips transient launch-mode flags (--agent-mode) so resume does not re-enter agent-mode", () => {
+        expect(sanitizeArgvForResume(["--agent-mode", "-m", "grok-build-0.1"], "new-id")).toEqual([
+            "-m",
+            "grok-build-0.1",
+            "--session",
+            "new-id",
+        ]);
+    });
+    it("strips `--mock-llm <dir>` and the combined form", () => {
+        expect(sanitizeArgvForResume(["--mock-llm", "/fix/dir", "-y"], "new-id")).toEqual(["-y", "--session", "new-id"]);
+        expect(sanitizeArgvForResume(["--mock-llm=/fix/dir", "-y"], "new-id")).toEqual(["-y", "--session", "new-id"]);
+    });
+    it("strips agent-mode + mock-llm together (harness-launched resume → clean user CLI)", () => {
+        expect(sanitizeArgvForResume(["--agent-mode", "--mock-llm", "/fx", "--session", "old"], "new")).toEqual([
+            "--session",
+            "new",
+        ]);
+    });
 });
 describe("relaunchWithSession", () => {
     it("spawns the same executable with the sanitized argv + session id, then exits 0", () => {
@@ -72,6 +90,38 @@ describe("relaunchWithSession", () => {
         expect(errMock).toHaveBeenCalled();
         errMock.mockRestore();
     });
+    it("runs beforeSpawn teardown before spawning", () => {
+        const calls = [];
+        const child = new EventEmitter();
+        const spawnMock = vi.fn(() => {
+            calls.push("spawn");
+            return child;
+        });
+        relaunchWithSession("sess", {
+            argv: ["/bin/bun", "src/index.ts"],
+            onExit: () => { },
+            spawnFn: spawnMock,
+            beforeSpawn: () => calls.push("teardown"),
+        });
+        expect(calls).toEqual(["teardown", "spawn"]);
+    });
+    it("supervise: stays alive until the child exits, then propagates the exit code", () => {
+        const exitMock = vi.fn();
+        const child = new EventEmitter();
+        const spawnMock = vi.fn(() => child);
+        relaunchWithSession("sess", {
+            argv: ["/bin/bun", "src/index.ts"],
+            onExit: exitMock,
+            spawnFn: spawnMock,
+            supervise: true,
+        });
+        // Does NOT exit on spawn when supervising.
+        child.emit("spawn");
+        expect(exitMock).not.toHaveBeenCalled();
+        // Exits with the child's code when the child finally exits.
+        child.emit("exit", 3);
+        expect(exitMock).toHaveBeenCalledWith(3);
+    });
     it("throws when argv[0] is missing (cannot relaunch without an executable)", () => {
         expect(() => relaunchWithSession("sess", {
             argv: [],

package/dist/src/ui/utils/text.d.ts

@@ -1,4 +1,15 @@
 export declare function formatTokenCount(tokens: number): string;
+/**
+ * Strip invisible/control Unicode characters that leak into terminal output.
+ * Keeps \t \n \r (needed for rendering); removes everything else that most
+ * terminals cannot display safely: zero-width spaces, soft hyphens, BiDi
+ * overrides, C0/C1 controls, BOM, and other default-ignorable code points.
+ * Fast-pathed: returns the input unchanged when no match is found.
+ *
+ * Uses `new RegExp()` to avoid Biome's `noControlCharactersInRegex` lint
+ * (control-char escapes in a regex literal are blocked).
+ */
+export declare function stripInvisibleChars(text: string): string;
 export declare function trunc(s: string, n: number): string;
 export declare function truncateLine(s: string, n: number): string;
 export declare function truncateBlock(text: string, maxLines: number): string;

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

@@ -5,6 +5,26 @@ export function formatTokenCount(tokens) {
         return `${Math.round(tokens / 1_000)}K`;
     return String(tokens);
 }
+/**
+ * Strip invisible/control Unicode characters that leak into terminal output.
+ * Keeps \t \n \r (needed for rendering); removes everything else that most
+ * terminals cannot display safely: zero-width spaces, soft hyphens, BiDi
+ * overrides, C0/C1 controls, BOM, and other default-ignorable code points.
+ * Fast-pathed: returns the input unchanged when no match is found.
+ *
+ * Uses `new RegExp()` to avoid Biome's `noControlCharactersInRegex` lint
+ * (control-char escapes in a regex literal are blocked).
+ */
+export function stripInvisibleChars(text) {
+    if (!text)
+        return text;
+    // Constructed via new RegExp to bypass Biome lint for control-char patterns.
+    // U+034F (Combining Grapheme Joiner) is separated via alternation per
+    // Biome's noMisleadingCharacterClass rule.
+    const re = new RegExp("[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F\u00AD\u061C\u070F\u200B-\u200F\u2028-\u202F\u2060-\u2069\uFEFF\uFFF9-\uFFFB]|" +
+        "\u034F|\u{1BCA0}-\u{1BCA3}|\u{E0001}|\u{E0020}-\u{E007F}", "gu");
+    return re.test(text) ? text.replace(re, "") : text;
+}
 export function trunc(s, n) {
     const str = String(s ?? "");
     return str.length <= n ? str : `${str.slice(0, n)}…`;
@@ -37,7 +57,7 @@ export function sanitizeContent(raw) {
  * answer (e.g. `\frac{a}{b}`) is untouched. Fast-pathed: no work when absent.
  */
 export function stripStrayModelMacros(text) {
-    if (!text || !text.includes("\\confidence"))
+    if (!text?.includes("\\confidence"))
         return text;
     // Trailing form (most common) — also swallow the whitespace/newline before it.
     let out = text.replace(/\s*\\confidence\s*\{[^}]*\}\s*$/i, "");

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 120_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 <= 600_000) {
+                expect(getSubAgentBudgetChars()).toBe(Math.floor(override));
+            }
+            else {
+                expect(getSubAgentBudgetChars()).toBe(120_000);
+            }
+        });
+        it("getTopLevelToolBudgetChars: default 200_000 when env unset and no user override", () => {
+            const override = loadUserSettings().topLevelToolBudgetChars;
+            if (typeof override === "number" && override >= 50_000 && override <= 1_500_000) {
+                expect(getTopLevelToolBudgetChars()).toBe(Math.floor(override));
+            }
+            else {
+                expect(getTopLevelToolBudgetChars()).toBe(200_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"; // > 600_000
+            const sub = getSubAgentBudgetChars();
+            expect(sub).not.toBe(999_999_999);
+            expect(sub).toBeGreaterThanOrEqual(20_000);
+            expect(sub).toBeLessThanOrEqual(600_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(1_500_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/clipboard-image.js

@@ -25,24 +25,24 @@ function readWin32() {
     try {
         const escaped = tmpFile.replace(/\\/g, "\\\\");
         // Run in STA thread with retry — clipboard can be locked by other processes
-        const ps = `
-      Add-Type -AssemblyName System.Windows.Forms
-      Add-Type -AssemblyName System.Drawing
-      $maxRetries = 3
-      $img = $null
-      for ($i = 0; $i -lt $maxRetries; $i++) {
-        try {
-          $img = [System.Windows.Forms.Clipboard]::GetImage()
-          if ($img -ne $null) { break }
-        } catch {
-          # clipboard locked — wait and retry
-        }
-        Start-Sleep -Milliseconds 100
-      }
-      if ($img -ne $null) {
-        $img.Save('${escaped}', [System.Drawing.Imaging.ImageFormat]::Png)
-        $img.Dispose()
-      }
+        const ps = `
+      Add-Type -AssemblyName System.Windows.Forms
+      Add-Type -AssemblyName System.Drawing
+      $maxRetries = 3
+      $img = $null
+      for ($i = 0; $i -lt $maxRetries; $i++) {
+        try {
+          $img = [System.Windows.Forms.Clipboard]::GetImage()
+          if ($img -ne $null) { break }
+        } catch {
+          # clipboard locked — wait and retry
+        }
+        Start-Sleep -Milliseconds 100
+      }
+      if ($img -ne $null) {
+        $img.Save('${escaped}', [System.Drawing.Imaging.ImageFormat]::Png)
+        $img.Dispose()
+      }
     `;
         const result = spawnSync("powershell", ["-NoProfile", "-STA", "-Command", ps], { timeout: 8000 });
         if (result.error || result.status !== 0)
@@ -81,11 +81,11 @@ function readDarwin() {
         const pngpaste = spawnSync("pngpaste", [tmpFile], { timeout: 5000 });
         if (pngpaste.status !== 0) {
             spawnSync("screencapture", ["-c", "-x"]);
-            const osascript = `
-        set imgData to the clipboard as «class PNGf»
-        set f to open for access POSIX file "${tmpFile}" with write permission
-        write imgData to f
-        close access f
+            const osascript = `
+        set imgData to the clipboard as «class PNGf»
+        set f to open for access POSIX file "${tmpFile}" with write permission
+        write imgData to f
+        close access f
       `;
             spawnSync("osascript", ["-e", osascript], { timeout: 5000 });
         }

package/dist/src/utils/llm-deadline.d.ts

@@ -41,4 +41,12 @@ export declare function withTimeoutSignal(parent: AbortSignal | undefined, timeo
  * still be aborted via `withTimeoutSignal` for cleanup; this layer just ensures
  * the caller is never blocked past the deadline.
  */
-export declare function withDeadlineRace<T>(fn: () => Promise<T>, deadlineMs: number, label: string): Promise<T>;
+export declare function withDeadlineRace<T>(fn: () => Promise<T>, deadlineMs: number, label: string, 
+/**
+ * User-abort signal. When it fires, the race rejects within `abortGraceMs`
+ * even if `fn()` hasn't settled — so a provider that ignores its abortSignal
+ * mid-call (observed with DeepSeek/grok socket stalls) can't keep the caller
+ * (and, for council, the locked composer) blocked until the full `deadlineMs`.
+ * The short grace lets the normal fetch-level abort win first when it's quick.
+ */
+abortSignal?: AbortSignal, abortGraceMs?: number): Promise<T>;