muonroi-cli 1.8.1 → 1.8.4

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 {};

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

@@ -1,129 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-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 };
-const info = (tier) => ({ ...base, tier });
-describe("shouldInjectCheapModelWorkbook", () => {
-    let saved;
-    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);
-    });
-});
-//# sourceMappingURL=cheap-model-workbooks.test.js.map

package/dist/src/pil/layer1-intent.test.d.ts

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