muonroi-cli 1.4.0 → 1.4.1

package/src/pil/cheap-model-playbook.ts

@@ -1,153 +0,0 @@
-/**
- * src/pil/cheap-model-playbook.ts
- *
- * Tier-aware behavioural prelude PREPENDED to the system prompt for budget
- * models. Smart models (sonnet, gpt-5, etc.) make these decisions correctly
- * on their own — the playbook only fires when `modelInfo.tier === "fast"`.
- *
- * Why prepend (not append)? Live-session forensics on session 622fdeb8f658
- * (DeepSeek V4 Flash, ~8K system prompt) showed the original append-at-end
- * placement let attention decay before the rules registered: model emitted
- * `bunx vitest run | tail -40` despite the rule saying not to pipe. Primacy
- * effect — putting the rules FIRST, behind a CRITICAL marker — is a real
- * fix, not a workaround.
- *
- * The wording also changed: the previous rule 1 said "NEVER re-run with
- * different pipe flags". Cheap models rationalized that the first call
- * isn't a re-run, so the rule didn't apply. Rule 1 now applies to EVERY
- * bash call where output might need to be queried — including the first.
- *
- * Escape hatch: `MUONROI_DISABLE_CHEAP_MODEL_PLAYBOOK=1` for A/B testing.
- */
-
-import type { ModelInfo } from "../types/index.js";
-import type { ShellKind } from "../utils/shell.js";
-
-/**
- * Playbook text injected at the TOP of the system prompt for fast-tier models.
- *
- * Wrapped with the `[CRITICAL TOOL-USE RULES ...]` marker so the model knows
- * to treat these as overrides to anything that follows.
- */
-export const CHEAP_MODEL_PLAYBOOK = `[CRITICAL TOOL-USE RULES — read before invoking any tool; these override defaults that follow]
-
-1. Bash output is AUTOMATICALLY cached. Every \`bash\` call returns a \`run_id\`
-   (e.g. \`bash-1\`) you can re-query via \`bash_output_get(run_id, mode=tail|head|grep|lines)\`.
-   - When you want only the last N lines: do NOT pipe \`| tail -N\`. Run the
-     bare command, then call \`bash_output_get(run_id, mode=tail, lines=N)\`.
-   - Same for \`| head\`, \`| grep PATTERN\`, \`> file\`. Pipes/redirects HIDE
-     the full output from the cache; \`bash_output_get\` reads from the cache
-     without re-running.
-   - This applies to EVERY bash call, not just retries.
-   - To VIEW a file use \`read_file\` (start_line/end_line) — never sed/cat a
-     file. \`bash_output_get\` is for COMMAND output, not files.
-
-2. Before reading more than 3 files to understand a topic, delegate to
-   \`task(agent="explore")\`. The sub-agent returns a compressed summary;
-   you save reading tokens.
-
-3. Use the \`grep\` tool (ripgrep) for content search — NOT \`bash\` with
-   \`grep\` / \`find\` piped.
-
-4. When a tool returns \`ERROR: ...\`, do NOT retry the identical call.
-   Pick a different tool, change inputs meaningfully, or stop and report.
-
-5. Fix the ROOT CAUSE, never mask a failure to make it "pass"
-   (\`continue-on-error\`, swallowed try/catch, skipped/deleted test, \`|| true\`).
-   If a step fails from a missing secret/config, make it CONDITIONAL (skip when
-   absent) so it still runs when present — do NOT blanket-ignore it.
-
-6. For a build / CI / test failure, read the ACTUAL failure log or stack trace
-   BEFORE hypothesizing — fix the real error, not a guess from source alone.
-
-7. ANTI-MÙ / COMPACTION (for long sessions): On pre-warn or "[context compacted at step...", emit PRESERVE_FULL_CONTEXT (full veto) or lighter KEEP_TOOL_IDS: id1,id2 (from stub id=) to protect specific high-value results. read_file/grep/lsp/bash on src/PLAN/error are auto-kept (idea 1). Use ee.query tool with "tool-artifact id=XXX" for on-demand full. Self-check "task finished?" / "compacted yet?". Use EE checkpoints.
-
-[END CRITICAL TOOL-USE RULES — your regular instructions begin below]
-
-`;
-
-/**
- * Predicate gating playbook injection.
- *
- * Returns true iff:
- *   - `modelInfo.tier === "fast"` (budget tier from catalog.json)
- *   - env `MUONROI_DISABLE_CHEAP_MODEL_PLAYBOOK` is unset / not "1"
- */
-export function shouldInjectCheapModelPlaybook(modelInfo: ModelInfo | undefined): boolean {
-  if (process.env.MUONROI_DISABLE_CHEAP_MODEL_PLAYBOOK === "1") return false;
-  return modelInfo?.tier === "fast";
-}
-
-/**
- * Prepend the playbook to a system prompt so it lands at the FRONT of the
- * model's attention window. Idempotent — passing an already-prefixed prompt
- * returns it unchanged so compaction reruns don't double-stack.
- *
- * Replaces the earlier `appendCheapModelPlaybook` which placed the rules at
- * the END of the system block. Live forensics showed end-placement let the
- * rules drop under attention threshold for DeepSeek V4 Flash (session
- * 622fdeb8f658 — model emitted `| tail -40` on first call despite the
- * "don't pipe" rule). Primacy fixes that.
- */
-export function injectCheapModelPlaybook(systemPrompt: string): string {
-  if (systemPrompt.startsWith(CHEAP_MODEL_PLAYBOOK)) return systemPrompt;
-  return `${CHEAP_MODEL_PLAYBOOK}${systemPrompt}`;
-}
-
-/**
- * Deprecated alias for backwards-compat with call sites that haven't moved
- * to the new name. New code should use `injectCheapModelPlaybook`.
- *
- * @deprecated use injectCheapModelPlaybook (prepends instead of appending)
- */
-export const appendCheapModelPlaybook = injectCheapModelPlaybook;
-
-/**
- * A2 — front-loaded one-line shell directive for fast-tier models.
- *
- * The authoritative ENVIRONMENT block (orchestrator/prompts.ts) already states
- * the OS / shell / cwd, but it lives in the BODY of the mode prompt. Live
- * forensics on fast-tier models (e.g. DeepSeek V4 Flash, gpt-5.4-mini) show
- * they underweight rules that are not front-loaded — the same primacy effect
- * that motivated prepending the playbook. So for budget models we ALSO echo a
- * single, imperative shell line at the very front of the system prompt.
- *
- * Pure function: takes the resolved shell kind + platform so it is trivially
- * unit-testable; the caller passes `resolveShell({}).kind` and
- * `process.platform` (mirroring how buildEnvironmentBlock resolves them).
- *
- * One line only — primacy matters more than detail, and tokens are the cost.
- */
-export function cheapModelShellLine(kind: ShellKind, platform: NodeJS.Platform): string {
-  const osName =
-    platform === "win32"
-      ? "Windows"
-      : platform === "darwin"
-        ? "macOS"
-        : platform === "linux"
-          ? "Linux"
-          : String(platform);
-  if (kind === "bash" || kind === "wsl") {
-    return `[ENV] OS=${osName}; the bash tool runs POSIX shell — use ONLY POSIX commands (ls, grep, sed, awk, cat, head, tail); NEVER PowerShell cmdlets or cmd.exe syntax.`;
-  }
-  if (kind === "powershell") {
-    return `[ENV] OS=${osName}; the bash tool runs PowerShell — use ONLY PowerShell cmdlets (Get-ChildItem, Select-String, Measure-Object, $env:VAR); NEVER POSIX grep/sed/awk or cmd.exe syntax.`;
-  }
-  if (kind === "cmd") {
-    return `[ENV] OS=${osName}; the bash tool runs cmd.exe — use ONLY cmd syntax (dir, type, copy, del); NEVER POSIX (grep/sed/ls) or PowerShell cmdlets.`;
-  }
-  // "auto" / anything undetermined: do NOT assert a syntax we cannot confirm —
-  // point the model at the authoritative ENVIRONMENT block instead.
-  return `[ENV] OS=${osName}; confirm the shell syntax from the ENVIRONMENT block before running any bash command.`;
-}
-
-/**
- * Prepend the one-line shell directive to a system prompt. Outermost layer —
- * call AFTER the playbook/workbook injection so the shell line lands at the
- * very front (maximum primacy). Idempotent.
- */
-export function injectCheapModelShellDirective(systemPrompt: string, shellLine: string): string {
-  const block = `${shellLine}\n\n`;
-  if (systemPrompt.startsWith(block)) return systemPrompt;
-  return `${block}${systemPrompt}`;
-}

package/src/pil/cheap-model-workbooks.test.ts

@@ -1,154 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import type { ModelInfo } from "../types/index.js";
-import {
-  CHEAP_MODEL_CONVERGENCE,
-  getCheapModelWorkbook,
-  injectCheapModelWorkbook,
-  shouldInjectCheapModelWorkbook,
-  subagentTaskType,
-} from "./cheap-model-workbooks.js";
-
-const base = { id: "x", name: "x", description: "", provider: "x", contextWindow: 100_000 } as const;
-const info = (tier: ModelInfo["tier"]): ModelInfo => ({ ...base, tier }) as unknown as ModelInfo;
-
-describe("shouldInjectCheapModelWorkbook", () => {
-  let saved: string | undefined;
-  beforeEach(() => {
-    saved = process.env.MUONROI_DISABLE_CHEAP_MODEL_WORKBOOK;
-    delete process.env.MUONROI_DISABLE_CHEAP_MODEL_WORKBOOK;
-  });
-  afterEach(() => {
-    if (saved === undefined) delete process.env.MUONROI_DISABLE_CHEAP_MODEL_WORKBOOK;
-    else process.env.MUONROI_DISABLE_CHEAP_MODEL_WORKBOOK = saved;
-  });
-
-  it("fires on fast tier only", () => {
-    expect(shouldInjectCheapModelWorkbook(info("fast"))).toBe(true);
-    expect(shouldInjectCheapModelWorkbook(info("balanced"))).toBe(false);
-    expect(shouldInjectCheapModelWorkbook(info("premium"))).toBe(false);
-    expect(shouldInjectCheapModelWorkbook(undefined)).toBe(false);
-  });
-
-  it("env override disables it", () => {
-    process.env.MUONROI_DISABLE_CHEAP_MODEL_WORKBOOK = "1";
-    expect(shouldInjectCheapModelWorkbook(info("fast"))).toBe(false);
-  });
-});
-
-describe("getCheapModelWorkbook", () => {
-  it("always includes the convergence (anti-ramble) block", () => {
-    expect(getCheapModelWorkbook("debug")).toContain(CHEAP_MODEL_CONVERGENCE);
-    expect(getCheapModelWorkbook(null)).toContain(CHEAP_MODEL_CONVERGENCE);
-  });
-
-  it("specialises per task type", () => {
-    expect(getCheapModelWorkbook("debug")).toMatch(/read the ACTUAL error|smallest root cause/i);
-    expect(getCheapModelWorkbook("debug")).toContain("continue-on-error");
-    expect(getCheapModelWorkbook("generate")).toMatch(/GENERATE/);
-    expect(getCheapModelWorkbook("refactor")).toMatch(/only what was named/i);
-    expect(getCheapModelWorkbook("analyze")).toMatch(/do not read the whole codebase/i);
-  });
-
-  it("analyze addendum steers code inspection over doc-skimming", () => {
-    // Live (gemini-flash Task A, 2026-06-04): a repo eval based mostly on
-    // AGENTS.md/CLAUDE.md docs, with little code inspection → shallow findings.
-    expect(getCheapModelWorkbook("analyze")).toMatch(/actual code|inspect the code|not just (the )?docs/i);
-  });
-
-  it("falls back to convergence-only for an unlisted task type", () => {
-    const general = getCheapModelWorkbook("general");
-    expect(general).toContain(CHEAP_MODEL_CONVERGENCE);
-    // no per-type addendum line for "general"
-    expect(general).not.toMatch(/DEBUG:|GENERATE:|REFACTOR:|ANALYZE:/);
-  });
-
-  it("emphasises minimising tool calls (the cost lever)", () => {
-    expect(CHEAP_MODEL_CONVERGENCE).toMatch(/FEWEST|minimise tool calls/i);
-    expect(CHEAP_MODEL_CONVERGENCE).toMatch(/STOP investigating/i);
-  });
-
-  it("steers a crisp completion line — finish the action, don't stop mid-step (A4)", () => {
-    // Live obs (workbook run 3308b3d02e11): the model's FINAL message was a
-    // mid-action narration ("I'm verifying the final workflow content now…")
-    // instead of stating completion. Steer it to finish, then state done.
-    expect(CHEAP_MODEL_CONVERGENCE).toMatch(/finish the action|don't stop mid|do not stop mid/i);
-    expect(CHEAP_MODEL_CONVERGENCE).toMatch(/one line|1 line|state.*(done|complet)/i);
-  });
-
-  it("stays compact (under 1300 chars) to preserve attention budget", () => {
-    // Bumped 900 → 1000 when the A4 completion-line rule was added; 1000 → 1300
-    // when the universal grounding (anti-hallucination) rule was added,
-    // and 1300 -> 1600 when anti-mù compaction recovery was added.
-    expect(getCheapModelWorkbook("debug").length).toBeLessThan(1600);
-  });
-});
-
-describe("grounding (anti-hallucination) directive", () => {
-  // Live obs (deepseek-v4-flash repo-eval, session 17fc23f0): the model
-  // fabricated a test count (claimed 67, actual ~479), invented a "model
-  // display bug" with fake file:line refs, and falsely claimed the finding
-  // was "already documented this session". That eval classified taskType=null
-  // on deepseek, so it received the convergence-ONLY block — which is why the
-  // grounding rule must live in the UNIVERSAL convergence block, not the
-  // per-type analyze addendum (or it would miss the exact observed case).
-  it("convergence block carries a grounding rule", () => {
-    expect(CHEAP_MODEL_CONVERGENCE).toMatch(/GROUND every claim/i);
-    expect(CHEAP_MODEL_CONVERGENCE).toMatch(/never invent/i);
-    expect(CHEAP_MODEL_CONVERGENCE).toMatch(/unverified/i);
-  });
-
-  it("applies even when taskType is null (the deepseek null-classified eval case)", () => {
-    expect(getCheapModelWorkbook(null)).toMatch(/GROUND every claim/i);
-    expect(getCheapModelWorkbook(null)).toMatch(/never invent/i);
-  });
-
-  it("applies to analyze/eval tasks too (inherited from convergence)", () => {
-    expect(getCheapModelWorkbook("analyze")).toMatch(/GROUND every claim/i);
-  });
-});
-
-describe("subagentTaskType", () => {
-  // Sub-agents have no PIL classifier run of their own; their role IS their
-  // task type. The Explore agent is read-only research → analyze; the verify
-  // family runs tests/diagnoses failures → debug. Everything else (general,
-  // vision, computer, custom) gets the convergence-only block (null).
-  it("maps explore → analyze", () => {
-    expect(subagentTaskType("explore")).toBe("analyze");
-  });
-
-  it("maps the verify family → debug", () => {
-    expect(subagentTaskType("verify")).toBe("debug");
-    expect(subagentTaskType("verify-detect")).toBe("debug");
-    expect(subagentTaskType("verify-manifest")).toBe("debug");
-  });
-
-  it("returns null (convergence-only) for general/vision/computer", () => {
-    expect(subagentTaskType("general")).toBeNull();
-    expect(subagentTaskType("vision")).toBeNull();
-    expect(subagentTaskType("computer")).toBeNull();
-  });
-
-  it("returns null for an unknown/custom sub-agent name", () => {
-    expect(subagentTaskType("my-custom-agent")).toBeNull();
-    expect(subagentTaskType("")).toBeNull();
-  });
-
-  it("feeds the workbook builder — explore yields the ANALYZE addendum", () => {
-    const wb = getCheapModelWorkbook(subagentTaskType("explore"));
-    expect(wb).toMatch(/do not read the whole codebase/i);
-  });
-});
-
-describe("injectCheapModelWorkbook", () => {
-  it("prepends the workbook to the system prompt", () => {
-    const out = injectCheapModelWorkbook("You are an agent.", "debug");
-    expect(out.startsWith(getCheapModelWorkbook("debug"))).toBe(true);
-    expect(out.endsWith("You are an agent.")).toBe(true);
-  });
-
-  it("is idempotent for the same task type", () => {
-    const once = injectCheapModelWorkbook("Sys.", "debug");
-    const twice = injectCheapModelWorkbook(once, "debug");
-    expect(twice).toBe(once);
-  });
-});

package/src/pil/cheap-model-workbooks.ts

@@ -1,109 +0,0 @@
-/**
- * src/pil/cheap-model-workbooks.ts
- *
- * Task-type-aware "workbooks" for budget (fast-tier) models — a focused
- * convergence layer that sits in front of the system prompt alongside the
- * cheap-model playbook (see cheap-model-playbook.ts for the tool-use rules).
- *
- * Motivation (live cost forensics, 2026-05-31): gpt-5.4-mini took 19 LLM calls
- * (~395K input tokens) to apply a ONE-LINE CI fix — broad greps, re-reads,
- * read-budget overruns, many tiny exploration steps. For budget models the
- * dominant cost is `tool-call-count × ~20K input/call` (the system prompt +
- * tool envelope is re-sent every call), so RAMBLING IS THE COST. Smart models
- * converge on their own; fast-tier models need an explicit "do the minimum,
- * then stop" instruction.
- *
- * The workbook is injected only for `modelInfo.tier === "fast"`, is fixed for
- * the whole turn (so it stays inside the cached prefix), and is intentionally
- * short to preserve attention budget.
- *
- * Escape hatch: MUONROI_DISABLE_CHEAP_MODEL_WORKBOOK=1.
- */
-
-import type { ModelInfo } from "../types/index.js";
-import type { TaskType } from "./types.js";
-
-/**
- * Universal anti-ramble convergence block — applies to every task type.
- * Kept tight; the per-task addendum below specialises it.
- */
-export const CHEAP_MODEL_CONVERGENCE = `[CONVERGENCE — minimise tool calls; the system prompt + tools are re-sent every call, so each extra step is expensive]
-
-- Plan the FEWEST reads you need, then read the specific file/section directly.
-  Do NOT broad-grep, re-read a file you already read, or explore "just in case".
-- The moment you have enough to act, STOP investigating and make the change.
-- Make the SMALLEST correct change for the request; do not widen scope.
-- Finish the action before you answer — never stop mid-step (e.g. "I'm verifying…").
-  When done, state completion in ONE line (what changed + that it's verified);
-  no recap, no next-steps padding.
-- GROUND every claim in what you actually read or ran THIS turn: cite real
-  file:line, and never invent counts, line numbers, names, or bugs. If a number
-  (test/file count) is not verified by a command you ran, run the check or mark
-  it "unverified" — do NOT guess a value or assert a finding you did not observe.
-- ANTI-MÙ: After compaction note or pre-warn, emit PRESERVE_FULL_CONTEXT (full) or KEEP_TOOL_IDS: id1,id2 to protect high-value (auto for read_file/grep on src/PLAN/error). Use the ee_query tool with "tool-artifact id=XXX" for on-demand full re-hydrate. Recall checkpoints. `;
-
-/**
- * Per-task-type addenda. Each is 1–2 tight lines targeting that type's most
- * common budget-model failure mode. Types not listed fall back to the
- * convergence block alone.
- */
-const TASK_WORKBOOKS: Partial<Record<TaskType, string>> = {
-  debug:
-    "DEBUG: read the ACTUAL error/log/failing output first; fix the smallest root cause with ONE change. " +
-    "Never mask a failure to make it pass (no continue-on-error, swallowed catch, skipped test, `|| true`).",
-  generate:
-    "GENERATE: confirm the target file + the surrounding pattern, write the new code to match it, then stop. " +
-    "Do not scaffold extras or restructure unrelated code.",
-  refactor: "REFACTOR: change only what was named (rename/extract/move). Preserve behaviour; add nothing new.",
-  analyze:
-    "ANALYZE: answer from what you have already read — do not read the whole codebase. Bullet findings, no narrative. " +
-    "For a repo/code review, base findings on the ACTUAL code you inspect (file sizes, structure, key modules), not just AGENTS.md/CLAUDE.md docs.",
-  documentation: "DOCS: document only what was asked, with a short example. No tangents.",
-  plan: "PLAN: produce concise ordered steps with one line of rationale each. No essays.",
-};
-
-/**
- * Map a sub-agent role (agentKey) to the workbook TaskType that best matches
- * its job. Sub-agents never run PIL Layer 1, so they have no classifier-derived
- * taskType — their ROLE is their task type:
- *   - explore           → analyze  (read-only research; "answer from what you read")
- *   - verify*           → debug    (runs tests / diagnoses failures; "read the real error")
- *   - general/vision/computer/custom → null (convergence-only anti-ramble block)
- *
- * Returning null is a safe default: the convergence block still applies, only
- * the per-type addendum is omitted.
- */
-export function subagentTaskType(agentKey: string): TaskType | null {
-  if (agentKey === "explore") return "analyze";
-  if (agentKey === "verify" || agentKey === "verify-detect" || agentKey === "verify-manifest") return "debug";
-  return null;
-}
-
-/**
- * Build the workbook text for a task type (convergence + optional addendum).
- */
-export function getCheapModelWorkbook(taskType: TaskType | null | undefined): string {
-  const addendum = taskType ? TASK_WORKBOOKS[taskType] : undefined;
-  const body = addendum ? `${CHEAP_MODEL_CONVERGENCE}\n\n${addendum}` : CHEAP_MODEL_CONVERGENCE;
-  return `${body}\n[END CONVERGENCE — your regular instructions follow]\n\n`;
-}
-
-/**
- * Gate workbook injection. Mirrors the playbook gate: fast tier only, unless
- * disabled via MUONROI_DISABLE_CHEAP_MODEL_WORKBOOK=1.
- */
-export function shouldInjectCheapModelWorkbook(modelInfo: ModelInfo | undefined): boolean {
-  if (process.env.MUONROI_DISABLE_CHEAP_MODEL_WORKBOOK === "1") return false;
-  return modelInfo?.tier === "fast";
-}
-
-/**
- * Prepend the task workbook to a system prompt. Idempotent — re-injecting an
- * already-prefixed prompt for the same task type returns it unchanged so
- * compaction reruns don't double-stack.
- */
-export function injectCheapModelWorkbook(systemPrompt: string, taskType: TaskType | null | undefined): string {
-  const workbook = getCheapModelWorkbook(taskType);
-  if (systemPrompt.startsWith(workbook)) return systemPrompt;
-  return `${workbook}${systemPrompt}`;
-}

package/src/pil/clarity-gate.ts

@@ -1,188 +0,0 @@
-import { getAutoPassThreshold } from "./config.js";
-import type { TaskType } from "./types.js";
-
-export interface L1Signal {
-  confidence: number;
-  taskType: TaskType | null;
-  complexity: "low" | "medium" | "high";
-}
-
-/**
- * A direct imperative command — "run the tests", "echo ok", "show the config",
- * "list the ports" — has a self-evident outcome (the command executes / the
- * thing is shown), so it should NOT trigger an outcome-clarification askcard.
- * Requires an executable verb at the very start followed by a concrete object
- * (a bare "run" with no object stays ambiguous → false).
- */
-const DIRECT_IMPERATIVE_RE = /^\s*(run|execute|show|list|print|echo)\b\s+\S/i;
-
-export function isDirectImperative(raw: string): boolean {
-  return DIRECT_IMPERATIVE_RE.test(raw);
-}
-
-export function canInferOutcome(taskType: TaskType | null, raw: string): boolean {
-  if (!taskType) return false;
-  // PIL clarity over-trigger fix: a "general" prompt normally can't infer its
-  // outcome, but a direct imperative command is the exception — its outcome is
-  // obvious, so asking "what's the expected outcome?" is pure noise.
-  if (taskType === "general") return isDirectImperative(raw);
-  const hasErrorRef = /error|exception|stack|TypeError|Cannot|failed|crash|fail(?:s|ed|ing)?|broken|red/i.test(raw);
-  const hasFileLineRef = /\.\w+:\d+/.test(raw);
-  const hasTargetState = /should|must|expect|return|produce|output|become/i.test(raw);
-  const hasAddPattern = /\b(add|create|implement|write|generate)\b.*\b(to|in|for|into)\b/i.test(raw);
-  // PIL-L6 fix — explicit goal phrase in the prompt is itself an outcome
-  // ("goal sẽ là ci green", "want: tests passing", "expect: 0 errors").
-  // Without this, debug prompts that name the desired end-state still
-  // tripped the interview because none of the verb-noun patterns matched.
-  const hasExplicitGoal = /\b(goal|target|expect|want|mong muốn|mong muon|kết quả|ket qua)\b[:\s]/i.test(raw);
-  return hasErrorRef || hasFileLineRef || hasTargetState || hasAddPattern || hasExplicitGoal;
-}
-
-/**
- * PIL-L6 fix — operational-domain scope (CI, deploy, build, lint) implies
- * scope is the project's pipeline/infra, not a specific file. "fix ci fail"
- * doesn't have a file path but the scope is unambiguous: it's the .github/
- * workflows + whatever those workflows run. Treat as scoped for auto-pass.
- */
-export function hasOperationalScope(raw: string): boolean {
-  return /\b(ci|cd|build|deploy(?:ment)?|action(?:s)?|workflow|pipeline|lint|tests?|coverage|gh\s+(check|run|workflow))\b/i.test(
-    raw,
-  );
-}
-
-export function countFileReferences(raw: string): number {
-  return (raw.match(/[\w-]+\.\w{1,5}/g) ?? []).filter((m) =>
-    /\.(ts|tsx|js|jsx|py|rs|go|java|cs|rb|vue|svelte|css|scss|json|yaml|yml|toml|md)$/i.test(m),
-  ).length;
-}
-
-export function hasExplicitScope(raw: string): boolean {
-  return /\b(src\/|lib\/|app\/|pages\/|components\/|modules\/|packages\/)\S+/.test(raw);
-}
-
-/**
- * An image-analysis prompt is scoped to the IMAGE, not the codebase. "analyze
- * diagram.png", "take a screenshot and describe it" name their target directly,
- * so the "Which part of the codebase should this target?" askcard is
- * nonsensical for them — exactly like operational (CI/build) prompts are scoped
- * to the pipeline (see hasOperationalScope). Detect a concrete image signal: an
- * image file extension, a data:image URI, or an unambiguous image noun.
- *
- * Deliberately NARROW: a false positive here SUPPRESSES a legitimate clarifying
- * question (quality risk), so overloaded words are excluded —
- *   - "logo" / "icon" / "diagram" / "chart" / "mockup" appear in real codebase
- *     tasks ("add a logo to the header"),
- *   - bare "image" collides with container/Docker usage ("rebuild the image"),
- *   - "picture" collides with the "bigger picture" idiom,
- *   - Vietnamese substrings (ảnh/hình) collide with frequent non-image words
- *     ("ảnh hưởng", "màn hình", "hình thức").
- * Only a file extension, data:image URI, "screenshot", or "photo" qualify.
- */
-const IMAGE_SCOPE_RE =
-  /\.(png|jpe?g|gif|webp|svg|bmp|tiff?|heic|avif|ico)\b|data:image\/|\bscreen-?shots?\b|\bphotos?\b/i;
-
-export function hasImageScope(raw: string): boolean {
-  return IMAGE_SCOPE_RE.test(raw);
-}
-
-/**
- * A web-search / external-information prompt ("search the web for X", "google
- * the error", a bare URL, "latest news on Y") is scoped to the WEB, not the
- * codebase, so the "Which part of the codebase should this target?" askcard is
- * nonsensical for it — symmetric to hasOperationalScope / hasImageScope. (Live:
- * "search the web for the latest vitest release notes" → taskType=analyze fired
- * the scope askcard and recorded a wrong scope of "src/mcp".)
- *
- * Deliberately NARROW — only UNAMBIGUOUSLY-external intent. It must not reuse
- * the broad hasDocsSignal vocabulary (library/api/install/package), because
- * those words routinely describe real codebase tasks ("add the zod library to
- * the auth module") that genuinely need the scope askcard. In particular a bare
- * "search" is excluded so "search the codebase" / "implement the search
- * feature" still get scoped.
- */
-const EXTERNAL_INFO_SCOPE_RE =
-  /https?:\/\/\S+|\bsearch\s+(the\s+)?(web|internet|online)\b|\bweb\s*search\b|\bon\s+the\s+(web|internet)\b|\bgoogle\b|\b(news|weather|headlines)\b/i;
-
-export function hasExternalInfoScope(raw: string): boolean {
-  return EXTERNAL_INFO_SCOPE_RE.test(raw);
-}
-
-/**
- * A whole-repo / whole-project prompt ("đánh giá repo này", "review the entire
- * codebase", "audit the whole project") is ALREADY scoped — to everything — so
- * the "Which part of the codebase should this target?" askcard is nonsensical
- * (and worse, it recommends a single bounded context like "src/cli" as the
- * default, which is wrong for a repo-wide eval). Symmetric to the other scope
- * predicates. Live: gemini-2.5-flash classified "đánh giá repo …" as analyze and
- * got the scope askcard whose recommended option was a narrow subdir.
- *
- * Deliberately NARROW — it must NOT fire on a narrow task that merely mentions a
- * repo/project ("add X to this repo", "fix the bug in the project"), or those
- * would wrongly skip a legitimate scope question. So it requires EITHER an
- * explicit wholeness qualifier (whole/entire/all/toàn bộ/cả) on a repo/project/
- * codebase noun, OR an evaluation/overview verb (review/audit/evaluate/assess/
- * analyze/overview · đánh giá/phân tích/tổng quan/kiểm tra) applied to that noun.
- */
-const WHOLE_REPO_SCOPE_RE =
-  // NOTE: leading anchors on Vietnamese-initial alternatives use (?:^|\s) not
-  // \b — JS \b is ASCII-only and never matches before a non-ASCII letter like
-  // "đ", so "\bđánh" would silently fail to match "đánh giá repo".
-  /\b(whole|entire|overall|all\s+of\s+the|across\s+the)\s+(repo(?:sitory)?|code-?base|project)\b|(?:^|\s)(toàn\s*bộ|toan\s*bo|cả|ca)\s+(repo|dự\s*án|du\s*an|m[ãa]\s*ngu[ồo]n|code-?base|project)\b|\b(review|audit|evaluate|assess|analy[sz]e|summari[sz]e|overview\s+of|summary\s+of)\s+(?:\S+\s+){0,2}?(repo(?:sitory)?|code-?base|project)\b|(?:^|\s)(đánh\s*giá|danh\s*gia|phân\s*tích|phan\s*tich|tổng\s*quan|tong\s*quan|kiểm\s*tra|kiem\s*tra|tóm\s*tắt|tom\s*tat)\s+(?:\S+\s+){0,2}?(toàn|toan|repo|dự\s*án|du\s*an|m[ãa]\s*ngu[ồo]n|code-?base|project)\b/i;
-
-export function hasWholeRepoScope(raw: string): boolean {
-  return WHOLE_REPO_SCOPE_RE.test(raw);
-}
-
-/**
- * A self-contained computation / reasoning prompt supplies its operand data
- * INLINE ("Compute f([3,1,2]) …", "what is the median of [10, 4, 7]?") — the
- * task's target is the data in the prompt, not the codebase, so the "Which part
- * of the codebase should this target?" askcard is nonsensical for it. Symmetric
- * to hasOperationalScope / hasImageScope / hasExternalInfoScope / hasWholeRepoScope.
- *
- * Live: "Compute f([3,1,2]) where f sorts the list ascending then returns the
- * sum of the first two elements." classified taskType=analyze — the regex
- * classifier matched the bare word "list" (regex:read, conf 0.80, which also
- * skips the brain) — and fired BOTH the pil-interview scope askcard (auto
- * "Entire project") and the pil-acceptance card on a pure math problem.
- *
- * Deliberately NARROW — a false positive here SUPPRESSES a legitimate scope
- * question (quality risk), so it requires BOTH:
- *   1. an inline DATA literal — a bracketed comma-list of >=2 numeric or quoted
- *      string values (`[3, 1, 2]`, `["a", "b"]`). A bracketed list of bare
- *      identifiers (`[auth.ts, session.ts]`) is NOT data — those are file/symbol
- *      references and stay codebase-scoped; the regex only accepts numbers and
- *      quoted strings, so it never matches them. Single-element `[0]` (array
- *      indexing) is excluded by the >=2-element requirement.
- *   2. computation framing — a compute/evaluate/sort/sum/statistic verb or a
- *      "what is …" / "given the array …" question frame.
- * The AND keeps real codebase tasks that merely embed a literal (e.g. "set the
- * default retry delays to [100, 200, 400] in the config") correctly scoped.
- */
-const INLINE_DATA_LITERAL_RE =
-  /\[\s*(?:-?\d+(?:\.\d+)?|"[^"]*"|'[^']*')(?:\s*,\s*(?:-?\d+(?:\.\d+)?|"[^"]*"|'[^']*'))+\s*\]/;
-const COMPUTE_FRAMING_RE =
-  /\b(comput(?:e|ing)|calculat(?:e|ing|ion)|evaluat(?:e|ing)|solve|sort(?:s|ed|ing)?|sum|median|mean|average|max(?:imum)?|min(?:imum)?|largest|smallest|reverse[ds]?|result\s+of|what(?:'?s|\s+is|\s+are)|given\s+(?:the\s+)?(?:array|list|sequence|set|matrix|string|numbers?))\b/i;
-
-export function hasSelfContainedComputationScope(raw: string): boolean {
-  return INLINE_DATA_LITERAL_RE.test(raw) && COMPUTE_FRAMING_RE.test(raw);
-}
-
-export function shouldAutoPass(l1: L1Signal, raw: string): boolean {
-  if (l1.confidence < getAutoPassThreshold()) return false;
-  if (!canInferOutcome(l1.taskType, raw)) return false;
-  // PIL-L6 fix — debug prompts about CI/build/deploy don't need a file path
-  // because their scope is the pipeline itself. Operational scope counts.
-  if (
-    countFileReferences(raw) === 0 &&
-    !hasExplicitScope(raw) &&
-    !hasOperationalScope(raw) &&
-    !hasImageScope(raw) &&
-    !hasExternalInfoScope(raw) &&
-    !hasWholeRepoScope(raw) &&
-    !hasSelfContainedComputationScope(raw)
-  )
-    return false;
-  if (l1.complexity === "high") return false;
-  return true;
-}

package/src/pil/config.ts

@@ -1,25 +0,0 @@
-/**
- * PIL feature flags.
- * - MUONROI_PIL_UNIFIED: "1" enables the new /api/pil-context single-call path
- *   in Layer 1. "0" or unset disables it (legacy multi-call path).
- *   Default OFF during rollout; flip to ON after dual-run validation.
- */
-export function isUnifiedPilEnabled(): boolean {
-  if (process.env.MUONROI_PIL_UNIFIED === "0") return false;
-  if (process.env.MUONROI_PIL_UNIFIED === "1") return true;
-  return false;
-}
-
-export function isDiscoveryEnabled(): boolean {
-  return process.env.MUONROI_PIL_DISCOVERY !== "0";
-}
-
-export function getAutoPassThreshold(): number {
-  const v = Number(process.env.MUONROI_PIL_AUTOPASS_THRESHOLD);
-  return Number.isFinite(v) && v >= 0.5 && v <= 1.0 ? v : 0.85;
-}
-
-export function getMaxInterviewQuestions(): number {
-  const v = Number(process.env.MUONROI_PIL_MAX_QUESTIONS);
-  return Number.isFinite(v) && v >= 1 && v <= 5 ? v : 3;
-}

package/src/pil/discovery-cache.ts

@@ -1,20 +0,0 @@
-import type { ProjectContext } from "./discovery-types.js";
-
-const CACHE_TTL_MS = 5 * 60_000;
-
-let _cached: ProjectContext | null = null;
-
-export function getCachedProjectContext(cwd: string): ProjectContext | null {
-  if (!_cached) return null;
-  if (_cached.cwd !== cwd) return null;
-  if (Date.now() - _cached.scannedAt > CACHE_TTL_MS) return null;
-  return _cached;
-}
-
-export function setCachedProjectContext(ctx: ProjectContext): void {
-  _cached = ctx;
-}
-
-export function clearDiscoveryCache(): void {
-  _cached = null;
-}