muonroi-cli 1.3.4 → 1.4.1

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

@@ -0,0 +1,176 @@
+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.d.ts

@@ -0,0 +1,64 @@
+/**
+ * src/orchestrator/tool-repetition-detector.ts
+ *
+ * Detects when the assistant emits the SAME failing tool call repeatedly —
+ * the malformed-JSON loop observed in session 080fe2fcbf24 (2026-05-26):
+ * Qwen3-30B emitted `grep` with `"pattern": "catch\\s*\\{\\s*\\},` (missing
+ * closing quote) four times in a row. Each retry re-sent the full context;
+ * SiliconFlow returned 429 TPM rate-limit on the 5th attempt and the session
+ * crashed with 0 useful output.
+ *
+ * Why the existing repetition-detector.ts doesn't cover this: that detector
+ * tracks the leading PHRASE of assistant text bursts. When the model emits a
+ * pure tool call (no text), recordAssistantBurst is a no-op by design — so a
+ * tool-only perseveration never increments the run counter.
+ *
+ * Trigger: after TRIGGER_RUN_LENGTH consecutive identical (toolName, argsHash)
+ * tool-error rows, shouldAbortToolRepetition() returns true. The orchestrator
+ * yields a terminal error chunk and ends the generator. Without this the
+ * model would keep retrying until TPM exhaustion.
+ *
+ * State lives on `globalThis.__muonroiToolRepetitionState: Map<sessionId, …>`
+ * — same pattern as repetition-detector.ts, survives prepareStep, resets
+ * between CLI processes.
+ */
+export interface ToolRepetitionState {
+    /** sha1(toolName + JSON.stringify(input)) — same call signature. */
+    lastCallKey: string | null;
+    /** sha1 of last error message (truncated to 200 chars). */
+    lastErrorKey: string | null;
+    /** Consecutive failures with this exact (callKey, errorKey) pair. */
+    runLength: number;
+    /** True once shouldAbort has fired for the current run. */
+    abortFired: boolean;
+}
+declare function hashInput(input: unknown): string;
+declare function hashError(errorMsg: string): string;
+/**
+ * Record a tool error for `sessionId`. Returns the updated run length and
+ * whether the orchestrator should abort the streaming loop.
+ *
+ * Sessions with null/empty sessionId no-op (treated as a single fresh call).
+ */
+export declare function recordToolError(sessionId: string | null | undefined, toolName: string, input: unknown, errorMsg: string): {
+    runLength: number;
+    shouldAbort: boolean;
+};
+/**
+ * Called whenever a tool SUCCEEDS or a different tool is called. Resets the
+ * counter so a sequence of [bad-grep, bad-grep, successful-read_file] does
+ * not accumulate toward the next bad-grep.
+ */
+export declare function recordToolSuccess(sessionId: string | null | undefined): void;
+/**
+ * Build the user-visible terminal message when the abort fires.
+ */
+export declare function buildToolRepetitionAbortMessage(toolName: string, runLength: number, errorPreview: string): string;
+/** Test helper — clear all session state. */
+export declare function _resetForTests(): void;
+export declare const _internals: {
+    TRIGGER_RUN_LENGTH: number;
+    hashInput: typeof hashInput;
+    hashError: typeof hashError;
+};
+export {};

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

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

package/dist/src/orchestrator/tool-repetition-detector.test.js

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

package/dist/src/orchestrator/turn-runner-deps.d.ts

@@ -43,5 +43,7 @@ export interface TurnRunnerDepsBase {
         outputTokens?: number;
         cacheReadTokens?: number;
         cacheCreationTokens?: number;
-    } | undefined, source?: UsageSource, model?: string): void;
+    } | undefined, source?: UsageSource, model?: string, 
+    /** O1 — providerOptions shape of this call, threaded per event (see Agent.recordUsage). */
+    providerOptionsShape?: string | null): void;
 }

package/dist/src/pil/__tests__/clarity-gate.test.d.ts

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

package/dist/src/pil/__tests__/clarity-gate.test.js

@@ -0,0 +1,228 @@
+import { describe, expect, it } from "vitest";
+import { canInferOutcome, countFileReferences, hasExplicitScope, hasExternalInfoScope, hasImageScope, hasOperationalScope, hasSelfContainedComputationScope, hasWholeRepoScope, shouldAutoPass, } from "../clarity-gate.js";
+describe("hasWholeRepoScope()", () => {
+    it("detects whole-repo / whole-project intent (EN + VI)", () => {
+        // The repo-eval prompt that fired a nonsensical "which part?" askcard.
+        expect(hasWholeRepoScope("đánh giá repo muonroi-cli này: điểm mạnh, điểm yếu")).toBe(true);
+        expect(hasWholeRepoScope("evaluate the repo: strengths and weaknesses")).toBe(true);
+        expect(hasWholeRepoScope("review the whole codebase")).toBe(true);
+        expect(hasWholeRepoScope("audit the entire project")).toBe(true);
+        expect(hasWholeRepoScope("phân tích toàn bộ dự án")).toBe(true);
+        expect(hasWholeRepoScope("give me an overview of the repository")).toBe(true);
+        // summarize/overview verbs (gap found in the deepseek session probe: "tóm tắt
+        // repo này" still fired the scope askcard because the verb list lacked it).
+        expect(hasWholeRepoScope("tóm tắt nhanh repo này")).toBe(true);
+        expect(hasWholeRepoScope("summarize the repository")).toBe(true);
+        expect(hasWholeRepoScope("give me a summary of the project")).toBe(true);
+    });
+    it("does NOT fire on summarize/review of a narrow target", () => {
+        expect(hasWholeRepoScope("summarize the login function")).toBe(false);
+        expect(hasWholeRepoScope("tóm tắt hàm xử lý auth")).toBe(false);
+    });
+    it("does NOT fire on narrow tasks that merely mention a repo/project", () => {
+        // "this repo" without a wholeness/eval signal must still be scoped.
+        expect(hasWholeRepoScope("add a logout button to this repo")).toBe(false);
+        expect(hasWholeRepoScope("fix the login bug in the project")).toBe(false);
+        expect(hasWholeRepoScope("implement the search feature")).toBe(false);
+        expect(hasWholeRepoScope("refactor the auth module")).toBe(false);
+    });
+    it("whole-repo scope no longer blocks auto-pass (was: scope-gap → false)", () => {
+        // With an inferable outcome (explicit goal), the ONLY remaining blocker for a
+        // repo-wide prompt was the scope gap. hasWholeRepoScope clears it.
+        const prompt = "review the entire codebase — goal: a report of strengths and weaknesses";
+        expect(shouldAutoPass({ confidence: 0.9, taskType: "analyze", complexity: "low" }, prompt)).toBe(true);
+        // Control: same shape but NOT repo-wide still fails on the scope gap.
+        const narrow = "review the system — goal: a report of strengths and weaknesses";
+        expect(shouldAutoPass({ confidence: 0.9, taskType: "analyze", complexity: "low" }, narrow)).toBe(false);
+    });
+});
+describe("hasSelfContainedComputationScope()", () => {
+    it("detects an inline-data computation prompt (the operand is in the prompt, not the codebase)", () => {
+        // Live drive (deepseek-vs-grok A/B, session probe 2026-06-05): "Compute
+        // f([3,1,2]) where f sorts the list ascending then returns the sum of the
+        // first two elements." classified taskType=analyze (regex:read matched the
+        // bare word "list") fired the codebase-scope askcard "Which part of the
+        // codebase should this target?" — nonsensical for a self-contained math
+        // problem whose input data is supplied inline. Symmetric to image/web/
+        // operational scope guards.
+        expect(hasSelfContainedComputationScope("Compute f([3,1,2]) where f sorts the list ascending then returns the sum of the first two elements.")).toBe(true);
+        expect(hasSelfContainedComputationScope("Given the array [5, 2, 8, 1, 9], what is the second largest element?")).toBe(true);
+        expect(hasSelfContainedComputationScope("What is the median of [10, 4, 7]?")).toBe(true);
+        expect(hasSelfContainedComputationScope('Reverse the list ["a", "b", "c"] and return it.')).toBe(true);
+    });
+    it("does NOT fire without an inline data literal", () => {
+        // The framing verb alone is not enough — a codebase task can say "compute"
+        // ("compute the hash in the auth module"). Only an inline operand qualifies.
+        expect(hasSelfContainedComputationScope("compute the cache key in the auth module")).toBe(false);
+        expect(hasSelfContainedComputationScope("sort the users table by created_at")).toBe(false);
+        expect(hasSelfContainedComputationScope("what is the second largest element of the array")).toBe(false);
+    });
+    it("does NOT fire on a real codebase task that merely contains an array literal (no compute framing)", () => {
+        // Narrowness guard: the literal alone is not enough. A feature/debug task
+        // that embeds a literal but is scoped to the codebase must KEEP its scope
+        // askcard. Requires BOTH an inline literal AND computation framing.
+        expect(hasSelfContainedComputationScope("add the items [1, 2, 3] to the cart in the checkout flow")).toBe(false);
+        expect(hasSelfContainedComputationScope("fix the bug where parseRange([1, 5]) returns the wrong values")).toBe(false);
+        expect(hasSelfContainedComputationScope("set the default retry delays to [100, 200, 400] in the config")).toBe(false);
+    });
+    it("does NOT fire on bracketed file-name lists (those are codebase-scoped)", () => {
+        // [a.ts, b.ts] is a list of files, not data — must stay codebase-scoped.
+        expect(hasSelfContainedComputationScope("compare the exports of [auth.ts, session.ts]")).toBe(false);
+    });
+    it("self-contained computation no longer blocks auto-pass (was: scope-gap → false)", () => {
+        // With an inferable outcome ("return the result"), the ONLY remaining blocker
+        // for an inline-data computation prompt was the scope gap.
+        // hasSelfContainedComputationScope clears it.
+        const prompt = "Compute the sum of the first two sorted elements of [3, 1, 2] and return the result.";
+        expect(shouldAutoPass({ confidence: 0.9, taskType: "analyze", complexity: "low" }, prompt)).toBe(true);
+        // Control: same outcome-inferable shape but NO inline literal still fails on
+        // the scope gap (a real codebase computation must still be scoped).
+        const codeTask = "Compute the largest element of the users array and return it.";
+        expect(shouldAutoPass({ confidence: 0.9, taskType: "analyze", complexity: "low" }, codeTask)).toBe(false);
+    });
+});
+describe("canInferOutcome()", () => {
+    it("returns false for null taskType", () => {
+        expect(canInferOutcome(null, "do something")).toBe(false);
+    });
+    it("returns false for general taskType", () => {
+        expect(canInferOutcome("general", "fix stuff")).toBe(false);
+    });
+    it("returns true for a general taskType that is a direct imperative command", () => {
+        // A direct command has a self-evident outcome (it runs / it shows), so it
+        // should auto-pass instead of triggering an outcome-clarification askcard.
+        expect(canInferOutcome("general", "run the test suite")).toBe(true);
+        expect(canInferOutcome("general", "echo harness-ok")).toBe(true);
+        expect(canInferOutcome("general", "show the package.json scripts")).toBe(true);
+        expect(canInferOutcome("general", "list the open ports")).toBe(true);
+    });
+    it("returns false for a general imperative verb with no object", () => {
+        expect(canInferOutcome("general", "run")).toBe(false);
+        expect(canInferOutcome("general", "execute   ")).toBe(false);
+    });
+    it("returns false for a general non-imperative prompt", () => {
+        expect(canInferOutcome("general", "the build is slow")).toBe(false);
+    });
+    it("returns true when prompt has error reference", () => {
+        expect(canInferOutcome("debug", "fix the TypeError in login")).toBe(true);
+    });
+    it("returns true when prompt has file:line reference", () => {
+        expect(canInferOutcome("debug", "fix auth.ts:42")).toBe(true);
+    });
+    it("returns true when prompt has target state verb", () => {
+        expect(canInferOutcome("refactor", "should return a Promise")).toBe(true);
+    });
+    it("returns true when prompt has add pattern", () => {
+        expect(canInferOutcome("generate", "add validation to login form")).toBe(true);
+    });
+    it("returns false for vague prompt with valid taskType", () => {
+        expect(canInferOutcome("debug", "fix auth")).toBe(false);
+    });
+});
+describe("countFileReferences()", () => {
+    it("counts .ts and .tsx files", () => {
+        expect(countFileReferences("fix login.ts and dashboard.tsx")).toBe(2);
+    });
+    it("returns 0 for no file refs", () => {
+        expect(countFileReferences("fix the auth module")).toBe(0);
+    });
+    it("ignores non-code extensions", () => {
+        expect(countFileReferences("see report.pdf")).toBe(0);
+    });
+});
+describe("hasExplicitScope()", () => {
+    it("detects src/ paths", () => {
+        expect(hasExplicitScope("refactor src/auth/jwt.ts")).toBe(true);
+    });
+    it("detects lib/ paths", () => {
+        expect(hasExplicitScope("update lib/utils")).toBe(true);
+    });
+    it("returns false for no path", () => {
+        expect(hasExplicitScope("refactor the code")).toBe(false);
+    });
+});
+describe("shouldAutoPass()", () => {
+    it("auto-passes high-confidence + specific file + inferrable outcome", () => {
+        expect(shouldAutoPass({ confidence: 0.9, taskType: "debug", complexity: "low" }, "fix TypeError in src/auth/login.ts:42")).toBe(true);
+    });
+    it("rejects low confidence", () => {
+        expect(shouldAutoPass({ confidence: 0.6, taskType: "debug", complexity: "low" }, "fix TypeError in login.ts:42")).toBe(false);
+    });
+    it("rejects vague prompt despite high confidence", () => {
+        expect(shouldAutoPass({ confidence: 0.9, taskType: "debug", complexity: "low" }, "fix auth")).toBe(false);
+    });
+    it("rejects high complexity", () => {
+        expect(shouldAutoPass({ confidence: 0.9, taskType: "refactor", complexity: "high" }, "refactor src/auth/login.ts should return Promise")).toBe(false);
+    });
+    it("auto-passes with explicit scope path even without file extension", () => {
+        expect(shouldAutoPass({ confidence: 0.9, taskType: "refactor", complexity: "medium" }, "refactor src/auth/ module to return Promises")).toBe(true);
+    });
+    // PIL-L6 fix
+    it("auto-passes CI/build debug task even without file path (operational scope)", () => {
+        expect(shouldAutoPass({ confidence: 0.9, taskType: "debug", complexity: "low" }, "fix the ci fail — goal: green pipeline")).toBe(true);
+    });
+    // Image-scope fix — an image-analysis task is scoped to the image, not a file
+    // path, so it should auto-pass when its outcome is inferrable.
+    it("auto-passes an image-analysis task even without file path (image scope)", () => {
+        expect(shouldAutoPass({ confidence: 0.9, taskType: "analyze", complexity: "low" }, "analyze screenshot.png — goal: describe the layout")).toBe(true);
+    });
+    // External-info fix — a web-search task is scoped to the web, not a file path.
+    it("auto-passes a web-search task even without file path (external-info scope)", () => {
+        expect(shouldAutoPass({ confidence: 0.9, taskType: "analyze", complexity: "low" }, "search the web for the vitest release date — goal: find the version")).toBe(true);
+    });
+});
+describe("hasExternalInfoScope()", () => {
+    it("detects web-search / external-info intent", () => {
+        expect(hasExternalInfoScope("search the web for the latest vitest release notes")).toBe(true);
+        expect(hasExternalInfoScope("google the error message")).toBe(true);
+        expect(hasExternalInfoScope("what's the latest news on the framework")).toBe(true);
+        expect(hasExternalInfoScope("summarize https://example.com/post")).toBe(true);
+    });
+    it("returns false for codebase tasks, including in-repo 'search'", () => {
+        // Narrow: must NOT swallow a real code task. "search the codebase" and
+        // "search feature" are codebase work and still deserve a scope askcard.
+        expect(hasExternalInfoScope("search the codebase for usages of foo")).toBe(false);
+        expect(hasExternalInfoScope("implement the search feature")).toBe(false);
+        expect(hasExternalInfoScope("add the zod library to the auth module")).toBe(false);
+        expect(hasExternalInfoScope("refactor the login flow")).toBe(false);
+    });
+});
+describe("hasImageScope()", () => {
+    it("detects an image file extension", () => {
+        expect(hasImageScope("analyze diagram.png")).toBe(true);
+        expect(hasImageScope("describe the layout of mock.jpg")).toBe(true);
+        expect(hasImageScope("read chart.svg")).toBe(true);
+    });
+    it("detects a data:image URI and screenshot/photo nouns", () => {
+        expect(hasImageScope("here is data:image/png;base64,AAAA")).toBe(true);
+        expect(hasImageScope("take a screenshot and analyze it")).toBe(true);
+        expect(hasImageScope("look at the photo")).toBe(true);
+    });
+    it("returns false for codebase tasks and ambiguous/overloaded words", () => {
+        // Narrow on purpose: a false positive SUPPRESSES a legitimate scope
+        // question, so overloaded words must NOT match.
+        expect(hasImageScope("refactor the login flow")).toBe(false);
+        expect(hasImageScope("add a logo to the header")).toBe(false); // "logo" excluded
+        expect(hasImageScope("rebuild the docker image")).toBe(false); // bare "image" excluded
+        expect(hasImageScope("look at the bigger picture")).toBe(false); // "picture" excluded
+    });
+});
+describe("hasOperationalScope() — PIL-L6", () => {
+    it("detects ci/build/test/action keywords", () => {
+        expect(hasOperationalScope("fix ci fail")).toBe(true);
+        expect(hasOperationalScope("the build is broken")).toBe(true);
+        expect(hasOperationalScope("workflow keeps failing")).toBe(true);
+        expect(hasOperationalScope("gh check shows red")).toBe(true);
+    });
+    it("returns false for unrelated prompts", () => {
+        expect(hasOperationalScope("refactor login flow")).toBe(false);
+        expect(hasOperationalScope("explain hooks")).toBe(false);
+    });
+});
+describe("canInferOutcome() — explicit goal (PIL-L6)", () => {
+    it("returns true when prompt names an explicit goal", () => {
+        expect(canInferOutcome("debug", "goal: pipeline green")).toBe(true);
+        expect(canInferOutcome("debug", "mong muốn: tests passing")).toBe(true);
+    });
+});
+//# sourceMappingURL=clarity-gate.test.js.map

package/dist/src/pil/__tests__/config.test.js

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { isUnifiedPilEnabled } from "../config.js";
+import { getAutoPassThreshold, getMaxInterviewQuestions, isDiscoveryEnabled, isUnifiedPilEnabled } from "../config.js";
 describe("isUnifiedPilEnabled", () => {
     const orig = process.env.MUONROI_PIL_UNIFIED;
     beforeEach(() => {
@@ -27,4 +27,47 @@ describe("isUnifiedPilEnabled", () => {
         expect(isUnifiedPilEnabled()).toBe(false);
     });
 });
+describe("isDiscoveryEnabled()", () => {
+    it("returns true by default (no env)", () => {
+        delete process.env.MUONROI_PIL_DISCOVERY;
+        expect(isDiscoveryEnabled()).toBe(true);
+    });
+    it("returns false when MUONROI_PIL_DISCOVERY=0", () => {
+        process.env.MUONROI_PIL_DISCOVERY = "0";
+        expect(isDiscoveryEnabled()).toBe(false);
+        delete process.env.MUONROI_PIL_DISCOVERY;
+    });
+    it("returns true when MUONROI_PIL_DISCOVERY=1", () => {
+        process.env.MUONROI_PIL_DISCOVERY = "1";
+        expect(isDiscoveryEnabled()).toBe(true);
+        delete process.env.MUONROI_PIL_DISCOVERY;
+    });
+});
+describe("getAutoPassThreshold()", () => {
+    it("returns 0.85 by default", () => {
+        delete process.env.MUONROI_PIL_AUTOPASS_THRESHOLD;
+        expect(getAutoPassThreshold()).toBe(0.85);
+    });
+    it("respects env override in range", () => {
+        process.env.MUONROI_PIL_AUTOPASS_THRESHOLD = "0.7";
+        expect(getAutoPassThreshold()).toBe(0.7);
+        delete process.env.MUONROI_PIL_AUTOPASS_THRESHOLD;
+    });
+    it("clamps out-of-range to default", () => {
+        process.env.MUONROI_PIL_AUTOPASS_THRESHOLD = "1.5";
+        expect(getAutoPassThreshold()).toBe(0.85);
+        delete process.env.MUONROI_PIL_AUTOPASS_THRESHOLD;
+    });
+});
+describe("getMaxInterviewQuestions()", () => {
+    it("returns 3 by default", () => {
+        delete process.env.MUONROI_PIL_MAX_QUESTIONS;
+        expect(getMaxInterviewQuestions()).toBe(3);
+    });
+    it("respects valid override", () => {
+        process.env.MUONROI_PIL_MAX_QUESTIONS = "2";
+        expect(getMaxInterviewQuestions()).toBe(2);
+        delete process.env.MUONROI_PIL_MAX_QUESTIONS;
+    });
+});
 //# sourceMappingURL=config.test.js.map

package/dist/src/pil/__tests__/discovery-cache.test.d.ts

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