muonroi-cli 1.4.0 → 1.4.1

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

@@ -1,104 +0,0 @@
-/**
- * Unit tests for scoreSufficiency — the context-sufficiency gate that decides
- * whether the /ideal dispatcher MUST force the Council path (and AskCard
- * discovery) regardless of complexity. Vague briefs like "todo app" are
- * exactly the case where an Agile team would stop and discover, not
- * scaffold-and-pray.
- */
-
-import { describe, expect, it } from "vitest";
-import { scoreSufficiency } from "../layer1-intent.js";
-
-describe("scoreSufficiency — vague briefs MUST go through Council", () => {
-  it("'todo app' → not sufficient, missing scope + intent", () => {
-    const out = scoreSufficiency({ rawText: "todo app" });
-    expect(out.sufficient).toBe(false);
-    expect(out.missing).toContain("scope");
-    expect(out.missing).toContain("intent");
-  });
-
-  it("'crm system' → not sufficient, scope missing", () => {
-    const out = scoreSufficiency({ rawText: "crm system" });
-    expect(out.sufficient).toBe(false);
-    expect(out.missing).toContain("scope");
-  });
-
-  it("'build a chat platform' → not sufficient, scope missing", () => {
-    const out = scoreSufficiency({ rawText: "build a chat platform" });
-    expect(out.sufficient).toBe(false);
-    expect(out.missing).toContain("scope");
-  });
-
-  it("'dashboard for users' → not sufficient, scope missing", () => {
-    const out = scoreSufficiency({ rawText: "dashboard for users" });
-    expect(out.sufficient).toBe(false);
-    expect(out.missing).toContain("scope");
-  });
-
-  it("empty string → not sufficient, all three categories missing", () => {
-    const out = scoreSufficiency({ rawText: "" });
-    expect(out.sufficient).toBe(false);
-    expect(out.missing).toEqual(expect.arrayContaining(["scope", "target", "intent"]));
-  });
-
-  it("single short word 'todo' → not sufficient, intent + target missing", () => {
-    const out = scoreSufficiency({ rawText: "todo" });
-    expect(out.sufficient).toBe(false);
-    expect(out.missing).toContain("intent");
-    expect(out.missing).toContain("target");
-  });
-});
-
-describe("scoreSufficiency — context-complete prompts CAN skip Council", () => {
-  it("'fix typo in src/foo.ts:42' → sufficient (file ref + concrete verb)", () => {
-    const out = scoreSufficiency({ rawText: "fix typo in src/foo.ts:42" });
-    expect(out.sufficient).toBe(true);
-    expect(out.missing).toEqual([]);
-  });
-
-  it("'rename FooService to BarService' → sufficient (concrete verb)", () => {
-    const out = scoreSufficiency({ rawText: "rename FooService to BarService" });
-    expect(out.sufficient).toBe(true);
-  });
-
-  it("'add validation to UserController.cs' → sufficient (file ref + verb)", () => {
-    const out = scoreSufficiency({ rawText: "add validation to UserController.cs" });
-    expect(out.sufficient).toBe(true);
-  });
-
-  it("'delete unused import in src/utils.ts' → sufficient", () => {
-    const out = scoreSufficiency({ rawText: "delete unused import in src/utils.ts" });
-    expect(out.sufficient).toBe(true);
-  });
-
-  it("long detailed brief (≥80 chars) with vague noun → scope NOT flagged", () => {
-    // 80+ chars carrying enough context that scope is implied even with 'app'.
-    const text =
-      "Build a todo app with auth, multi-user support, postgres persistence, and a React + Vite frontend talking to a NestJS API";
-    const out = scoreSufficiency({ rawText: text });
-    expect(out.missing).not.toContain("scope");
-  });
-});
-
-describe("scoreSufficiency — edge cases", () => {
-  it("whitespace-only string treated as empty", () => {
-    const out = scoreSufficiency({ rawText: "   \n\t  " });
-    expect(out.sufficient).toBe(false);
-  });
-
-  it("repeated calls are idempotent (no FILE_REF_RE.lastIndex regression)", () => {
-    const text = "fix bug in src/index.ts";
-    const a = scoreSufficiency({ rawText: text });
-    const b = scoreSufficiency({ rawText: text });
-    expect(a.sufficient).toBe(b.sufficient);
-    expect(a.missing).toEqual(b.missing);
-  });
-
-  it("'build a counter' → sufficient (concrete verb 'add'-adjacent 'build' is NOT in verb list, but length < 30 + no scope-noun → intent)", () => {
-    // 'build' is not in CONCRETE_VERB_RE — intent only flagged if scope-noun AND file-ref AND verb all absent
-    // 'build a counter' (15 chars) lacks scope-noun, file-ref, concrete-verb → intent missing
-    const out = scoreSufficiency({ rawText: "build a counter" });
-    expect(out.sufficient).toBe(false);
-    expect(out.missing).toContain("intent");
-  });
-});

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

@@ -1,49 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getPilLastResult, setPilLastResult } from "../store.js";
-import type { PipelineContext } from "../types.js";
-
-// Reset module state between tests by re-importing via dynamic import won't work easily
-// Instead we use a helper pattern: call setPilLastResult(null as any) to reset
-// Actually we'll just rely on test order since the module is stateful
-
-const makeCtx = (raw: string): PipelineContext => ({
-  raw,
-  enriched: raw,
-  taskType: null,
-  domain: null,
-  confidence: 0,
-  outputStyle: null,
-  tokenBudget: 500,
-  metrics: null,
-  layers: [],
-});
-
-describe("PIL store", () => {
-  it("returns null before any call", () => {
-    // This only works if tests run in isolation or this is first test
-    // We test the getter returns null on a fresh import
-    // Since vitest reuses module state, we reset by calling set with null-like ctx
-    // For a clean null test, rely on fresh module state from vitest isolation
-    const initial = getPilLastResult();
-    // Accept either null (fresh) or whatever was set before
-    // The key invariant: after we set, we get back the same ctx
-    expect(initial === null || initial !== undefined).toBe(true);
-  });
-
-  it("setPilLastResult then getPilLastResult returns same ctx reference", () => {
-    const ctx = makeCtx("refactor this function");
-    setPilLastResult(ctx);
-    const result = getPilLastResult();
-    expect(result).toBe(ctx);
-  });
-
-  it("setPilLastResult called twice — second call overwrites first", () => {
-    const ctx1 = makeCtx("first prompt");
-    const ctx2 = makeCtx("second prompt");
-    setPilLastResult(ctx1);
-    setPilLastResult(ctx2);
-    const result = getPilLastResult();
-    expect(result).toBe(ctx2);
-    expect(result?.raw).toBe("second prompt");
-  });
-});

package/src/pil/__tests__/task-tier-map.test.ts

@@ -1,41 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { taskTypeToTier } from "../task-tier-map.js";
-
-describe("taskTypeToTier — TaskType to EE tier mapping", () => {
-  it("maps 'refactor' to 'balanced'", () => {
-    expect(taskTypeToTier("refactor")).toBe("balanced");
-  });
-
-  it("maps 'debug' to 'balanced'", () => {
-    expect(taskTypeToTier("debug")).toBe("balanced");
-  });
-
-  it("maps 'plan' to 'premium'", () => {
-    expect(taskTypeToTier("plan")).toBe("premium");
-  });
-
-  it("maps 'analyze' to 'balanced'", () => {
-    expect(taskTypeToTier("analyze")).toBe("balanced");
-  });
-
-  it("maps 'documentation' to 'fast'", () => {
-    expect(taskTypeToTier("documentation")).toBe("fast");
-  });
-
-  it("maps 'generate' to 'balanced'", () => {
-    expect(taskTypeToTier("generate")).toBe("balanced");
-  });
-
-  it("maps 'general' to 'fast'", () => {
-    expect(taskTypeToTier("general")).toBe("fast");
-  });
-
-  it("maps null to 'fast'", () => {
-    expect(taskTypeToTier(null)).toBe("fast");
-  });
-
-  it("maps unknown string to 'balanced' (default fallback)", () => {
-    expect(taskTypeToTier("unknown")).toBe("balanced");
-    expect(taskTypeToTier("foobar")).toBe("balanced");
-  });
-});

package/src/pil/agent-operating-contract.test.ts

@@ -1,84 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { AGENT_OPERATING_CONTRACT, buildContractSection } from "./agent-operating-contract.js";
-
-describe("AGENT_OPERATING_CONTRACT", () => {
-  it("covers core work phases + anti-mù compaction contract (upgrade)", () => {
-    expect(AGENT_OPERATING_CONTRACT).toMatch(/BEFORE ACTING/i);
-    expect(AGENT_OPERATING_CONTRACT).toMatch(/READING/i);
-    expect(AGENT_OPERATING_CONTRACT).toMatch(/EXECUTING/i);
-    expect(AGENT_OPERATING_CONTRACT).toMatch(/WHEN UNSURE/i);
-    expect(AGENT_OPERATING_CONTRACT).toMatch(/REPORTING/i);
-    expect(AGENT_OPERATING_CONTRACT).toMatch(/ANTI-MÙ \/ COMPACTION/i);
-    expect(AGENT_OPERATING_CONTRACT).toMatch(/PRESERVE_FULL_CONTEXT/i);
-  });
-
-  it("carries the anti-hallucination / grounding rule in the REPORTING phase", () => {
-    // The decisive failure this contract addresses: a model asserting a count
-    // or file:line it never verified (live: deepseek claimed 67 tests, actual
-    // 401). REPORTING must forbid guessing numbers and require running the check
-    // or labelling "unverified".
-    expect(AGENT_OPERATING_CONTRACT).toMatch(/unverified/i);
-    expect(AGENT_OPERATING_CONTRACT).toMatch(/never guess|do not guess/i);
-  });
-
-  it("forbids masking failures in the EXECUTING phase", () => {
-    expect(AGENT_OPERATING_CONTRACT).toMatch(/\|\| true|swallow|skipped|mask/i);
-  });
-
-  it("requires verify/cross-check before concluding when unsure", () => {
-    expect(AGENT_OPERATING_CONTRACT).toMatch(/verify|cross-check|reproduc/i);
-  });
-
-  it("REPORTING forbids over-answering with unrequested numbers", () => {
-    // Live (deepseek Task B, 2026-06-04): the model volunteered an unrequested,
-    // wrong "10026 total lines" stat. REPORTING must steer "answer only what
-    // was asked".
-    expect(AGENT_OPERATING_CONTRACT).toMatch(/only what (was|is) asked|do not volunteer|don't volunteer/i);
-  });
-
-  it("REPORTING forbids claiming verification or edits that were not actually done", () => {
-    // Live (grok, 2026-06-06): the model reported it added listener-cleanup code
-    // and "verified" a build — but the cleanup was never written and the build
-    // step was skipped (it hit a phantom sandbox path). REPORTING must forbid
-    // claiming a build/test ran or that code was applied unless it actually was.
-    expect(AGENT_OPERATING_CONTRACT).toMatch(/never claim a (build|test|command|verification)/i);
-    expect(AGENT_OPERATING_CONTRACT).toMatch(/describe edits|did not actually (do|apply|run)/i);
-  });
-
-  it("has clear start/end markers so the model treats it as a prelude", () => {
-    expect(AGENT_OPERATING_CONTRACT).toMatch(/AGENT OPERATING CONTRACT/i);
-    expect(AGENT_OPERATING_CONTRACT).toMatch(/END CONTRACT/i);
-  });
-
-  it("stays compact (under 1800 chars) to preserve attention budget on every turn (anti-mù section added)", () => {
-    expect(AGENT_OPERATING_CONTRACT.length).toBeLessThan(1800);
-  });
-});
-
-describe("buildContractSection", () => {
-  let saved: string | undefined;
-  beforeEach(() => {
-    saved = process.env.MUONROI_DISABLE_AGENT_CONTRACT;
-    delete process.env.MUONROI_DISABLE_AGENT_CONTRACT;
-  });
-  afterEach(() => {
-    if (saved === undefined) delete process.env.MUONROI_DISABLE_AGENT_CONTRACT;
-    else process.env.MUONROI_DISABLE_AGENT_CONTRACT = saved;
-  });
-
-  it("returns the contract followed by a blank-line separator by default", () => {
-    const section = buildContractSection();
-    expect(section.startsWith(AGENT_OPERATING_CONTRACT)).toBe(true);
-    expect(section.endsWith("\n\n")).toBe(true);
-  });
-
-  it("is empty for chitchat turns (no tools, no factual claims to ground)", () => {
-    expect(buildContractSection({ chitchat: true })).toBe("");
-  });
-
-  it("is empty when disabled via env override", () => {
-    process.env.MUONROI_DISABLE_AGENT_CONTRACT = "1";
-    expect(buildContractSection()).toBe("");
-    expect(buildContractSection({ chitchat: false })).toBe("");
-  });
-});

package/src/pil/agent-operating-contract.ts

@@ -1,70 +0,0 @@
-/**
- * src/pil/agent-operating-contract.ts
- *
- * The Agent Operating Contract — a compact, phase-keyed behavioural prelude
- * placed at the FRONT of the system prompt for EVERY tier (not just fast).
- *
- * Motivation. The anti-hallucination principle already exists in the repo
- * conventions (AGENTS.md "Evidence-First Rule") and IS loaded into the runtime
- * system prompt via loadCustomInstructions → the CUSTOM INSTRUCTIONS section.
- * But that section lands AFTER the (large) mode prompt, buried inside the
- * concatenated AGENTS.md + CLAUDE.md text. Live forensics (deepseek-v4-flash
- * repo-eval, session 17fc23f0) showed the model fabricate a test count (claimed
- * 67, actual 401) and invent a bug with fake file:line refs DESPITE the rule
- * being present — the classic primacy problem the cheap-model playbook already
- * documents: rules that are not front-loaded get underweighted.
- *
- * So this contract does NOT introduce new rules. It DISTILS the rules that are
- * already scattered across AGENTS.md (Evidence-First, No Silent Catch), the
- * cheap-model playbook (tool-use), and the grounding clause (#39) into one
- * short, ordered-by-work-phase block positioned for maximum primacy.
- *
- * Layering note. For fast-tier models the cheap-model shell line / playbook /
- * workbook are prepended in message-processor AFTER buildSystemPrompt returns,
- * so they sit IN FRONT of this contract. That is intentional: fast tier keeps
- * its detailed, proven tool-use prelude at the very front; this contract adds
- * the same discipline for balanced/premium tiers (which otherwise only had the
- * buried CUSTOM INSTRUCTIONS copy). The grounding clause therefore lives in
- * BOTH the fast-tier workbook (front-most for fast tier) and this contract
- * (front-most for every other tier) — minor duplication accepted as cheap
- * insurance against primacy loss; see cheap-model-workbooks.ts.
- *
- * Escape hatch: MUONROI_DISABLE_AGENT_CONTRACT=1.
- */
-
-/**
- * The contract text. Ordered by the phase of work an agent moves through:
- * BEFORE ACTING → READING → EXECUTING → WHEN UNSURE → REPORTING. Each phase is
- * one imperative line targeting that phase's most damaging failure mode. Kept
- * tight (primacy matters more than detail; tokens are the cost).
- */
-export const AGENT_OPERATING_CONTRACT = `[AGENT OPERATING CONTRACT — read first; applies to every step]
-
-1. BEFORE ACTING: do only what was asked. Never assume scope or facts — if ambiguous, ask or use defaults; never invent requirements.
-2. READING: base statements on what you read/ran THIS turn. Do not infer contents of files you did not open.
-3. EXECUTING: smallest correct change; never widen scope or mask failures (no \`|| true\`, skipped tests, or swallowed catch).
-4. WHEN UNSURE: verify and cross-check BEFORE concluding. Bugs need a reproduction; reading code is not proof.
-5. REPORTING: answer ONLY what was asked. Every fact or file:line MUST come from this turn; else label "unverified"; do not guess. Synthesize evidence gracefully — do NOT dump massive verbatim tool outputs into the final answer. Cite concise file:line references. Never claim a build/test ran, or describe edits, you did not actually do this turn; if a check can't run, fix it or say so — don't imply success.
-
-6. LANGUAGE: Reply in user's detected language for final output. Internal reasoning, tools, and code remain in English.
-
-7. ANTI-MÙ / COMPACTION: After seeing "[pre-compaction warning at step..." or "[context compacted at step...", decide if you need full prior tool results. Emit PRESERVE_FULL_CONTEXT for full veto this turn, or the lighter KEEP_TOOL_IDS: id1,id2 (ids from prior stub "(id=...)") to protect only high-value results (read_file/grep on src/PLAN/error etc are auto-protected). Use the ee_query tool with "tool-artifact id=XXX" for on-demand full re-hydrate of elided ones. Self-check "task finished?" / "compacted yet?". Use EE checkpoints.
-
-[END CONTRACT — instructions follow]`;
-
-export interface ContractSectionOptions {
-  /** Chitchat turns carry no tools and make no factual claims — skip the contract. */
-  chitchat?: boolean;
-}
-
-/**
- * Build the contract block for insertion at the front of the system prompt.
- * Returns "" when disabled (env override) or for chitchat turns; otherwise the
- * contract followed by a blank-line separator so it sits cleanly before the
- * mode prompt.
- */
-export function buildContractSection(options?: ContractSectionOptions): string {
-  if (process.env.MUONROI_DISABLE_AGENT_CONTRACT === "1") return "";
-  if (options?.chitchat === true) return "";
-  return `${AGENT_OPERATING_CONTRACT}\n\n`;
-}

package/src/pil/budget-log.ts

@@ -1,86 +0,0 @@
-import { promises as fs } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import type { IntentDetectionTrace } from "./types.js";
-
-export type IntentTraceSnapshot = IntentDetectionTrace;
-
-export interface PilLayerSnapshot {
-  name: string;
-  charsBefore: number;
-  charsAfter: number;
-  charsDelta: number;
-  durationMs: number;
-}
-
-export interface PilBudgetLogEntry {
-  ts: number;
-  sessionId: string | null;
-  taskType: string | null;
-  domain: string | null;
-  confidence: number;
-  rawChars: number;
-  enrichedChars: number;
-  totalDeltaChars: number;
-  totalMs: number;
-  layers: PilLayerSnapshot[];
-  fallbackReason: string | null;
-  intentDetection: IntentTraceSnapshot | null;
-}
-
-function muonroiHome(): string {
-  return process.env.MUONROI_CLI_HOME ?? path.join(os.homedir(), ".muonroi-cli");
-}
-
-function todayUtc(): string {
-  const d = new Date();
-  return `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, "0")}-${String(d.getUTCDate()).padStart(2, "0")}`;
-}
-
-function logDir(): string {
-  return path.join(muonroiHome(), "pil");
-}
-
-function logPath(date: string): string {
-  return path.join(logDir(), `budget-log-${date}.jsonl`);
-}
-
-export async function appendPilLog(entry: Record<string, unknown>): Promise<void> {
-  try {
-    await fs.mkdir(logDir(), { recursive: true });
-    await fs.appendFile(logPath(todayUtc()), `${JSON.stringify(entry)}\n`, "utf8");
-  } catch {
-    // best-effort, never throw
-  }
-}
-
-export async function listPilLogDates(): Promise<string[]> {
-  try {
-    const files = await fs.readdir(logDir());
-    return files
-      .filter((f) => f.startsWith("budget-log-") && f.endsWith(".jsonl"))
-      .map((f) => f.slice("budget-log-".length, -".jsonl".length))
-      .sort();
-  } catch {
-    return [];
-  }
-}
-
-export async function readPilLog(date: string): Promise<PilBudgetLogEntry[]> {
-  try {
-    const text = await fs.readFile(logPath(date), "utf8");
-    const out: PilBudgetLogEntry[] = [];
-    for (const line of text.split("\n")) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      try {
-        out.push(JSON.parse(trimmed) as PilBudgetLogEntry);
-      } catch {
-        // skip corrupt line
-      }
-    }
-    return out;
-  } catch {
-    return [];
-  }
-}

package/src/pil/budget.ts

@@ -1,18 +0,0 @@
-/**
- * src/pil/budget.ts
- *
- * Token budget utilities for Layer 3-5 context enrichment.
- * Prevents context bloat by enforcing character limits on injected content.
- */
-
-export const DEFAULT_TOKEN_BUDGET = 500;
-
-const CHARS_PER_TOKEN = 4;
-
-export function truncateToBudget(text: string, budgetTokens: number): string {
-  const maxChars = budgetTokens * CHARS_PER_TOKEN;
-  if (text.length <= maxChars) return text;
-  const truncated = text.slice(0, maxChars);
-  const lastSpace = truncated.lastIndexOf(" ");
-  return `${lastSpace > maxChars * 0.8 ? truncated.slice(0, lastSpace) : truncated}...`;
-}

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

@@ -1,191 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import type { ModelInfo } from "../types/index.js";
-import {
-  appendCheapModelPlaybook,
-  CHEAP_MODEL_PLAYBOOK,
-  cheapModelShellLine,
-  injectCheapModelPlaybook,
-  injectCheapModelShellDirective,
-  shouldInjectCheapModelPlaybook,
-} from "./cheap-model-playbook.js";
-
-const baseInfo = {
-  id: "x",
-  name: "x",
-  description: "",
-  provider: "x",
-  contextWindow: 100_000,
-} as const;
-
-function info(tier: ModelInfo["tier"]): ModelInfo {
-  return { ...baseInfo, tier } as unknown as ModelInfo;
-}
-
-describe("shouldInjectCheapModelPlaybook", () => {
-  let savedEnv: string | undefined;
-  beforeEach(() => {
-    savedEnv = process.env.MUONROI_DISABLE_CHEAP_MODEL_PLAYBOOK;
-    delete process.env.MUONROI_DISABLE_CHEAP_MODEL_PLAYBOOK;
-  });
-  afterEach(() => {
-    if (savedEnv === undefined) delete process.env.MUONROI_DISABLE_CHEAP_MODEL_PLAYBOOK;
-    else process.env.MUONROI_DISABLE_CHEAP_MODEL_PLAYBOOK = savedEnv;
-  });
-
-  it("fires on fast tier", () => {
-    expect(shouldInjectCheapModelPlaybook(info("fast"))).toBe(true);
-  });
-
-  it("does NOT fire on balanced tier", () => {
-    expect(shouldInjectCheapModelPlaybook(info("balanced"))).toBe(false);
-  });
-
-  it("does NOT fire on premium tier", () => {
-    expect(shouldInjectCheapModelPlaybook(info("premium"))).toBe(false);
-  });
-
-  it("does NOT fire when modelInfo is undefined", () => {
-    expect(shouldInjectCheapModelPlaybook(undefined)).toBe(false);
-  });
-
-  it("does NOT fire when tier is absent on ModelInfo", () => {
-    const noTier = { ...baseInfo } as unknown as ModelInfo;
-    expect(shouldInjectCheapModelPlaybook(noTier)).toBe(false);
-  });
-
-  it("env override disables for fast tier", () => {
-    process.env.MUONROI_DISABLE_CHEAP_MODEL_PLAYBOOK = "1";
-    expect(shouldInjectCheapModelPlaybook(info("fast"))).toBe(false);
-  });
-
-  it("env override with non-'1' value does not disable", () => {
-    process.env.MUONROI_DISABLE_CHEAP_MODEL_PLAYBOOK = "0";
-    expect(shouldInjectCheapModelPlaybook(info("fast"))).toBe(true);
-    process.env.MUONROI_DISABLE_CHEAP_MODEL_PLAYBOOK = "true";
-    expect(shouldInjectCheapModelPlaybook(info("fast"))).toBe(true);
-  });
-});
-
-describe("injectCheapModelPlaybook", () => {
-  it("PREPENDS the playbook so it lands at the front of attention", () => {
-    const out = injectCheapModelPlaybook("You are an agent.");
-    expect(out).toBe(`${CHEAP_MODEL_PLAYBOOK}You are an agent.`);
-    // Primacy property — system prompt now opens with the CRITICAL marker.
-    expect(out.startsWith("[CRITICAL TOOL-USE RULES")).toBe(true);
-  });
-
-  it("is idempotent — passing already-prefixed prompt returns it unchanged", () => {
-    const once = injectCheapModelPlaybook("Sys.");
-    const twice = injectCheapModelPlaybook(once);
-    expect(twice).toBe(once);
-  });
-
-  it("playbook content mentions the four key tool steering rules", () => {
-    expect(CHEAP_MODEL_PLAYBOOK).toContain("bash_output_get");
-    expect(CHEAP_MODEL_PLAYBOOK).toMatch(/task\(agent="explore"\)/);
-    expect(CHEAP_MODEL_PLAYBOOK).toContain("grep");
-    expect(CHEAP_MODEL_PLAYBOOK).toMatch(/ERROR/);
-  });
-
-  it("rule 1 wording now applies to every bash call (not just retries)", () => {
-    // Live forensics showed cheap models rationalized that the first call
-    // isn't a re-run, so the "NEVER re-run" wording let them skip the rule.
-    // The new wording explicitly says EVERY bash call.
-    expect(CHEAP_MODEL_PLAYBOOK).toMatch(/EVERY bash call/i);
-    expect(CHEAP_MODEL_PLAYBOOK).toMatch(/do NOT pipe.*tail/i);
-  });
-
-  it("steers fix QUALITY: root-cause over masking (rule 5) and read real failure logs (rule 6)", () => {
-    // Grounded in a live observation (gpt-5.4-mini self-fixing a failing CI
-    // workflow): the cheap model masked the failure with `continue-on-error:
-    // true` instead of guarding the missing-secret root cause, and never read
-    // the actual run log. These two rules steer fast-tier models away from
-    // symptom-masking and toward evidence-first root-cause fixes.
-    expect(CHEAP_MODEL_PLAYBOOK).toMatch(/root cause/i);
-    expect(CHEAP_MODEL_PLAYBOOK).toContain("continue-on-error");
-    expect(CHEAP_MODEL_PLAYBOOK).toMatch(/CONDITIONAL|skip when absent/i);
-    expect(CHEAP_MODEL_PLAYBOOK).toMatch(/failure (log|output)|run log/i);
-    expect(CHEAP_MODEL_PLAYBOOK).toMatch(/before .*hypothesi/i);
-  });
-
-  it("playbook stays short (under 1800 chars) to preserve attention budget", () => {
-    // Bumped 1500 → 1600 (rules 5/6 fix-quality) → 1800 (rule 1 file-viewing
-    // clause, A1: kills the observed read_file+sed double-read). Still a tight
-    // prelude; primacy placement matters more than absolute length.
-    expect(CHEAP_MODEL_PLAYBOOK.length).toBeLessThan(2500);
-  });
-
-  it("deprecated appendCheapModelPlaybook alias still works (now actually prepends)", () => {
-    const out = appendCheapModelPlaybook("Sys.");
-    expect(out).toBe(`${CHEAP_MODEL_PLAYBOOK}Sys.`);
-  });
-
-  it("steers file-VIEWING to read_file, not a redundant bash sed/cat (A1 anti-redundancy)", () => {
-    // Live observation (workbook run 3308b3d02e11): gpt-5.4-mini read the same
-    // lines TWICE — once via read_file(60-95), once via `sed -n '60,95p'`. The
-    // ENVIRONMENT block legitimises sed as "POSIX-OK" while the playbook only
-    // forbade PIPING output. The missing rule: viewing a file is read_file's
-    // job; bash_output_get is for COMMAND output, not files.
-    expect(CHEAP_MODEL_PLAYBOOK).toContain("read_file");
-    expect(CHEAP_MODEL_PLAYBOOK).toMatch(/never[\s`]*sed|do NOT[\s`]*sed/i);
-    expect(CHEAP_MODEL_PLAYBOOK).toMatch(/COMMAND output/i);
-  });
-});
-
-describe("cheapModelShellLine (A2 — front-loaded env/shell directive)", () => {
-  it("POSIX bash: demands POSIX commands, forbids PowerShell/cmd, names the OS", () => {
-    const line = cheapModelShellLine("bash", "win32");
-    expect(line).toMatch(/POSIX/);
-    expect(line).toMatch(/Windows/);
-    expect(line).toMatch(/NEVER|do not|don't/i);
-    expect(line).toMatch(/PowerShell|cmd/);
-    // single line — front-loaded primacy, token-frugal
-    expect(line).not.toContain("\n");
-  });
-
-  it("WSL is treated as POSIX too", () => {
-    expect(cheapModelShellLine("wsl", "win32")).toMatch(/POSIX/);
-  });
-
-  it("PowerShell: demands cmdlets, forbids POSIX grep/sed/awk", () => {
-    const line = cheapModelShellLine("powershell", "win32");
-    expect(line).toMatch(/PowerShell|cmdlet/i);
-    expect(line).toMatch(/Select-String|Get-ChildItem/);
-    expect(line).toMatch(/NEVER|do not|don't/i);
-    expect(line).toMatch(/grep|sed|awk|POSIX/);
-  });
-
-  it("cmd.exe: demands cmd syntax, forbids POSIX and PowerShell", () => {
-    const line = cheapModelShellLine("cmd", "win32");
-    expect(line).toMatch(/cmd/i);
-    expect(line).toMatch(/dir|type|copy/);
-    expect(line).toMatch(/NEVER|do not|don't/i);
-  });
-
-  it("maps platform to a human OS name", () => {
-    expect(cheapModelShellLine("bash", "linux")).toMatch(/Linux/);
-    expect(cheapModelShellLine("bash", "darwin")).toMatch(/macOS/);
-  });
-
-  it("auto/unknown kind stays conservative — does not assert a syntax it cannot confirm", () => {
-    const line = cheapModelShellLine("auto", "win32");
-    // Must NOT claim a definite POSIX/PowerShell/cmd syntax when undetermined.
-    expect(line).toMatch(/confirm|ENVIRONMENT/i);
-  });
-});
-
-describe("injectCheapModelShellDirective (A2 wiring)", () => {
-  it("prepends the shell line at the very front, ahead of the playbook", () => {
-    const line = cheapModelShellLine("powershell", "win32");
-    const sys = injectCheapModelShellDirective("Body.", line);
-    expect(sys.startsWith(line)).toBe(true);
-    expect(sys).toContain("Body.");
-  });
-
-  it("is idempotent — re-injecting the same directive does not double-stack", () => {
-    const line = cheapModelShellLine("bash", "linux");
-    const once = injectCheapModelShellDirective("Body.", line);
-    const twice = injectCheapModelShellDirective(once, line);
-    expect(twice).toBe(once);
-  });
-});