muonroi-cli 1.3.4 → 1.4.1

package/dist/src/pil/__tests__/layer3-ee-injection.test.js

@@ -104,7 +104,10 @@ describe("layer3EeInjection (bridge-based)", () => {
         // New behavior: two parallel calls, one per collection (different score floors).
         expect(vi.mocked(searchByText)).toHaveBeenCalledWith(expect.any(String), ["experience-principles"], expect.any(Number), expect.any(Object));
         expect(vi.mocked(searchByText)).toHaveBeenCalledWith(expect.any(String), ["experience-behavioral"], expect.any(Number), expect.any(Object));
-        expect(vi.mocked(searchByText)).toHaveBeenCalledTimes(2);
+        // Phase 3 ee-anti-mu + upgrade: third call for compaction checkpoints (targeted query on behavioral collection).
+        // Now lower score floor (0.7) + explicit PRESERVE/ee.query in contract/playbook + unconditional layer1 enrichment for sessionId turns.
+        expect(vi.mocked(searchByText)).toHaveBeenCalledWith(expect.stringContaining("Context checkpoint summary"), ["experience-behavioral"], expect.any(Number), expect.any(Object));
+        expect(vi.mocked(searchByText)).toHaveBeenCalledTimes(3);
     });
 });
 describe("Layer 3 formatter mode (ctx._brainData populated)", () => {

package/dist/src/pil/__tests__/layer3-injected-chunk.test.js

@@ -56,9 +56,9 @@ describe("layer3 experience_injected chunk emission (CQ-16b)", () => {
         expect(injectedChunk).toBeDefined();
         expect(injectedChunk?.type).toBe("experience_injected");
         // New behavior: queryEeBridge issues 2 parallel calls (principles + behavioral).
-        // The shared mock returns the same point for both, so it surfaces in both
-        // collections (passes principles floor 0.40 and behavioral floor 0.55).
-        expect(injectedChunk?.experienceInjected?.pointCount).toBe(2);
+        // The shared mock returns the same point for all three arms (principles,
+        // behavioral, checkpoints).
+        expect(injectedChunk?.experienceInjected?.pointCount).toBe(3);
         expect(injectedChunk?.experienceInjected?.pointIds).toContain("point-1");
     });
     it("experience_injected chunk carries scoreFloor as a number", async () => {

package/dist/src/pil/__tests__/layer6-output.test.js

@@ -61,6 +61,18 @@ describe("applyPilSuffix — per-task-type suffixes", () => {
         expect(result).not.toMatch(/OUTPUT BUDGET/);
         expect(result).not.toMatch(/FORBIDDEN OPENERS/);
     });
+    it("general response-tool turn appends the human-UX note + no-footer clause (session 9e3fb3e2e0c9)", () => {
+        // A general/question response-tool turn must steer the answer toward a
+        // human reader: lead with the answer, no implementation plan, no process
+        // narration, and crucially NO evidence-provenance footer ("all facts from
+        // this turn / did not infer unopened files") — that compliance bookkeeping
+        // leaked into the user-facing reply.
+        const result = applyPilSuffix("S", makeCtx("general", "concise"), true);
+        expect(result).toContain("respond_general");
+        expect(result).toMatch(/for the HUMAN who asked/);
+        expect(result).toMatch(/do NOT narrate your own process/);
+        expect(result).toMatch(/Do NOT append an evidence-provenance footer/);
+    });
 });
 describe("getResponseToolSet — PIL-04 Tier 1.1 gating", () => {
     it("returns response tool for analyze (list-shaped, JSON wins)", () => {
@@ -101,26 +113,71 @@ describe("getResponseToolSet — PIL-04 Tier 1.1 gating", () => {
     it("returns empty toolset when taskType is null", () => {
         expect(getResponseToolSet(makeCtx(null, null))).toEqual({});
     });
+    it("drops respond_<task> on an IMPLEMENTATION-intent prompt (no premature terminal answer)", () => {
+        // Live (grok session 19fa8895c41c): an "Improve … implement these fixes"
+        // prompt classified `debug` got respond_debug; the model called it mid-task
+        // as a plan and the turn ended before the edits completed. Implementation
+        // turns must fall through to markdown OUTPUT RULES, not a terminal tool.
+        const impl = (raw, t) => ({ ...makeCtx(t, null), raw });
+        expect(getResponseToolSet(impl("Improve the story-list screen. Implement these prioritized fixes: …", "debug"))).toEqual({});
+        expect(getResponseToolSet(impl("Edit ONLY these two files and fix the empty span", "debug"))).toEqual({});
+        expect(getResponseToolSet(impl("refactor the genre dropdown and wire up keyboard handlers", "analyze"))).toEqual({});
+        expect(getResponseToolSet(impl("triển khai các cải tiến đã đề xuất", "plan"))).toEqual({});
+    });
+    it("KEEPS respond_<task> for pure analysis/plan prompts (narrowness guard)", () => {
+        // The deliverable here IS a structured report — must not be suppressed.
+        const ana = (raw, t) => ({ ...makeCtx(t, null), raw });
+        expect(Object.keys(getResponseToolSet(ana("analyze the orchestrator for cost leaks", "analyze")))).toContain("respond_analyze");
+        expect(Object.keys(getResponseToolSet(ana("why does the build fail intermittently?", "debug")))).toContain("respond_debug");
+        expect(Object.keys(getResponseToolSet(ana("plan the migration to the new auth flow", "plan")))).toContain("respond_plan");
+        expect(Object.keys(getResponseToolSet(ana("review the auth module and explain the design", "analyze")))).toContain("respond_analyze");
+    });
 });
 describe("applyPilSuffix — outputStyle variants", () => {
     const styles = ["concise", "detailed", "balanced"];
-    it("each style produces a different suffix for the same taskType", () => {
-        const suffixes = styles.map((s) => applyPilSuffix("", makeCtx("refactor", s)));
+    it("each style produces a different suffix for the same taskType (using non-action task)", () => {
+        // Action tasks (debug/refactor/generate) coerce style=detailed → concise
+        // unless the prompt literally asks for detail, so they only have 2 distinct
+        // suffix shapes from the 3 inputs. Use a non-action task (plan) to verify
+        // style variants are still routed through.
+        const suffixes = styles.map((s) => applyPilSuffix("", makeCtx("plan", s)));
         const unique = new Set(suffixes);
         expect(unique.size).toBe(styles.length);
     });
-    it.each(styles)("detailed suffix is longer than concise for taskType=debug (style=%s check)", (style) => {
+    it.each(styles)("debug suffix always present for style=%s", (style) => {
         const result = applyPilSuffix("", makeCtx("debug", style));
         expect(result).toContain("OUTPUT RULES (debug)");
     });
-    it("detailed suffix allows explanation", () => {
-        const result = applyPilSuffix("", makeCtx("refactor", "detailed"));
+    it("detailed suffix allows explanation on non-action task (plan)", () => {
+        // Action-task coercion: refactor+detailed → concise (no "full rationale").
+        // The behavior we care about — that "detailed" really carries through to a
+        // longer suffix — is still observable on plan.
+        const result = applyPilSuffix("", makeCtx("plan", "detailed"));
         expect(result).toContain("full rationale");
     });
     it("concise suffix restricts prose", () => {
         const result = applyPilSuffix("", makeCtx("refactor", "concise"));
         expect(result).toContain("No prose");
     });
+    it("coerces refactor+detailed → concise when prompt has no detail-request keywords (session 127140a47b56)", () => {
+        const ctx = makeCtx("refactor", "detailed");
+        ctx.raw = "rename foo to bar across the repo";
+        const result = applyPilSuffix("", ctx);
+        expect(result).toContain("No prose");
+        expect(result).not.toContain("full rationale");
+    });
+    it("honors refactor+detailed when the prompt explicitly asks for detail", () => {
+        const ctx = makeCtx("refactor", "detailed");
+        ctx.raw = "refactor this module and explain in detail what you changed";
+        const result = applyPilSuffix("", ctx);
+        expect(result).toContain("full rationale");
+    });
+    it("honors refactor+detailed when the Vietnamese prompt asks for chi tiết", () => {
+        const ctx = makeCtx("refactor", "detailed");
+        ctx.raw = "refactor module này và giải thích chi tiết cho tôi";
+        const result = applyPilSuffix("", ctx);
+        expect(result).toContain("full rationale");
+    });
 });
 describe("layer6Output — style resolution", () => {
     beforeEach(() => {
@@ -150,10 +207,12 @@ describe("layer6Output — style resolution", () => {
         expect(result.layers[0].delta).toContain("style=detailed");
         expect(result.layers[0].delta).toContain("src=brain-rescue");
     });
-    it("PIL-03b: uses task-type heuristic when brain returns null (debug→balanced)", async () => {
+    // PIL-L6 verbosity fix — debug default flipped to "concise" to stop the
+    // model from padding root-cause analysis with rationale prose.
+    it("PIL-03b: uses task-type heuristic when brain returns null (debug→concise)", async () => {
         const result = await layer6Output(makeCtx("debug", null));
-        expect(result.outputStyle).toBe("balanced");
-        expect(result.layers[0].delta).toContain("style=balanced");
+        expect(result.outputStyle).toBe("concise");
+        expect(result.layers[0].delta).toContain("style=concise");
         expect(result.layers[0].delta).toContain("src=task-heuristic");
     });
     it("PIL-03b: task-heuristic for plan→balanced (not detailed — avoids generating extra sections)", async () => {
@@ -181,9 +240,10 @@ describe("layer6Output — style resolution", () => {
         expect(brain).not.toHaveBeenCalled();
     });
     it("PIL-03: resolved outputStyle propagated back onto ctx", async () => {
+        // PIL-L6 verbosity fix — analyze default also flipped to "concise".
         const result = await layer6Output(makeCtx("analyze", null));
         expect(result.outputStyle).not.toBeNull();
-        expect(result.outputStyle).toBe("balanced");
+        expect(result.outputStyle).toBe("concise");
     });
 });
 describe("layer6Output", () => {

package/dist/src/pil/__tests__/llm-classify.test.d.ts

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

package/dist/src/pil/__tests__/llm-classify.test.js

@@ -0,0 +1,113 @@
+import { afterEach, beforeAll, describe, expect, it } from "vitest";
+import { installMockModel, textOnlyStream } from "../../agent-harness/mock-model.js";
+import { loadCatalog } from "../../models/registry.js";
+import { createLlmClassifier } from "../llm-classify.js";
+describe("createLlmClassifier (PIL Layer 1 Pass 4)", () => {
+    beforeAll(async () => {
+        await loadCatalog();
+    });
+    let cleanup = null;
+    afterEach(() => {
+        cleanup?.();
+        cleanup = null;
+    });
+    it("parses a clean two-word reply into TaskType + style", async () => {
+        const handle = installMockModel({ fixture: { stream: textOnlyStream("debug,concise") } });
+        cleanup = handle.uninstall;
+        // Build a stub factory — installMockModel routes everything through the mock anyway.
+        const factory = (() => handle.model);
+        const classify = createLlmClassifier(factory, "deepseek-v4-flash");
+        const result = await classify("ci action github fail, fix giúp tôi");
+        expect(result).not.toBeNull();
+        expect(result?.taskType).toBe("debug");
+        expect(result?.outputStyle).toBe("concise");
+        expect(result?.confidence).toBeGreaterThan(0.5);
+    });
+    it("returns null when the reply cannot be parsed", async () => {
+        const handle = installMockModel({ fixture: { stream: textOnlyStream("¯\\_(ツ)_/¯") } });
+        cleanup = handle.uninstall;
+        const factory = (() => handle.model);
+        const classify = createLlmClassifier(factory, "deepseek-v4-flash");
+        const result = await classify("hello");
+        expect(result).toBeNull();
+    });
+    it("accepts a taskType-only reply (style optional)", async () => {
+        const handle = installMockModel({ fixture: { stream: textOnlyStream("plan") } });
+        cleanup = handle.uninstall;
+        const factory = (() => handle.model);
+        const classify = createLlmClassifier(factory, "deepseek-v4-flash");
+        const result = await classify("design a sharded queue");
+        expect(result?.taskType).toBe("plan");
+        expect(result?.outputStyle).toBeNull();
+    });
+    it("ignores noisy formatting (markdown, quotes, newlines)", async () => {
+        const handle = installMockModel({
+            fixture: { stream: textOnlyStream('**"refactor, balanced"**\n\nrationale: ...') },
+        });
+        cleanup = handle.uninstall;
+        const factory = (() => handle.model);
+        const classify = createLlmClassifier(factory, "deepseek-v4-flash");
+        const result = await classify("tái cấu trúc auth module");
+        expect(result?.taskType).toBe("refactor");
+        expect(result?.outputStyle).toBe("balanced");
+    });
+    // Reasoning models (grok-4.3, deepseek-v4-flash) consumed the doomed 16-token
+    // budget on reasoning tokens FIRST → emitted zero text-delta → parseResponse
+    // saw "" → returned null. 5/5 live grok sessions showed `llm=fail`. Fix: give
+    // reasoning models a real output budget + force the lowest reasoning effort the
+    // provider supports, so the 2-word answer actually streams back.
+    it("gives a reasoning model a real output budget (not the doomed 16)", async () => {
+        const handle = installMockModel({ fixture: { stream: textOnlyStream("debug,concise") } });
+        cleanup = handle.uninstall;
+        const factory = (() => handle.model);
+        const classify = createLlmClassifier(factory, "grok-4.3"); // reasoning:true
+        const result = await classify("fix the failing CI build");
+        expect(result?.taskType).toBe("debug");
+        const call = handle.calls[0];
+        expect(call.maxOutputTokens).toBeGreaterThanOrEqual(1024);
+    });
+    it("forces low reasoning effort for reasoning models that support it", async () => {
+        const handle = installMockModel({ fixture: { stream: textOnlyStream("debug,concise") } });
+        cleanup = handle.uninstall;
+        const factory = (() => handle.model);
+        const classify = createLlmClassifier(factory, "grok-4.3"); // xai, supports_effort:true
+        await classify("fix the failing CI build");
+        const call = handle.calls[0];
+        expect(call.providerOptions?.xai?.reasoningEffort).toBe("low");
+    });
+    it("recovers the verdict from the reasoning channel when text is empty", async () => {
+        // Some reasoning models route the whole 2-word answer into reasoning parts
+        // and commit no text. The classifier must still recover it.
+        const reasoningOnly = [
+            { type: "stream-start", warnings: [] },
+            { type: "reasoning-start", id: "r1" },
+            { type: "reasoning-delta", id: "r1", delta: "debug,concise" },
+            { type: "reasoning-end", id: "r1" },
+            {
+                type: "finish",
+                finishReason: { unified: "stop", raw: undefined },
+                usage: {
+                    inputTokens: { total: 10, noCache: 10, cacheRead: undefined, cacheWrite: undefined },
+                    outputTokens: { total: 5, text: 0, reasoning: 5 },
+                },
+            },
+        ];
+        const handle = installMockModel({ fixture: { stream: reasoningOnly } });
+        cleanup = handle.uninstall;
+        const factory = (() => handle.model);
+        const classify = createLlmClassifier(factory, "grok-4.3");
+        const result = await classify("fix the failing CI build");
+        expect(result?.taskType).toBe("debug");
+        expect(result?.outputStyle).toBe("concise");
+    });
+    it("keeps the tiny 16-token budget for non-reasoning models", async () => {
+        const handle = installMockModel({ fixture: { stream: textOnlyStream("generate,concise") } });
+        cleanup = handle.uninstall;
+        const factory = (() => handle.model);
+        const classify = createLlmClassifier(factory, "Qwen/Qwen3-8B"); // reasoning:false
+        await classify("add a new endpoint");
+        const call = handle.calls[0];
+        expect(call.maxOutputTokens).toBe(16);
+    });
+});
+//# sourceMappingURL=llm-classify.test.js.map

package/dist/src/pil/__tests__/native-capabilities-workbook.test.d.ts

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

package/dist/src/pil/__tests__/native-capabilities-workbook.test.js

@@ -0,0 +1,40 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { buildNativeCapabilitiesSection, NATIVE_CAPABILITIES } from "../native-capabilities-workbook.js";
+describe("buildNativeCapabilitiesSection", () => {
+    afterEach(() => {
+        process.env.MUONROI_DISABLE_NATIVE_CAPABILITIES = undefined;
+    });
+    it("emits the manifest for agent mode (non-chitchat)", () => {
+        const out = buildNativeCapabilitiesSection({ mode: "agent", chitchat: false });
+        expect(out).toContain("NATIVE CAPABILITIES");
+        expect(out.endsWith("\n\n")).toBe(true);
+    });
+    it("names the load-bearing affordances the agent previously could not see", () => {
+        // Regression: these are the capabilities the in-CLI agent reconstructed by
+        // grepping source (session d95113d3be09). They MUST appear in the manifest.
+        for (const token of [
+            "ee_query",
+            "tool-artifact",
+            'task(agent="explore"',
+            "delegate(",
+            "self-verify",
+            "usage forensics",
+            "bash_output_get",
+            "[Discovery]",
+        ]) {
+            expect(NATIVE_CAPABILITIES).toContain(token);
+        }
+    });
+    it("is empty for chitchat turns", () => {
+        expect(buildNativeCapabilitiesSection({ mode: "agent", chitchat: true })).toBe("");
+    });
+    it("is empty for non-agent modes (plan/ask have a restricted toolset)", () => {
+        expect(buildNativeCapabilitiesSection({ mode: "plan", chitchat: false })).toBe("");
+        expect(buildNativeCapabilitiesSection({ mode: "ask", chitchat: false })).toBe("");
+    });
+    it("respects the MUONROI_DISABLE_NATIVE_CAPABILITIES escape hatch", () => {
+        process.env.MUONROI_DISABLE_NATIVE_CAPABILITIES = "1";
+        expect(buildNativeCapabilitiesSection({ mode: "agent", chitchat: false })).toBe("");
+    });
+});
+//# sourceMappingURL=native-capabilities-workbook.test.js.map

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

@@ -70,9 +70,10 @@ describe("runPipeline()", () => {
         expect(ctx.metrics).not.toBeNull();
         expect(ctx.metrics.totalMs).toBeGreaterThanOrEqual(0);
     });
-    it("metrics.layerTimings has 6 entries", async () => {
+    it("metrics.layerTimings has 7 entries (6 layers + discovery phase)", async () => {
         const ctx = await runPipeline("refactor this");
-        expect(ctx.metrics.layerTimings).toHaveLength(6);
+        // 6 standard layer timings + 1 discovery phase timing when discovery is enabled
+        expect(ctx.metrics.layerTimings.length).toBeGreaterThanOrEqual(6);
     });
     it("metrics.inputChars equals raw.length", async () => {
         const ctx = await runPipeline("hello world");

package/dist/src/pil/__tests__/renderer-coverage.test.js

@@ -23,7 +23,7 @@ describe("StructuredResponseView renderer coverage", () => {
         // structured-response-view.tsx — scan both files.
         const appSrc = readFileSync(resolve("src/ui/app.tsx"), "utf8");
         const rendererSrc = readFileSync(resolve("src/ui/components/structured-response-view.tsx"), "utf8");
-        const combinedSrc = appSrc + "\n" + rendererSrc;
+        const combinedSrc = `${appSrc}\n${rendererSrc}`;
         const switchOffsets = [];
         let idx = 0;
         while ((idx = combinedSrc.indexOf("switch (sr.taskType)", idx)) !== -1) {

package/dist/src/pil/__tests__/response-tools.test.js

@@ -1,5 +1,8 @@
 import { describe, expect, it } from "vitest";
-import { AnalyzeSchema, buildResponseTools, DebugSchema, DocsSchema, GeneralSchema, GenerateSchema, getResponseTaskType, isResponseTool, PlanSchema, RESPONSE_TOOL_PREFIX, RefactorSchema, } from "../response-tools.js";
+import { AnalyzeSchema, buildResponseTools, DebugSchema, DocsSchema, GeneralSchema, GenerateSchema, getResponseTaskType, isResponseTool, PlanSchema, RESPONSE_TOOL_PREFIX, RefactorSchema, shouldHaltOnResponseTool, stepEmittedResponseTool, } from "../response-tools.js";
+const step = (...names) => ({
+    toolCalls: names.map((toolName) => ({ toolName })),
+});
 describe("isResponseTool", () => {
     it("returns true for response tool names", () => {
         expect(isResponseTool("respond_refactor")).toBe(true);
@@ -57,6 +60,51 @@ describe("buildResponseTools", () => {
         }
     });
 });
+describe("stepEmittedResponseTool", () => {
+    it("returns true when a step emitted a response tool", () => {
+        expect(stepEmittedResponseTool({ toolCalls: [{ toolName: "respond_general" }] })).toBe(true);
+        expect(stepEmittedResponseTool({ toolCalls: [{ toolName: "read_file" }, { toolName: "respond_analyze" }] })).toBe(true);
+    });
+    it("returns false for action-only steps", () => {
+        expect(stepEmittedResponseTool({ toolCalls: [{ toolName: "bash" }, { toolName: "read_file" }] })).toBe(false);
+    });
+    it("returns false for steps with no tool calls", () => {
+        expect(stepEmittedResponseTool({ toolCalls: [] })).toBe(false);
+        expect(stepEmittedResponseTool({})).toBe(false);
+        expect(stepEmittedResponseTool(undefined)).toBe(false);
+    });
+    it("ignores malformed entries without a toolName", () => {
+        expect(stepEmittedResponseTool({ toolCalls: [{}, { toolName: undefined }] })).toBe(false);
+    });
+});
+describe("shouldHaltOnResponseTool", () => {
+    it("does not halt when the last step did not emit a response tool", () => {
+        expect(shouldHaltOnResponseTool([step("read_file"), step("grep")])).toBe(false);
+        expect(shouldHaltOnResponseTool([])).toBe(false);
+        expect(shouldHaltOnResponseTool(undefined)).toBe(false);
+    });
+    it("halts on a response tool emitted AFTER real tool work (terminal answer)", () => {
+        // d95113d3 seq=27: 7 grep/read calls, THEN respond_general → halt at call #1.
+        expect(shouldHaltOnResponseTool([step("grep"), step("read_file"), step("read_file"), step("respond_general")])).toBe(true);
+        // Real work + response in the SAME step also counts as investigated.
+        expect(shouldHaltOnResponseTool([step("read_file", "respond_analyze")])).toBe(true);
+        // d95113d3 seq=3: deep investigation → single respond_analyze.
+        expect(shouldHaltOnResponseTool([step("bash"), step("read_file"), step("respond_analyze")])).toBe(true);
+    });
+    it("does NOT halt on a single blind response tool (no prior investigation)", () => {
+        // e4a9d97a90: lone blind respond_general at step 0 — give the model the
+        // step it announced it would use to read code instead of force-stopping.
+        expect(shouldHaltOnResponseTool([step("respond_general")])).toBe(false);
+    });
+    it("halts on a 2nd blind response tool with still no real work (narration loop)", () => {
+        // 9b1b3: 2× blind respond_general, zero investigation → bounded at 2.
+        expect(shouldHaltOnResponseTool([step("respond_general"), step("respond_general")])).toBe(true);
+    });
+    it("treats a blind response then real work then response as terminal (investigated)", () => {
+        // Announce → investigate → answer: the final response is after real work.
+        expect(shouldHaltOnResponseTool([step("respond_general"), step("read_file"), step("respond_general")])).toBe(true);
+    });
+});
 describe("schemas validate correct input", () => {
     it("RefactorSchema accepts valid input", () => {
         const result = RefactorSchema.safeParse({

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

@@ -55,7 +55,7 @@ describe("scoreComplexity — signal isolation", () => {
         expect(shortOut.complexity).not.toBe("low");
         // 250-char version: length +2 + FORCE_HIGH_RE +3 = 5 → medium; still not low.
         const medOut = scoreComplexity({
-            rawText: "Architecture migration plan for multi-tenant SaaS " + "a".repeat(200),
+            rawText: `Architecture migration plan for multi-tenant SaaS ${"a".repeat(200)}`,
             taskType: null,
             t0HitCount: 0,
             hasMaxSprintsOne: false,
@@ -64,7 +64,7 @@ describe("scoreComplexity — signal isolation", () => {
         expect(medOut.complexity).not.toBe("low");
         // 600-char version: length +3 + FORCE_HIGH_RE +3 = 6 → high.
         const highOut = scoreComplexity({
-            rawText: "Architecture migration plan for multi-tenant SaaS " + "a".repeat(560),
+            rawText: `Architecture migration plan for multi-tenant SaaS ${"a".repeat(560)}`,
             taskType: null,
             t0HitCount: 0,
             hasMaxSprintsOne: false,

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

@@ -0,0 +1,51 @@
+/**
+ * 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 declare const AGENT_OPERATING_CONTRACT = "[AGENT OPERATING CONTRACT \u2014 read first; applies to every step]\n\n1. BEFORE ACTING: do only what was asked. Never assume scope or facts \u2014 if ambiguous, ask or use defaults; never invent requirements.\n2. READING: base statements on what you read/ran THIS turn. Do not infer contents of files you did not open.\n3. EXECUTING: smallest correct change; never widen scope or mask failures (no `|| true`, skipped tests, or swallowed catch).\n4. WHEN UNSURE: verify and cross-check BEFORE concluding. Bugs need a reproduction; reading code is not proof.\n5. 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 \u2014 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 \u2014 don't imply success.\n\n6. LANGUAGE: Reply in user's detected language for final output. Internal reasoning, tools, and code remain in English.\n\n7. ANTI-M\u00D9 / 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.\n\n[END CONTRACT \u2014 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 declare function buildContractSection(options?: ContractSectionOptions): string;

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

@@ -0,0 +1,66 @@
+/**
+ * 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]`;
+/**
+ * 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) {
+    if (process.env.MUONROI_DISABLE_AGENT_CONTRACT === "1")
+        return "";
+    if (options?.chitchat === true)
+        return "";
+    return `${AGENT_OPERATING_CONTRACT}\n\n`;
+}
+//# sourceMappingURL=agent-operating-contract.js.map

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

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

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

@@ -0,0 +1,75 @@
+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;
+    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/budget-log.js

@@ -17,7 +17,7 @@ function logPath(date) {
 export async function appendPilLog(entry) {
     try {
         await fs.mkdir(logDir(), { recursive: true });
-        await fs.appendFile(logPath(todayUtc()), JSON.stringify(entry) + "\n", "utf8");
+        await fs.appendFile(logPath(todayUtc()), `${JSON.stringify(entry)}\n`, "utf8");
     }
     catch {
         // best-effort, never throw