muonroi-cli 1.8.0 → 1.8.3

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

@@ -1,89 +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");
-    });
-});
-//# sourceMappingURL=scoreSufficiency.test.js.map

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

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

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

@@ -1,44 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getPilLastResult, setPilLastResult } from "../store.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) => ({
-    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");
-    });
-});
-//# sourceMappingURL=store.test.js.map

package/dist/src/pil/__tests__/surface-compaction-artifacts.test.d.ts

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

package/dist/src/pil/__tests__/surface-compaction-artifacts.test.js

@@ -1,112 +0,0 @@
-import { beforeEach, describe, expect, test, vi } from "vitest";
-import { surfaceCompactionArtifacts } from "../layer3-ee-injection.js";
-// Issue #4 — targeted complement to layer3's checkpoint arm on meta turns.
-// layer3 (now run on meta after issue #2) surfaces checkpoints via a FIXED
-// recency query; this arm searches by the meta question (ctx.raw) to surface the
-// elided tool-artifacts relevant to it, and DEFERS when layer3 already injected a
-// checkpoint block. Mock the EE search + the audit log so the test stays offline.
-vi.mock("../../ee/bridge.js", () => ({
-    searchByText: vi.fn().mockResolvedValue([]),
-}));
-vi.mock("../../storage/interaction-log.js", () => ({
-    logInteraction: vi.fn(),
-}));
-import { searchByText } from "../../ee/bridge.js";
-function makeCtx(overrides = {}) {
-    return {
-        raw: "compaction cần cải thiện gì trong CLI",
-        enriched: "compaction cần cải thiện gì trong CLI",
-        taskType: "general",
-        domain: null,
-        confidence: 0.85,
-        outputStyle: "balanced",
-        tokenBudget: 2000,
-        metrics: null,
-        layers: [],
-        sessionId: "sess-meta-1",
-        ...overrides,
-    };
-}
-const artifactPoint = {
-    id: "art1",
-    score: 0.9,
-    payload: {
-        text: "tool-artifact id=call_7 toolName=read_file elided 4200 chars: src/orchestrator/compaction.ts createCompactionSummaryMessage ...",
-    },
-    collection: "experience-behavioral",
-};
-const checkpointPoint = {
-    id: "cp1",
-    score: 0.8,
-    payload: { text: "Context checkpoint summary ✔ DONE: extended IMPORTANT_TOOL_NAMES; tests 16/16" },
-    collection: "experience-behavioral",
-};
-const genericPoint = {
-    id: "gen1",
-    score: 0.97,
-    payload: { text: "Always run the full test suite before pushing" },
-    collection: "experience-behavioral",
-};
-describe("surfaceCompactionArtifacts (issue #4 — meta-turn auto-surface)", () => {
-    beforeEach(() => {
-        vi.mocked(searchByText).mockReset();
-        vi.mocked(searchByText).mockResolvedValue([]);
-    });
-    test("auto-surfaces [artifact] + checkpoint refs (and the rehydrate instruction) into enriched", async () => {
-        // biome-ignore lint/suspicious/noExplicitAny: test fixture shape mirrors EEPoint
-        vi.mocked(searchByText).mockResolvedValue([artifactPoint, checkpointPoint]);
-        const ctx = makeCtx();
-        const out = await surfaceCompactionArtifacts(ctx);
-        expect(out.enriched).toContain("[artifact]"); // artifact-typed line
-        expect(out.enriched).toContain("ee.query tool"); // how to rehydrate the full output
-        expect(out.enriched).toContain("call_7"); // the concrete tool-artifact id the agent can fetch
-        const layer = out.layers.find((l) => l.name === "ee-meta-artifacts");
-        expect(layer?.applied).toBe(true);
-        expect(layer?.delta).toContain("artifacts=2");
-        // Searches only the behavioral collection (where tool-artifacts are persisted).
-        expect(vi.mocked(searchByText)).toHaveBeenCalledWith(expect.stringContaining("tool-artifact"), ["experience-behavioral"], expect.any(Number), expect.any(Object));
-    });
-    test("no sessionId → unchanged, no EE call (no prior compaction to rehydrate)", async () => {
-        const ctx = makeCtx({ sessionId: undefined });
-        const out = await surfaceCompactionArtifacts(ctx);
-        expect(out.enriched).toBe(ctx.enriched);
-        expect(out.layers.find((l) => l.name === "ee-meta-artifacts")?.delta).toBe("no-session");
-        expect(vi.mocked(searchByText)).not.toHaveBeenCalled();
-    });
-    test("search failure is fail-open + recorded (delta=error=…, enriched unchanged)", async () => {
-        vi.mocked(searchByText).mockRejectedValue(new Error("EE down"));
-        const ctx = makeCtx();
-        const out = await surfaceCompactionArtifacts(ctx);
-        expect(out.enriched).toBe(ctx.enriched);
-        expect(out.layers.find((l) => l.name === "ee-meta-artifacts")?.delta).toMatch(/^error=/);
-    });
-    test("generic behavioral hits are filtered out (not mislabelled as artifacts)", async () => {
-        // biome-ignore lint/suspicious/noExplicitAny: test fixture shape mirrors EEPoint
-        vi.mocked(searchByText).mockResolvedValue([genericPoint]);
-        const ctx = makeCtx();
-        const out = await surfaceCompactionArtifacts(ctx);
-        expect(out.enriched).toBe(ctx.enriched);
-        expect(out.layers.find((l) => l.name === "ee-meta-artifacts")?.delta).toBe("no-artifacts");
-    });
-    test("defers to layer3 — skips with NO EE call when a checkpoint block is already present", async () => {
-        // layer3 ran first this turn and injected a checkpoint block (its marker is
-        // in enriched). The complement must not duplicate it or pay a 2nd round-trip.
-        const enriched = `${makeCtx().raw}\n[task checkpoints …]\n<!-- ee-checkpoint-injected:0123456789abcdef -->`;
-        const out = await surfaceCompactionArtifacts(makeCtx({ enriched }));
-        expect(out.layers.find((l) => l.name === "ee-meta-artifacts")?.delta).toBe("already-surfaced");
-        expect(out.enriched).toBe(enriched); // unchanged
-        expect(vi.mocked(searchByText)).not.toHaveBeenCalled();
-    });
-    test("idempotent — a second pass on its own output defers (marker it wrote is seen)", async () => {
-        // biome-ignore lint/suspicious/noExplicitAny: test fixture shape mirrors EEPoint
-        vi.mocked(searchByText).mockResolvedValue([artifactPoint]);
-        const first = await surfaceCompactionArtifacts(makeCtx());
-        expect(first.enriched).toContain("[artifact]");
-        expect(vi.mocked(searchByText)).toHaveBeenCalledTimes(1);
-        const second = await surfaceCompactionArtifacts(makeCtx({ enriched: first.enriched }));
-        expect(second.layers.find((l) => l.name === "ee-meta-artifacts")?.delta).toBe("already-surfaced");
-        expect(second.enriched).toBe(first.enriched); // not grown a second time
-        expect(vi.mocked(searchByText)).toHaveBeenCalledTimes(1); // no second round-trip
-    });
-});
-//# sourceMappingURL=surface-compaction-artifacts.test.js.map

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

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

package/dist/src/pil/__tests__/task-tier-map.test.js

@@ -1,33 +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");
-    });
-});
-//# sourceMappingURL=task-tier-map.test.js.map

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

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

package/dist/src/pil/agent-operating-contract.test.js

@@ -1,80 +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("carries the git-safety rule (never push on red; no broad git add of secrets)", () => {
-        expect(AGENT_OPERATING_CONTRACT).toMatch(/GIT SAFETY/i);
-        expect(AGENT_OPERATING_CONTRACT).toMatch(/push on red|never push/i);
-        expect(AGENT_OPERATING_CONTRACT).toMatch(/git add -A|stage explicitly/i);
-    });
-    it("stays compact (under 2000 chars) to preserve attention budget on every turn (git-safety rule added)", () => {
-        expect(AGENT_OPERATING_CONTRACT.length).toBeLessThan(2000);
-    });
-});
-describe("buildContractSection", () => {
-    let saved;
-    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("");
-    });
-});
-//# sourceMappingURL=agent-operating-contract.test.js.map

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

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

package/dist/src/pil/cheap-model-playbook.test.js

@@ -1,160 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-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,
-};
-function info(tier) {
-    return { ...baseInfo, tier };
-}
-describe("shouldInjectCheapModelPlaybook", () => {
-    let savedEnv;
-    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 };
-        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);
-    });
-});
-//# sourceMappingURL=cheap-model-playbook.test.js.map

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

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