muonroi-cli 1.7.1 → 1.8.0

package/dist/src/orchestrator/turn-runner-deps.d.ts

@@ -35,6 +35,7 @@ export interface TurnRunnerDepsBase {
     runDelegation(request: TaskRequest, signal?: AbortSignal): Promise<ToolResult>;
     readDelegation(id: string): Promise<ToolResult>;
     listDelegations(): Promise<ToolResult>;
+    killDelegation(id: string): Promise<ToolResult>;
     appendCompletedTurn(userMessage: ModelMessage, assistantMessages: ModelMessage[]): void;
     discardAbortedTurn(userMessage: ModelMessage): void;
     recordUsage(usage: {

package/dist/src/pil/__tests__/discovery-types.test.js

@@ -16,11 +16,20 @@ describe("discovery-types", () => {
         };
         expect(ctx.language).toBe("typescript");
     });
-    it("ClarityDimension union covers all 3 values", () => {
-        const dims = ["outcome", "scope", "constraint"];
-        expect(dims).toHaveLength(3);
+    it("ModelCard has all required fields", () => {
+        const card = {
+            question: "What auth method?",
+            options: [
+                { label: "OAuth", kind: "choice", isCancel: false, isAdjust: false },
+                { label: "API keys", kind: "choice" },
+                { label: "Custom", kind: "freetext" },
+            ],
+            defaultIndex: 0,
+        };
+        expect(card.question).toBe("What auth method?");
+        expect(card.options).toHaveLength(3);
     });
-    it("DiscoveryResult has all required fields", () => {
+    it("DiscoveryResult has all required fields including interviewTranscript", () => {
         const result = {
             raw: "fix auth",
             projectContext: {
@@ -47,8 +56,10 @@ describe("discovery-types", () => {
             domain: "typescript",
             outputStyle: "balanced",
             discoveryMs: 100,
+            interviewTranscript: [],
         };
         expect(result.accepted).toBe(true);
+        expect(result.interviewTranscript).toEqual([]);
     });
 });
 //# sourceMappingURL=discovery-types.test.js.map

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

@@ -7,15 +7,11 @@ import { clearDiscoveryCache } from "../discovery-cache.js";
 afterEach(() => clearDiscoveryCache());
 const mockHandler = {
     askQuestion: vi.fn().mockResolvedValue({ questionId: "q1", text: "Error disappears", kind: "choice" }),
-    showAcceptance: vi.fn().mockResolvedValue("accept"),
 };
 describe("runDiscovery()", () => {
-    it("proceeds without interview when the model proposes no questions", async () => {
-        // Phase 2: the model is the sole ask-decider. An empty proposer result means
-        // "no gray area" → no interview, no fabricated [Discovery] outcome.
+    it("proceeds without interview when the model proposes no cards", async () => {
         const handler = {
             askQuestion: vi.fn().mockResolvedValue({ questionId: "q1", text: "x", kind: "choice" }),
-            showAcceptance: vi.fn().mockResolvedValue("accept"),
         };
         const proposer = vi.fn().mockResolvedValue([]);
         const result = await runDiscovery("fix TypeError in src/auth/login.ts:42", {
@@ -31,15 +27,11 @@ describe("runDiscovery()", () => {
         expect(result.accepted).toBe(true);
         expect(handler.askQuestion).not.toHaveBeenCalled();
     });
-    it("does NOT interview (and never fabricates regex questions) when no proposer is wired", async () => {
-        // Phase 2 fail-loud: an interactive turn missing a proposer logs and proceeds
-        // WITHOUT an interview — it must never fall back to keyword-generated gaps.
+    it("does NOT interview when no proposer is wired", async () => {
         const handler = {
             askQuestion: vi.fn().mockResolvedValue({ questionId: "q1", text: "x", kind: "choice" }),
-            showAcceptance: vi.fn().mockResolvedValue("accept"),
         };
-        const result = await runDiscovery("fix auth", // vague — old regex gate would have asked a scope question
-        {
+        const result = await runDiscovery("fix auth", {
             taskType: "debug",
             confidence: 0.6,
             complexity: "low",
@@ -51,16 +43,61 @@ describe("runDiscovery()", () => {
         expect(result.accepted).toBe(true);
         expect(handler.askQuestion).not.toHaveBeenCalled();
     });
-    it("surfaces the model's reason + recommends in the interview askcard", async () => {
-        const askQuestion = vi.fn().mockResolvedValue({ questionId: "q1", text: "OAuth", kind: "choice" });
-        const handler = {
-            askQuestion,
-            showAcceptance: vi.fn().mockResolvedValue("accept"),
-        };
-        const proposer = vi
+    it("interviews user when the model proposes cards", async () => {
+        const askQuestion = vi.fn().mockResolvedValue({ questionId: "q1", text: "Error disappears", kind: "choice" });
+        const handler = { askQuestion };
+        const modelCards = [
+            {
+                question: "What outcome do you expect?",
+                options: [
+                    { label: "Error disappears", kind: "choice" },
+                    { label: "Not sure", kind: "freetext" },
+                ],
+                defaultIndex: 0,
+            },
+        ];
+        const proposer = vi.fn().mockResolvedValue(modelCards);
+        const result = await runDiscovery("fix auth", {
+            taskType: "debug",
+            confidence: 0.6,
+            complexity: "low",
+            domain: "typescript",
+            outputStyle: null,
+            intentKind: "task",
+        }, process.cwd(), handler, null, proposer);
+        expect(result.interviewed).toBe(true);
+        expect(result.accepted).toBe(true);
+        expect(handler.askQuestion).toHaveBeenCalled();
+        expect(result.interviewTranscript).toHaveLength(1);
+        expect(result.interviewTranscript[0].question).toBe("What outcome do you expect?");
+        expect(result.interviewTranscript[0].answer).toBe("Error disappears");
+    });
+    it("records multiple cards in the interview transcript", async () => {
+        const askQuestion = vi
             .fn()
-            .mockResolvedValue(["Which auth method? [MODEL RECS: OAuth | API keys] [WHY: changes the whole token flow]"]);
-        await runDiscovery("add authentication", {
+            .mockResolvedValueOnce({ questionId: "q1", text: "OAuth", kind: "choice" })
+            .mockResolvedValueOnce({ questionId: "q2", text: "src/auth/", kind: "choice" });
+        const handler = { askQuestion };
+        const modelCards = [
+            {
+                question: "Which auth method?",
+                options: [
+                    { label: "OAuth", kind: "choice" },
+                    { label: "API Keys", kind: "choice" },
+                ],
+                defaultIndex: 0,
+            },
+            {
+                question: "Which module?",
+                options: [
+                    { label: "src/auth/", kind: "choice" },
+                    { label: "src/user/", kind: "choice" },
+                ],
+                defaultIndex: 0,
+            },
+        ];
+        const proposer = vi.fn().mockResolvedValue(modelCards);
+        const result = await runDiscovery("add authentication", {
             taskType: "generate",
             confidence: 0.6,
             complexity: "low",
@@ -68,24 +105,45 @@ describe("runDiscovery()", () => {
             outputStyle: null,
             intentKind: "task",
         }, process.cwd(), handler, null, proposer);
-        expect(askQuestion).toHaveBeenCalled();
-        const card = askQuestion.mock.calls[0][0];
-        // Model's WHY drives the askcard context; recommends drive the options.
-        expect(card.context).toBe("changes the whole token flow");
-        expect(card.question).toBe("Which auth method?");
-        const labels = (card.options ?? []).map((o) => o.label);
-        expect(labels).toContain("OAuth");
-        expect(labels).toContain("API keys");
-        expect(card.defaultIndex).toBe(0); // first recommend = recommended default
+        expect(result.interviewTranscript).toHaveLength(2);
+        expect(result.interviewTranscript[0].question).toBe("Which auth method?");
+        expect(result.interviewTranscript[0].answer).toBe("OAuth");
+        expect(result.interviewTranscript[1].question).toBe("Which module?");
+        expect(result.interviewTranscript[1].answer).toBe("src/auth/");
+    });
+    it("sets accepted=false when user picks a cancel option", async () => {
+        const askQuestion = vi
+            .fn()
+            .mockResolvedValueOnce({ questionId: "q1", text: "Cancel this request", kind: "choice" });
+        const handler = { askQuestion };
+        const modelCards = [
+            {
+                question: "What outcome?",
+                options: [
+                    { label: "Proceed", kind: "choice" },
+                    { label: "Cancel this request", kind: "choice", isCancel: true },
+                ],
+                defaultIndex: 0,
+            },
+        ];
+        const proposer = vi.fn().mockResolvedValue(modelCards);
+        const result = await runDiscovery("fix auth", {
+            taskType: "debug",
+            confidence: 0.6,
+            complexity: "low",
+            domain: "typescript",
+            outputStyle: null,
+            intentKind: "task",
+        }, process.cwd(), handler, null, proposer);
+        expect(result.accepted).toBe(false);
     });
     it("skips all discovery when the user explicitly says don't ask (EN + VI)", async () => {
         const handler = {
             askQuestion: vi.fn().mockResolvedValue({ questionId: "q1", text: "x", kind: "choice" }),
-            showAcceptance: vi.fn().mockResolvedValue("accept"),
         };
         const l1 = {
             taskType: "analyze",
-            confidence: 0.6, // low enough that discovery would normally interview
+            confidence: 0.6,
             complexity: "low",
             domain: null,
             outputStyle: null,
@@ -99,24 +157,6 @@ describe("runDiscovery()", () => {
         expect(viResult.accepted).toBe(true);
         expect(handler.askQuestion).not.toHaveBeenCalled();
     });
-    it("interviews user when the model proposes a question", async () => {
-        const handler = {
-            askQuestion: vi.fn().mockResolvedValue({ questionId: "q1", text: "Error disappears", kind: "choice" }),
-            showAcceptance: vi.fn().mockResolvedValue("accept"),
-        };
-        const proposer = vi.fn().mockResolvedValue(["What's the expected fix outcome? [MODEL RECS: Error disappears]"]);
-        const result = await runDiscovery("fix auth", {
-            taskType: "debug",
-            confidence: 0.6,
-            complexity: "low",
-            domain: "typescript",
-            outputStyle: null,
-            intentKind: "task",
-        }, process.cwd(), handler, null, proposer);
-        expect(result.interviewed).toBe(true);
-        expect(result.accepted).toBe(true);
-        expect(handler.askQuestion).toHaveBeenCalled();
-    });
     it("skips interview but still passes when handler is null (headless)", async () => {
         const result = await runDiscovery("fix auth", {
             taskType: "debug",
@@ -129,106 +169,10 @@ describe("runDiscovery()", () => {
         expect(result.interviewed).toBe(false);
         expect(result.accepted).toBe(true);
     });
-    it("sets accepted=false when user cancels", async () => {
-        const handler = {
-            // First askQuestion = the model's interview question, second = acceptance card.
-            askQuestion: vi
-                .fn()
-                .mockResolvedValueOnce({ questionId: "q1", text: "done", kind: "choice" })
-                .mockResolvedValue({ questionId: "q-acc", text: "cancel", kind: "choice" }),
-            showAcceptance: vi.fn().mockResolvedValue("cancel"),
-        };
-        const proposer = vi.fn().mockResolvedValue(["What's the expected outcome? [MODEL RECS: Error disappears]"]);
-        const result = await runDiscovery("fix auth", {
-            taskType: "debug",
-            confidence: 0.6,
-            complexity: "low",
-            domain: "typescript",
-            outputStyle: null,
-            intentKind: "task",
-        }, process.cwd(), handler, null, proposer);
-        expect(result.accepted).toBe(false);
-    });
-    it("does not swallow the original request into a generic outcome for a general prompt (B2)", async () => {
-        // B2 — the old generic outcome askcard collapsed intent to "general: Task
-        // completed", discarding the user's prompt. With the model proposing no
-        // questions, the outcome must derive from the raw text (no fabrication).
-        const handler = {
-            askQuestion: vi.fn().mockResolvedValue({ questionId: "q1", text: "Task completed", kind: "choice" }),
-            showAcceptance: vi.fn().mockResolvedValue("accept"),
-        };
-        const proposer = vi.fn().mockResolvedValue([]);
-        const result = await runDiscovery("make the dashboard feel less cluttered", {
-            taskType: "general",
-            confidence: 0.6,
-            complexity: "low",
-            domain: null,
-            outputStyle: null,
-            intentKind: "task",
-        }, process.cwd(), handler, null, proposer);
-        expect(result.intentStatement).not.toBe("general: Task completed");
-        expect(result.outcome).not.toBe("Task completed");
-        // The original request must survive into the resolved outcome.
-        expect(result.outcome.toLowerCase()).toContain("dashboard");
-    });
     it("skips discovery entirely for chitchat", async () => {
         const result = await runDiscovery("hi", { taskType: null, confidence: 0.5, complexity: "low", domain: null, outputStyle: null, intentKind: "chitchat" }, process.cwd(), mockHandler);
         expect(result.interviewed).toBe(false);
         expect(result.accepted).toBe(true);
     });
 });
-describe("runDiscovery() — outcome autofill override (path-leak vs legit slash)", () => {
-    const analyzeL1 = {
-        taskType: "analyze",
-        confidence: 0.6,
-        complexity: "low",
-        domain: null,
-        outputStyle: null,
-        intentKind: "task",
-    };
-    // A handler that always picks `text` for both the interview answer and the
-    // acceptance card (any non-"cancel"/"adjust" text accepts).
-    const pickAnswer = (text) => ({
-        askQuestion: vi.fn().mockResolvedValue({ questionId: "q1", text, kind: "choice" }),
-        showAcceptance: vi.fn().mockResolvedValue("accept"),
-    });
-    it("preserves a user outcome answer containing '/' (does not clobber with the autofilled default)", async () => {
-        // Regression: the override matched ANY '/' (bare `\/` regex alt +
-        // `.includes("/")`), silently replacing a legit answer like
-        // "support both REST/GraphQL endpoints" with the analyze default.
-        const userAnswer = "support both REST/GraphQL endpoints";
-        const proposer = vi
-            .fn()
-            .mockResolvedValue([
-            "Which API surface should the analysis target? [MODEL RECS: support both REST/GraphQL endpoints | REST only]",
-        ]);
-        const result = await runDiscovery("review the API layer", analyzeL1, process.cwd(), pickAnswer(userAnswer), null, proposer);
-        expect(result.outcome).toBe(userAnswer);
-        expect(result.outcome).not.toBe("Detailed analysis with concrete improvement recommendations");
-    });
-    it("preserves another 'or'-style slash answer (validate input/output schemas)", async () => {
-        const userAnswer = "validate input/output schemas";
-        const proposer = vi.fn().mockResolvedValue(["What should the analysis verify?"]);
-        const result = await runDiscovery("review the API layer", analyzeL1, process.cwd(), pickAnswer(userAnswer), null, proposer);
-        expect(result.outcome).toBe(userAnswer);
-    });
-    it("still overwrites a genuinely path-leaked outcome with the autofilled default", async () => {
-        // Guard against over-correction: a real filesystem-path leak (scope-option
-        // shape "src/cli (cli)") must STILL be replaced by the inferred outcome.
-        const proposer = vi.fn().mockResolvedValue(["What scope? [MODEL RECS: src/cli (cli)]"]);
-        const result = await runDiscovery("review the API layer", analyzeL1, process.cwd(), pickAnswer("src/cli (cli)"), null, proposer);
-        expect(result.outcome).toBe("Detailed analysis with concrete improvement recommendations");
-    });
-    it("treats the 'provide my own details' meta-option as no-answer, not a literal outcome", async () => {
-        // The default meta-option ("I will provide my own details / constraints")
-        // is a 'no specific answer' sentinel — it must not survive verbatim as the
-        // outcome. With no inferred default available (generate), it falls back to
-        // the raw-derived intent rather than the sentinel string.
-        const sentinel = "I will provide my own details / constraints";
-        const proposer = vi.fn().mockResolvedValue(["What outcome do you expect?"]);
-        const result = await runDiscovery("build the user dashboard widget", { ...analyzeL1, taskType: "generate" }, process.cwd(), pickAnswer(sentinel), null, proposer);
-        expect(result.outcome).not.toBe(sentinel);
-        expect(result.outcome.toLowerCase()).toContain("dashboard");
-    });
-});
 //# sourceMappingURL=discovery.test.js.map

package/dist/src/pil/__tests__/dual-run.test.js

@@ -12,6 +12,8 @@ vi.mock("../../ee/bridge.js", () => ({
     getEmbeddingRaw: vi.fn().mockResolvedValue(null),
     routeTask: vi.fn().mockResolvedValue(null),
     pilContext: vi.fn().mockResolvedValue(null),
+    getWhoAmIProfile: vi.fn(() => null),
+    outputStyleFromProfile: vi.fn(() => null),
 }));
 const FIXTURES = [
     "tại sao test fail?",

package/dist/src/pil/__tests__/layer1-intent-trace.test.js

@@ -20,6 +20,9 @@ vi.mock("../../ee/bridge.js", () => ({
 vi.mock("../config.js", () => ({
     isUnifiedPilEnabled: mockIsUnifiedPilEnabled,
     isLlmFirstClassifyEnabled: mockIsLlmFirstClassifyEnabled,
+    // Pass-3 unified reads the client-side budget; whole-module mock replaces the
+    // real export, so it must be provided or the call site throws.
+    getUnifiedPilBudgetMs: vi.fn(() => 3500),
 }));
 import { layer1Intent } from "../layer1-intent.js";
 function makeCtx(raw) {

package/dist/src/pil/__tests__/layer1-intent.test.js

@@ -7,6 +7,9 @@ vi.mock("../config.js", () => ({
     // OFF here so these cascade tests exercise the regex passes (the model-first
     // gate is covered in src/pil/layer1-intent.test.ts).
     isLlmFirstClassifyEnabled: vi.fn(() => false),
+    // Pass-3 unified reads the client-side budget; whole-module mock replaces the
+    // real export, so it must be provided or the call site throws.
+    getUnifiedPilBudgetMs: vi.fn(() => 3500),
 }));
 vi.mock("../../ee/bridge.js", () => ({
     classifyViaBrain: vi.fn().mockResolvedValue(null),

package/dist/src/pil/__tests__/layer16-clarity.test.js

@@ -1,9 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { buildInterviewQuestion, resolveGapsNonInteractive } from "../layer16-clarity.js";
-// Phase 2 (2026-06-16): detectClarityGaps + its keyword option-builders were
-// removed (the model now generates every clarification). The surviving helpers
-// — buildInterviewQuestion (render) and resolveGapsNonInteractive (headless
-// default-answer resolution) — are exercised here with model-shaped gaps.
+import { modelCardToQuestion, resolveGapsNonInteractive } from "../layer16-clarity.js";
 const EMPTY_PROJECT = {
     language: "typescript",
     framework: null,
@@ -18,49 +14,56 @@ const EMPTY_PROJECT = {
     scannedAt: Date.now(),
     cwd: "/proj",
 };
-describe("buildInterviewQuestion()", () => {
-    it("builds a CouncilQuestionData with pil-interview phase", () => {
-        const gap = {
-            dimension: "outcome",
-            description: "no outcome",
-            suggestedQuestion: "What outcome?",
-            options: ["test passes", "no error"],
+describe("modelCardToQuestion()", () => {
+    it("maps ModelCard to CouncilQuestionData with pil-interview phase", () => {
+        const card = {
+            question: "What outcome?",
+            context: "This changes how we debug",
+            options: [
+                { label: "Error disappears", kind: "choice" },
+                { label: "Custom fix", kind: "freetext" },
+            ],
             defaultIndex: 0,
         };
-        const q = buildInterviewQuestion(gap, "q-1");
+        const q = modelCardToQuestion(card, "q-1");
         expect(q.phase).toBe("pil-interview");
         expect(q.questionId).toBe("q-1");
         expect(q.options).toBeDefined();
-        expect(q.options.some((o) => o.kind === "freetext")).toBe(true);
+        expect(q.options).toHaveLength(2);
+        expect(q.options[0].isCancel).toBeUndefined();
+        expect(q.options[0].isAdjust).toBeUndefined();
     });
-    it("surfaces the model's reason (gap.description) as the askcard context", () => {
-        const gap = {
-            dimension: "outcome",
-            description: "answering this changes whether we add OAuth or just API keys",
-            suggestedQuestion: "Which auth method?",
-            options: ["OAuth", "API keys"],
+    it("preserves isCancel and isAdjust flags from model card options", () => {
+        const card = {
+            question: "Proceed?",
+            options: [
+                { label: "Looks good, go ahead", kind: "choice" },
+                { label: "Cancel this", kind: "choice", isCancel: true },
+                { label: "Let me clarify", kind: "choice", isAdjust: true },
+            ],
             defaultIndex: 0,
         };
-        const q = buildInterviewQuestion(gap, "q-2");
-        expect(q.context).toBe("answering this changes whether we add OAuth or just API keys");
+        const q = modelCardToQuestion(card, "q-2");
+        expect(q.options[1].isCancel).toBe(true);
+        expect(q.options[2].isAdjust).toBe(true);
     });
 });
 describe("resolveGapsNonInteractive()", () => {
-    it("fills gaps with best-effort defaults from the model options + project context", () => {
-        const gaps = [
+    it("fills gaps with default options from model cards", () => {
+        const cards = [
             {
-                dimension: "outcome",
-                description: "Model-generated clarification #1",
-                suggestedQuestion: "What outcome do you expect?",
-                options: ["Error resolved", "Other (type free answer)"],
+                question: "What outcome?",
+                options: [
+                    { label: "Error resolved", kind: "choice" },
+                    { label: "Not sure", kind: "freetext" },
+                ],
                 defaultIndex: 0,
             },
         ];
-        const resolved = resolveGapsNonInteractive(gaps, EMPTY_PROJECT, "fix auth");
-        expect(resolved.outcome).toBe("Error resolved");
-        expect(resolved.scope.length).toBeGreaterThan(0);
+        const resolved = resolveGapsNonInteractive(cards, EMPTY_PROJECT, "fix auth");
+        expect(resolved.outcome).toContain("Error resolved");
     });
-    it("falls back to the raw-derived outcome when there is no outcome gap", () => {
+    it("falls back to raw-derived outcome when model cards are empty", () => {
         const resolved = resolveGapsNonInteractive([], EMPTY_PROJECT, "fix the login bug");
         expect(resolved.outcome).toBeTruthy();
         expect(resolved.scope.length).toBeGreaterThan(0);

package/dist/src/pil/__tests__/layer18-acceptance.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { buildAcceptanceCard, buildAcceptanceQuestion } from "../layer18-acceptance.js";
+import { buildAcceptanceCard } from "../layer18-acceptance.js";
 describe("buildAcceptanceCard()", () => {
     it("builds card with intent, outcome, scope, and warnings", () => {
         const intent = { outcome: "error gone", scope: ["src/auth/jwt.ts"], constraints: [], gaps: [] };
@@ -15,81 +15,4 @@ describe("buildAcceptanceCard()", () => {
         expect(card.warnings).toEqual(["oauth.ts also handles tokens"]);
     });
 });
-describe("buildAcceptanceQuestion()", () => {
-    it("builds a CouncilQuestionData with pil-acceptance phase", () => {
-        const card = { intentStatement: "Fix auth", outcome: "done", scope: ["src/auth/"], warnings: [] };
-        const q = buildAcceptanceQuestion(card, "acc-1");
-        expect(q.phase).toBe("pil-acceptance");
-        expect(q.questionId).toBe("acc-1");
-        expect(q.options).toHaveLength(3);
-        expect(q.options[0].label).toBe("Accept");
-        expect(q.options[1].label).toBe("Adjust");
-        expect(q.options[2].label).toBe("Cancel");
-        expect(q.defaultIndex).toBe(0);
-    });
-    it("includes warnings in context when present", () => {
-        const card = { intentStatement: "Fix auth", outcome: "done", scope: ["src/auth/"], warnings: ["risk: oauth.ts"] };
-        const q = buildAcceptanceQuestion(card, "acc-2");
-        expect(q.context).toContain("risk: oauth.ts");
-    });
-    // Default flips to "Adjust" only for BLOCKING warnings (e.g. infeasibility).
-    it("defaults to Adjust (index 1) when warning is blocking", () => {
-        const card = {
-            intentStatement: "Fix auth",
-            outcome: "done",
-            scope: ["src/"],
-            warnings: ["infeasible: file does not exist"],
-        };
-        const q = buildAcceptanceQuestion(card, "acc-3");
-        expect(q.defaultIndex).toBe(1);
-    });
-    it("defaults to Accept (index 0) when no warnings", () => {
-        const card = { intentStatement: "Fix auth", outcome: "done", scope: ["src/"], warnings: [] };
-        const q = buildAcceptanceQuestion(card, "acc-4");
-        expect(q.defaultIndex).toBe(0);
-    });
-    // Fix #7 — informational mismatch warning should NOT flip default to Adjust.
-    // Evidence: session 1f29e238 ("Can you fix it?" follow-up) — the intent
-    // mismatch detector emitted "Detected debug/bug-fix signals..." which is
-    // informational; forcing Adjust looped PIL through another interview round.
-    it("defaults to Accept when only warning is intent-mismatch (informational)", () => {
-        const card = {
-            intentStatement: "debug: Complete: Can you fix it?",
-            outcome: "done",
-            scope: ["src/"],
-            warnings: ['Detected debug/bug-fix signals in your prompt ("fail") but intent reframed as "..."'],
-        };
-        const q = buildAcceptanceQuestion(card, "acc-5");
-        expect(q.defaultIndex).toBe(0);
-    });
-    it("defaults to Adjust when mix of informational + blocking warnings", () => {
-        const card = {
-            intentStatement: "Fix auth",
-            outcome: "done",
-            scope: ["src/"],
-            warnings: ["Detected debug signals — Verify before accepting", "infeasible: file does not exist"],
-        };
-        const q = buildAcceptanceQuestion(card, "acc-6");
-        expect(q.defaultIndex).toBe(1);
-    });
-});
-describe("buildAcceptanceCard() intent-mismatch detection — PIL-L6", () => {
-    const baseFeas = { viable: true, warnings: [], adjustedScope: [] };
-    it("flags warning when raw has debug signals but intent is non-debug", () => {
-        const intent = { outcome: "Feature implemented", scope: ["project"], constraints: [], gaps: [] };
-        const card = buildAcceptanceCard("generate: Feature implemented and working", intent, baseFeas, "ci action fail dùng gh check và fix cho t");
-        expect(card.warnings.length).toBeGreaterThan(0);
-        expect(card.warnings[0]).toMatch(/debug.*signals|Verify before accepting/i);
-    });
-    it("no mismatch when intent statement matches debug signal", () => {
-        const intent = { outcome: "CI green", scope: ["project"], constraints: [], gaps: [] };
-        const card = buildAcceptanceCard("debug: CI pipeline green", intent, baseFeas, "fix the ci fail");
-        expect(card.warnings).toEqual([]);
-    });
-    it("no warning when raw has no debug signals", () => {
-        const intent = { outcome: "Feature implemented", scope: ["project"], constraints: [], gaps: [] };
-        const card = buildAcceptanceCard("generate: Feature implemented and working", intent, baseFeas, "add a new button to the dashboard");
-        expect(card.warnings).toEqual([]);
-    });
-});
 //# sourceMappingURL=layer18-acceptance.test.js.map

package/dist/src/pil/__tests__/layer2_5-ponytail.test.d.ts

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

package/dist/src/pil/__tests__/layer2_5-ponytail.test.js

@@ -0,0 +1,53 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { layer2_5Ponytail } from "../layer2_5-ponytail.js";
+describe("layer2_5Ponytail", () => {
+    const originalEnv = process.env.MUONROI_PONYTAIL_DISABLE;
+    afterEach(() => {
+        if (originalEnv === undefined) {
+            delete process.env.MUONROI_PONYTAIL_DISABLE;
+        }
+        else {
+            process.env.MUONROI_PONYTAIL_DISABLE = originalEnv;
+        }
+    });
+    it("should apply ponytail instruction when enabled", async () => {
+        process.env.MUONROI_PONYTAIL_DISABLE = "0";
+        const ctx = {
+            raw: "test",
+            enriched: "test",
+            taskType: "general",
+            confidence: 1,
+            domain: null,
+            outputStyle: "balanced",
+            tokenBudget: 1000,
+            metrics: null,
+            layers: [],
+        };
+        const result = await layer2_5Ponytail(ctx);
+        expect(result.layers.length).toBe(1);
+        expect(result.layers[0].name).toBe("ponytail-mode");
+        expect(result.layers[0].applied).toBe(true);
+        expect(result.enriched).toContain("LAZY SENIOR / PONYTAIL MODE ACTIVE");
+    });
+    it("should skip ponytail instruction when disabled via env var", async () => {
+        process.env.MUONROI_PONYTAIL_DISABLE = "1";
+        const ctx = {
+            raw: "test",
+            enriched: "test",
+            taskType: "general",
+            confidence: 1,
+            domain: null,
+            outputStyle: "balanced",
+            tokenBudget: 1000,
+            metrics: null,
+            layers: [],
+        };
+        const result = await layer2_5Ponytail(ctx);
+        expect(result.layers.length).toBe(1);
+        expect(result.layers[0].name).toBe("ponytail-mode");
+        expect(result.layers[0].applied).toBe(false);
+        expect(result.layers[0].delta).toBe("skipped:disabled-by-config");
+        expect(result.enriched).toBe("test"); // Not enriched with ponytail
+    });
+});
+//# sourceMappingURL=layer2_5-ponytail.test.js.map