muonroi-cli 1.4.0 → 1.4.1

package/src/orchestrator/tool-utils.ts

@@ -1,214 +0,0 @@
-import type { Plan, ToolCall, ToolResult } from "../types/index";
-import type { ProcessMessageFinishReason, ProcessMessageUsage } from "./agent-options";
-import { asNumber } from "./batch-utils";
-
-export function toToolCall(part: { toolCallId: string; toolName: string; args?: unknown; input?: unknown }): ToolCall {
-  return {
-    id: part.toolCallId,
-    type: "function",
-    function: {
-      name: part.toolName,
-      arguments: JSON.stringify(part.input ?? part.args ?? {}),
-    },
-  };
-}
-
-export function toToolResult(output: unknown): ToolResult {
-  if (output && typeof output === "object" && "success" in output) {
-    const r = output as {
-      success: boolean;
-      output?: string;
-      error?: string;
-      diff?: ToolResult["diff"];
-      plan?: Plan;
-      task?: ToolResult["task"];
-      delegation?: ToolResult["delegation"];
-      backgroundProcess?: ToolResult["backgroundProcess"];
-      media?: ToolResult["media"];
-      computer?: ToolResult["computer"];
-      lspDiagnostics?: ToolResult["lspDiagnostics"];
-    };
-    return {
-      success: r.success,
-      output: r.output,
-      error: r.error ?? (r.success ? undefined : r.output),
-      diff: r.diff,
-      plan: r.plan,
-      task: r.task,
-      delegation: r.delegation,
-      backgroundProcess: r.backgroundProcess,
-      media: r.media,
-      computer: r.computer,
-      lspDiagnostics: r.lspDiagnostics,
-    };
-  }
-  return { success: true, output: String(output) };
-}
-
-export function formatSubagentActivity(toolName: string, args?: unknown): string {
-  const parsed = parseToolArgs(args);
-  if (toolName === "read_file") return `Read ${parsed.path || "file"}`;
-  if (toolName === "lsp") return `LSP ${parsed.operation || "query"} ${parsed.filePath || ""}`.trim();
-  if (toolName === "write_file") return `Write ${parsed.path || "file"}`;
-  if (toolName === "edit_file") return `Edit ${parsed.path || "file"}`;
-  if (toolName === "search_web") return `Web search "${truncate(parsed.query || "", 50)}"`;
-  if (toolName === "search_x") return `X search "${truncate(parsed.query || "", 50)}"`;
-  if (toolName === "generate_image") return `Generate image "${truncate(parsed.prompt || "", 50)}"`;
-  if (toolName === "generate_video") return `Generate video "${truncate(parsed.prompt || "", 50)}"`;
-  if (toolName === "computer_snapshot") return `Snapshot ${parsed.app || "desktop"}`;
-  if (toolName === "computer_screenshot") return "Capture desktop screenshot";
-  if (toolName === "computer_click")
-    return parsed.ref ? `Click ${parsed.ref}` : `Click at ${parsed.x || "?"},${parsed.y || "?"}`;
-  if (toolName === "computer_mouse_move")
-    return parsed.ref ? `Hover ${parsed.ref}` : `Move mouse to ${parsed.x || "?"},${parsed.y || "?"}`;
-  if (toolName === "computer_type") return `Type into ${parsed.ref || "element"}`;
-  if (toolName === "computer_press") return `Press ${parsed.key || "key"}`;
-  if (toolName === "computer_scroll") return `Scroll ${parsed.ref || "element"} ${parsed.direction || "down"}`;
-  if (toolName === "computer_launch") return `Launch ${parsed.app || "app"}`;
-  if (toolName === "computer_list_windows") return `List windows${parsed.app ? ` for ${parsed.app}` : ""}`;
-  if (toolName === "computer_focus_window")
-    return `Focus window ${parsed.window_id || parsed.title || parsed.app || ""}`.trim();
-  if (toolName === "computer_wait") return "Wait for desktop state";
-  if (toolName === "computer_get") return `Read ${parsed.property || "text"} from ${parsed.ref || "element"}`;
-  if (toolName === "bash") return truncate(parsed.command || "Run command", 70);
-  return truncate(`${toolName}`, 70);
-}
-
-export function parseToolArgs(args: unknown): Record<string, string> {
-  if (!args || typeof args !== "object") return {};
-  const result: Record<string, string> = {};
-  for (const [key, value] of Object.entries(args)) {
-    result[key] = typeof value === "string" ? value : JSON.stringify(value);
-  }
-  return result;
-}
-
-export function firstLine(text: string): string {
-  return text.trim().split("\n").find(Boolean)?.trim() || "Task completed.";
-}
-
-export function truncate(text: string, max: number): string {
-  return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
-}
-
-export function notifyObserver<T>(listener: ((payload: T) => void) | undefined, payload: T): void {
-  if (!listener) {
-    return;
-  }
-
-  try {
-    listener(payload);
-  } catch {
-    // Observer failures should never break generation.
-  }
-}
-
-export function combineAbortSignals(...signals: Array<AbortSignal | undefined>): AbortSignal | undefined {
-  const activeSignals = signals.filter((signal): signal is AbortSignal => Boolean(signal));
-  if (activeSignals.length === 0) return undefined;
-  if (activeSignals.length === 1) return activeSignals[0];
-
-  if (typeof AbortSignal.any === "function") {
-    return AbortSignal.any(activeSignals);
-  }
-
-  const controller = new AbortController();
-  for (const signal of activeSignals) {
-    if (signal.aborted) {
-      controller.abort();
-      break;
-    }
-
-    signal.addEventListener("abort", () => controller.abort(), { once: true });
-  }
-
-  return controller.signal;
-}
-
-export function getStepNumber(event: unknown, fallback: number): number {
-  if (event && typeof event === "object" && "stepNumber" in event && typeof event.stepNumber === "number") {
-    return event.stepNumber;
-  }
-  return fallback;
-}
-
-export function getFinishReason(event: unknown): ProcessMessageFinishReason {
-  if (event && typeof event === "object" && "finishReason" in event) {
-    switch (event.finishReason) {
-      case "stop":
-      case "length":
-      case "content-filter":
-      case "tool-calls":
-      case "error":
-      case "other":
-        return event.finishReason;
-    }
-  }
-  return "other";
-}
-
-/**
- * Normalize a streamText `onStepFinish` / `onFinish` event into ProcessMessageUsage.
- *
- * Reads cache metrics from THREE possible locations (in priority order):
- *   1. `event.usage.cachedInputTokens` / `event.usage.inputTokenDetails.*` — AI SDK
- *      v6 standardized fields (set by `@ai-sdk/anthropic`, `@ai-sdk/openai`).
- *   2. `event.providerMetadata.<provider>.*` — provider-specific surface emitted
- *      by `@ai-sdk/deepseek` as `{ deepseek: { promptCacheHitTokens, promptCacheMissTokens } }`
- *      and by `@ai-sdk/openai` as `{ openai: { cachedPromptTokens } }`.
- *   3. `event.usage.raw.*` — legacy escape hatch for raw provider response fields
- *      (`prompt_cache_hit_tokens`, `cache_creation_input_tokens`). Kept for batch
- *      compat with `getBatchUsage`.
- *
- * Phase C1 fix: previously this only read (1) and (3). DeepSeek goes through
- * `@ai-sdk/openai-compatible`, which does NOT populate `usage.raw` AND does NOT
- * populate the standardized fields — its cache metrics live in (2) under the
- * provider id. Without reading providerMetadata, every DeepSeek request recorded
- * `cache_read_tokens=0` even when the API charged the cached-input price, which
- * is what `usage forensics` flagged as "zero cache_creation across deepseek route".
- */
-export function getUsage(event: unknown): ProcessMessageUsage {
-  if (!(event && typeof event === "object")) {
-    return {};
-  }
-  const evt = event as Record<string, unknown>;
-  const usage = evt.usage;
-  if (!usage || typeof usage !== "object") {
-    return {};
-  }
-  const u = usage as Record<string, unknown>;
-  const details = u.inputTokenDetails as Record<string, unknown> | undefined;
-  const raw = u.raw as Record<string, unknown> | undefined;
-
-  // providerMetadata sits on the event, not inside usage. Pull each known
-  // provider bucket separately so a future provider addition is one new const.
-  const pm = evt.providerMetadata as Record<string, unknown> | undefined;
-  const deepseekMeta = pm?.deepseek as Record<string, unknown> | undefined;
-  const openaiMeta = pm?.openai as Record<string, unknown> | undefined;
-
-  // Cache reads: standardized field → deepseek meta → openai meta → raw passthrough.
-  const cacheRead =
-    asNumber(u.cachedInputTokens) ??
-    asNumber(details?.cacheReadTokens) ??
-    asNumber(deepseekMeta?.promptCacheHitTokens) ??
-    asNumber(openaiMeta?.cachedPromptTokens) ??
-    asNumber(raw?.prompt_cache_hit_tokens);
-
-  // Cache writes: only Anthropic exposes this today. DeepSeek's on-disk cache
-  // is write-only-server-side (no charged write), so leaving this undefined for
-  // DeepSeek is correct — do NOT zero-fill (that would mask provider regressions).
-  const cacheCreation = asNumber(details?.cacheWriteTokens) ?? asNumber(raw?.cache_creation_input_tokens);
-
-  // Non-cached input split. DeepSeek reports it directly; for others we leave
-  // undefined and let downstream derive it.
-  const noCacheInput = asNumber(deepseekMeta?.promptCacheMissTokens) ?? asNumber(raw?.prompt_cache_miss_tokens);
-
-  return {
-    inputTokens: typeof u.inputTokens === "number" ? u.inputTokens : undefined,
-    outputTokens: typeof u.outputTokens === "number" ? u.outputTokens : undefined,
-    totalTokens: typeof u.totalTokens === "number" ? u.totalTokens : undefined,
-    cacheReadTokens: cacheRead ?? undefined,
-    cacheCreationTokens: cacheCreation ?? undefined,
-    noCacheInputTokens: noCacheInput ?? undefined,
-  };
-}

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

@@ -1,85 +0,0 @@
-// TurnRunnerDepsBase — shared dependency surface extracted from
-// `MessageProcessorDeps` (Phase 12.4) and `BatchTurnRunnerDeps` (Phase 12.5).
-//
-// Both turn-runner modules need the same minimum proxy onto Agent state for
-// compaction, task delegation, and turn bookkeeping. Hoisting that overlap
-// here lets both interfaces declare the relationship explicitly via
-// `interface X extends TurnRunnerDepsBase` instead of duplicating the
-// property list.
-//
-// Pure type module — no runtime code. Adding a member here requires bumping
-// every concrete deps implementation in orchestrator.ts; removing one only
-// affects the concrete implementations that still rely on it.
-
-import type { ModelMessage } from "ai";
-import type { BashTool } from "../tools/bash";
-import type { AgentMode, TaskRequest, ToolResult, UsageSource } from "../types/index";
-import type { LegacyProvider } from "./agent-options";
-import type { CompactionSettings } from "./compaction";
-
-/**
- * Shared base for turn-runner deps surfaces.
- *
- * Holds the properties that are identical across `MessageProcessorDeps`
- * (streaming path) and `BatchTurnRunnerDeps` (batch-API path):
- *   - Read-only state references the turn loop touches
- *   - Compaction delegators (per-turn + post-turn)
- *   - Task/delegation tool callbacks
- *   - Turn bookkeeping (append/discard/recordUsage)
- *   - Common scalar getters/setters (compactedThisTurn, providerOptionsShape)
- *
- * Path-specific members (PIL, hooks, council, batch client, etc.) stay on
- * the concrete deps interfaces.
- */
-export interface TurnRunnerDepsBase {
-  // ---- Read-only state references ---------------------------------------
-  /** Live messages array (mutated by push). */
-  readonly messages: ModelMessage[];
-  readonly bash: BashTool;
-  readonly mode: AgentMode;
-  readonly maxToolRounds: number;
-  readonly schedules: import("../tools/schedule").ScheduleManager;
-  readonly sendTelegramFile: ((filePath: string) => Promise<ToolResult>) | null;
-
-  // ---- Scalar getters / setters -----------------------------------------
-  getCompactedThisTurn(): boolean;
-  setCompactedThisTurn(v: boolean): void;
-  setLastProviderOptionsShape(shape: string | null): void;
-
-  // ---- Compaction behavior delegators -----------------------------------
-  getCompactionSettings(contextWindow?: number): CompactionSettings;
-  compactForContext(
-    provider: LegacyProvider,
-    system: string,
-    contextWindow: number,
-    signal: AbortSignal,
-    settings?: CompactionSettings,
-    overflow?: boolean,
-  ): Promise<boolean>;
-  postTurnCompact(provider: LegacyProvider, system: string, contextWindow: number, signal: AbortSignal): Promise<void>;
-
-  // ---- Task / delegation tool callbacks ---------------------------------
-  runTask(request: TaskRequest, signal?: AbortSignal): Promise<ToolResult>;
-  runDelegation(request: TaskRequest, signal?: AbortSignal): Promise<ToolResult>;
-  readDelegation(id: string): Promise<ToolResult>;
-  listDelegations(): Promise<ToolResult>;
-
-  // ---- Turn bookkeeping --------------------------------------------------
-  appendCompletedTurn(userMessage: ModelMessage, assistantMessages: ModelMessage[]): void;
-  discardAbortedTurn(userMessage: ModelMessage): void;
-  recordUsage(
-    usage:
-      | {
-          totalTokens?: number;
-          inputTokens?: number;
-          outputTokens?: number;
-          cacheReadTokens?: number;
-          cacheCreationTokens?: number;
-        }
-      | undefined,
-    source?: UsageSource,
-    model?: string,
-    /** O1 — providerOptions shape of this call, threaded per event (see Agent.recordUsage). */
-    providerOptionsShape?: string | null,
-  ): void;
-}

package/src/pil/__tests__/budget.test.ts

@@ -1,39 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { DEFAULT_TOKEN_BUDGET, truncateToBudget } from "../budget";
-
-describe("truncateToBudget", () => {
-  it("allows ~4 chars per token of budget", () => {
-    const text = "a".repeat(400);
-    const result = truncateToBudget(text, 100);
-    expect(result).toBe(text);
-  });
-
-  it("truncates text exceeding budget in token-equivalent chars", () => {
-    const text = "a".repeat(500);
-    const result = truncateToBudget(text, 100);
-    expect(result.length).toBeLessThanOrEqual(404);
-  });
-
-  it("returns short text unchanged", () => {
-    expect(truncateToBudget("hello world", 100)).toBe("hello world");
-  });
-
-  it("truncates at word boundary when possible", () => {
-    const text = "word ".repeat(120);
-    const result = truncateToBudget(text, 100);
-    expect(result.endsWith("...")).toBe(true);
-    expect(result.length).toBeLessThanOrEqual(404);
-  });
-
-  it("handles empty string", () => {
-    expect(truncateToBudget("", 100)).toBe("");
-  });
-
-  it("handles budget=0 by truncating everything", () => {
-    expect(truncateToBudget("hello", 0)).toBe("...");
-  });
-
-  it("DEFAULT_TOKEN_BUDGET is 500", () => {
-    expect(DEFAULT_TOKEN_BUDGET).toBe(500);
-  });
-});

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

@@ -1,299 +0,0 @@
-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);
-  });
-});