muonroi-cli 1.8.1 → 1.8.3

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

@@ -1,221 +0,0 @@
-import { beforeEach, describe, expect, test, vi } from "vitest";
-import { sessionRecallLedger } from "../../ee/recall-ledger.js";
-import { layer3EeInjection, RECALL_FEEDBACK_NUDGE } from "../layer3-ee-injection.js";
-vi.mock("../../ee/bridge.js", () => ({
-    searchByText: vi.fn().mockResolvedValue([]),
-}));
-import { searchByText } from "../../ee/bridge.js";
-function makeCtx(overrides = {}) {
-    return {
-        raw: "debug the login flow",
-        enriched: "debug the login flow",
-        taskType: "debug",
-        domain: null,
-        confidence: 0.85,
-        outputStyle: "concise",
-        tokenBudget: 500,
-        metrics: null,
-        layers: [],
-        ...overrides,
-    };
-}
-describe("layer3EeInjection (bridge-based)", () => {
-    beforeEach(() => {
-        vi.mocked(searchByText).mockReset();
-        vi.mocked(searchByText).mockResolvedValue([]);
-        // The recall-feedback ledger is a process singleton; reset so passive-injection
-        // debt recorded by one test does not lengthen the pending reminder in the next.
-        sessionRecallLedger.reset();
-    });
-    test("Test 1: returns enriched context with hints when searchByText returns points with payload.text", async () => {
-        vi.mocked(searchByText).mockResolvedValue([
-            {
-                id: "abc1",
-                score: 0.92,
-                payload: { text: "Always check null before accessing .user" },
-                collection: "experience-behavioral",
-            },
-            {
-                id: "def2",
-                score: 0.88,
-                payload: { text: "Use try-catch around DB calls" },
-                collection: "experience-behavioral",
-            },
-        ]);
-        const result = await layer3EeInjection(makeCtx());
-        expect(result.enriched).toContain("[experience:");
-        expect(result.enriched).toContain("Always check null before accessing .user");
-        const layer = result.layers.find((l) => l.name === "ee-experience-injection");
-        expect(layer).toBeDefined();
-        expect(layer.applied).toBe(true);
-    });
-    test("Test 2: returns ctx unchanged with applied=false and delta=no-points when searchByText throws", async () => {
-        vi.mocked(searchByText).mockRejectedValue(new Error("network down"));
-        const ctx = makeCtx();
-        const result = await layer3EeInjection(ctx);
-        expect(result.enriched).toBe(ctx.enriched);
-        const layer = result.layers.find((l) => l.name === "ee-experience-injection");
-        expect(layer).toBeDefined();
-        expect(layer.applied).toBe(false);
-        expect(layer.delta).toContain("error=");
-    });
-    test("Test 3: returns ctx unchanged with applied=false and delta=no-points when searchByText returns []", async () => {
-        vi.mocked(searchByText).mockResolvedValue([]);
-        const ctx = makeCtx();
-        const result = await layer3EeInjection(ctx);
-        expect(result.enriched).toBe(ctx.enriched);
-        const layer = result.layers.find((l) => l.name === "ee-experience-injection");
-        expect(layer).toBeDefined();
-        expect(layer.applied).toBe(false);
-        expect(layer.delta).toBe("no-points");
-    });
-    test("Test 4: extracts text from payload.json containing solution field", async () => {
-        vi.mocked(searchByText).mockResolvedValue([
-            {
-                id: "xyz9",
-                score: 0.75,
-                payload: { json: JSON.stringify({ solution: "Always validate inputs at boundary" }) },
-                collection: "experience-behavioral",
-            },
-        ]);
-        const result = await layer3EeInjection(makeCtx());
-        expect(result.enriched).toContain("Always validate inputs at boundary");
-        const layer = result.layers.find((l) => l.name === "ee-experience-injection");
-        expect(layer.applied).toBe(true);
-    });
-    test("Test 5: hints are truncated via truncateToBudget at 30% of tokenBudget", async () => {
-        const longText = "A".repeat(2000);
-        vi.mocked(searchByText).mockResolvedValue([
-            { id: "x", score: 0.9, payload: { text: longText }, collection: "experience-behavioral" },
-        ]);
-        const result = await layer3EeInjection(makeCtx({ tokenBudget: 100 }));
-        const layer = result.layers.find((l) => l.name === "ee-experience-injection");
-        expect(layer.applied).toBe(true);
-        if (layer?.delta) {
-            const charsMatch = layer.delta.match(/chars=(\d+)/);
-            if (charsMatch) {
-                const chars = parseInt(charsMatch[1], 10);
-                // Two parallel collections, each at 15% of budget: 15% of 100 tokens * 4 chars/token
-                // = 60 chars per block + 3 for "..." suffix, joined with newline. Allow generous
-                // ceiling for header text + 2 blocks, PLUS the dynamic pending-feedback reminder
-                // (≤5 [id collection] lines) that replaced the fixed nudge. The 2000-char input
-                // means a truncation regression would blow well past this bound regardless.
-                expect(chars).toBeLessThanOrEqual(600);
-            }
-        }
-    });
-    test("Test 6: search hits server whitelist (behavioral + principles) regardless of taskType", async () => {
-        vi.mocked(searchByText).mockResolvedValue([]);
-        await layer3EeInjection(makeCtx({ taskType: "refactor" }));
-        // 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));
-        // 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)", () => {
-    test("emits principles + experience blocks from ctx._brainData without brain call", async () => {
-        const { layer3EeInjection } = await import("../layer3-ee-injection.js");
-        const ctx = {
-            raw: "x",
-            enriched: "x",
-            taskType: "debug",
-            domain: null,
-            confidence: 0.85,
-            outputStyle: "balanced",
-            tokenBudget: 2000,
-            metrics: null,
-            layers: [],
-            _brainData: {
-                t0_principles: [{ text: "always run tests", score: 0.9 }],
-                t1_rules: ["never skip tests"],
-                t2_patterns: [{ text: "mock fs in unit tests", score: 0.7 }],
-                retrieval_skipped_reason: null,
-            },
-        };
-        const result = await layer3EeInjection(ctx);
-        expect(result.enriched).toContain("always run tests");
-        expect(result.enriched).toContain("mock fs in unit tests");
-        expect(result.t1Rules).toEqual(["never skip tests"]);
-    });
-    test("unified path: records rateable points (with id) into the ledger + names [id collection] in the reminder", async () => {
-        // Symmetric with the legacy-path recall-loop closure. When the server (PIL
-        // schema_version 1.1+) attributes points with id/collection, the unified
-        // formatter must record them as pending debt and surface an actionable reminder.
-        sessionRecallLedger.reset();
-        const { layer3EeInjection } = await import("../layer3-ee-injection.js");
-        const ctx = {
-            raw: "x",
-            enriched: "x",
-            taskType: "debug",
-            domain: null,
-            confidence: 0.85,
-            outputStyle: "balanced",
-            tokenBudget: 2000,
-            metrics: null,
-            layers: [],
-            _brainData: {
-                t0_principles: [{ text: "always run tests", score: 0.9, id: "pr1", collection: "experience-principles" }],
-                t1_rules: [],
-                t2_patterns: [{ text: "mock fs in unit tests", score: 0.7, id: "be1", collection: "experience-behavioral" }],
-                retrieval_skipped_reason: null,
-            },
-        };
-        const result = await layer3EeInjection(ctx);
-        // Inline [id:..] handle rendered so the reminder refers to something visible.
-        expect(result.enriched).toContain("[id:pr1]");
-        // Dynamic reminder names the actual [id collection] so ee_feedback is actionable.
-        expect(result.enriched).toMatch(/ee_feedback\(id, collection, followed\|ignored\|noise\)/);
-        expect(result.enriched).toContain("[pr1 experience-principles]");
-        expect(result.enriched).toContain("[be1 experience-behavioral]");
-        // Both points recorded as rateable pending debt.
-        expect(sessionRecallLedger.pendingCount()).toBe(2);
-    });
-    test("unified path: no id (older server) renders text but stays unrateable (static nudge)", async () => {
-        sessionRecallLedger.reset();
-        const { layer3EeInjection } = await import("../layer3-ee-injection.js");
-        const ctx = {
-            raw: "x",
-            enriched: "x",
-            taskType: "debug",
-            domain: null,
-            confidence: 0.85,
-            outputStyle: "balanced",
-            tokenBudget: 2000,
-            metrics: null,
-            layers: [],
-            _brainData: {
-                t0_principles: [{ text: "always run tests", score: 0.9 }],
-                t1_rules: [],
-                t2_patterns: [{ text: "mock fs in unit tests", score: 0.7 }],
-                retrieval_skipped_reason: null,
-            },
-        };
-        const result = await layer3EeInjection(ctx);
-        expect(result.enriched).toContain("always run tests");
-        // No ids → nothing recorded; the static nudge is the fallback.
-        expect(sessionRecallLedger.pendingCount()).toBe(0);
-        expect(result.enriched).toContain(RECALL_FEEDBACK_NUDGE);
-    });
-    test("emits no block when ctx._brainData is null AND legacy disabled by flag", async () => {
-        const { layer3EeInjection } = await import("../layer3-ee-injection.js");
-        const ctx = {
-            raw: "x",
-            enriched: "x",
-            taskType: "debug",
-            domain: null,
-            confidence: 0.85,
-            outputStyle: "balanced",
-            tokenBudget: 2000,
-            metrics: null,
-            layers: [],
-            _brainData: null,
-        };
-        const result = await layer3EeInjection(ctx);
-        expect(result.layers[0].name).toBe("ee-experience-injection");
-    });
-});
-//# sourceMappingURL=layer3-ee-injection.test.js.map

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

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

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

@@ -1,134 +0,0 @@
-/**
- * layer3-injected-chunk.test.ts
- *
- * CQ-16b regression tests: layer3EeInjection emits experience_injected StreamChunk
- * when searchByText returns high-score points. Verifies observable sink behavior
- * locked after Wave 1/3 changes to layer3-ee-injection.ts.
- */
-import { beforeEach, describe, expect, it, vi } from "vitest";
-// Hoisted so mocks can reference them before module initialization
-const mockSearchByText = vi.hoisted(() => vi.fn().mockResolvedValue([]));
-const capturedSinkCalls = [];
-vi.mock("../../ee/bridge.js", () => ({
-    searchByText: mockSearchByText,
-}));
-vi.mock("../../ee/render.js", () => ({
-    getRenderSink: vi.fn(() => (c) => capturedSinkCalls.push(c)),
-    setRenderSink: vi.fn(),
-}));
-// Mock interaction-log to prevent DB writes in tests
-vi.mock("../../storage/interaction-log.js", () => ({
-    logInteraction: vi.fn(),
-}));
-// Mock intercept (updateLastSurfacedState)
-vi.mock("../../ee/intercept.js", () => ({
-    updateLastSurfacedState: vi.fn(),
-}));
-import { sessionRecallLedger } from "../../ee/recall-ledger.js";
-import { layer3EeInjection } from "../layer3-ee-injection.js";
-const BASE_CTX = {
-    raw: "test prompt for experience injection",
-    enriched: "",
-    layers: [],
-    tokenBudget: 4096,
-    sessionId: "test-session",
-    taskType: "general",
-    domain: "frontend",
-    outputStyle: null,
-    confidence: 0.8,
-    metrics: null,
-};
-describe("layer3 experience_injected chunk emission (CQ-16b)", () => {
-    beforeEach(() => {
-        capturedSinkCalls.length = 0;
-        mockSearchByText.mockResolvedValue([]);
-        // Reset the process-singleton recall ledger so pending debt from a prior test
-        // does not change the dynamic feedback reminder content of the next.
-        sessionRecallLedger.reset();
-    });
-    it("emits experience_injected chunk when searchByText returns high-score point", async () => {
-        mockSearchByText.mockResolvedValue([
-            {
-                id: "point-1",
-                score: 0.9,
-                payload: { text: "Use dependency injection for testability" },
-                collection: "experience-behavioral",
-            },
-        ]);
-        await layer3EeInjection(BASE_CTX);
-        const injectedChunk = capturedSinkCalls.find((c) => typeof c !== "string" && c.type === "experience_injected");
-        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 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 () => {
-        mockSearchByText.mockResolvedValue([
-            {
-                id: "p1",
-                score: 0.9,
-                payload: { text: "hint text" },
-                collection: "experience-behavioral",
-            },
-        ]);
-        await layer3EeInjection(BASE_CTX);
-        const chunk = capturedSinkCalls.find((c) => typeof c !== "string" && c.type === "experience_injected");
-        expect(chunk?.experienceInjected?.scoreFloor).toBeDefined();
-        expect(typeof chunk?.experienceInjected?.scoreFloor).toBe("number");
-    });
-    it("experience_injected chunk carries per-point {id, title, tier} so the TUI can show WHAT was injected", async () => {
-        mockSearchByText.mockResolvedValue([
-            {
-                id: "point-1",
-                score: 0.9,
-                payload: { text: "Use dependency injection for testability" },
-                collection: "experience-behavioral",
-            },
-        ]);
-        await layer3EeInjection(BASE_CTX);
-        const chunk = capturedSinkCalls.find((c) => typeof c !== "string" && c.type === "experience_injected");
-        const points = chunk?.experienceInjected?.points;
-        expect(Array.isArray(points)).toBe(true);
-        expect(points.length).toBeGreaterThan(0);
-        const p = points[0];
-        expect(p.id).toBe("point-1");
-        expect(p.title).toContain("dependency injection");
-        expect(["principle", "behavioral", "checkpoint"]).toContain(p.tier);
-    });
-    it("appends an ee_feedback nudge to the injected text when rateable experience is present", async () => {
-        mockSearchByText.mockResolvedValue([
-            {
-                id: "p1",
-                score: 0.9,
-                payload: { text: "Prefer composition over inheritance" },
-                collection: "experience-behavioral",
-            },
-        ]);
-        const result = await layer3EeInjection({ ...BASE_CTX, sessionId: "test-session-nudge" });
-        // The dynamic pending-feedback reminder replaced the fixed nudge when the ledger
-        // is enabled (default soft); it names the actual [id collection] so ee_feedback is
-        // actionable. Accept either form (reminder when the ledger recorded debt, or the
-        // static fallback when disabled).
-        expect(result.enriched).toMatch(/ee_feedback\(id, (collection, )?followed\|ignored\|noise\)/);
-        // Reminder names the actual [id collection]; the mock returns the same point in
-        // both search arms so the principles arm wins first-sighting (real searches return
-        // distinct points per collection) — assert id-named, collection-agnostic.
-        expect(result.enriched).toMatch(/\[p1 experience-(principles|behavioral)\]/);
-    });
-    it("does NOT emit experience_injected when searchByText returns empty array", async () => {
-        mockSearchByText.mockResolvedValue([]);
-        await layer3EeInjection(BASE_CTX);
-        const injectedChunk = capturedSinkCalls.find((c) => typeof c !== "string" && c.type === "experience_injected");
-        expect(injectedChunk).toBeUndefined();
-    });
-    it("does NOT emit experience_injected when searchByText throws (error path)", async () => {
-        mockSearchByText.mockRejectedValue(new Error("VPS unreachable"));
-        await layer3EeInjection(BASE_CTX);
-        const injectedChunk = capturedSinkCalls.find((c) => typeof c !== "string" && c.type === "experience_injected");
-        expect(injectedChunk).toBeUndefined();
-    });
-});
-//# sourceMappingURL=layer3-injected-chunk.test.js.map

package/dist/src/pil/__tests__/layer4-gsd.test.d.ts

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

package/dist/src/pil/__tests__/layer4-gsd.test.js

@@ -1,191 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-vi.mock("../../ee/bridge.js", () => ({
-    routeTask: vi.fn().mockResolvedValue(null),
-    // WhoAmI v4.0: L4 reads delegation_style to bias a 'discuss' phase. Default null
-    // = fail-open, so every pre-existing test below behaves exactly as before.
-    getWhoAmIProfile: vi.fn(() => null),
-}));
-import { getWhoAmIProfile } from "../../ee/bridge.js";
-import { layer4Gsd } from "../layer4-gsd.js";
-function makeCtx(overrides = {}) {
-    return {
-        raw: "implement the login feature",
-        enriched: "implement the login feature",
-        taskType: "generate",
-        domain: null,
-        confidence: 0.9,
-        outputStyle: "concise",
-        tokenBudget: 500,
-        metrics: null,
-        layers: [],
-        ...overrides,
-    };
-}
-describe("layer4Gsd (playbook)", () => {
-    it("skips directive injection when intentKind === 'chitchat'", async () => {
-        const before = "hello";
-        const result = await layer4Gsd(makeCtx({ raw: before, enriched: before, intentKind: "chitchat" }));
-        expect(result.enriched).toBe(before);
-        const layer = result.layers.find((l) => l.name === "gsd-workflow-structuring");
-        expect(layer.applied).toBe(false);
-        expect(layer.delta).toBe("skip:chitchat");
-    });
-    it("appends a playbook directive and records the layer as applied", async () => {
-        const result = await layer4Gsd(makeCtx({ raw: "implement the login feature" }));
-        expect(result.enriched).toContain("[playbook]");
-        const layer = result.layers.find((l) => l.name === "gsd-workflow-structuring");
-        expect(layer).toBeDefined();
-        expect(layer.applied).toBe(true);
-        expect(layer.delta).toMatch(/tier=(quick|standard|heavy)/);
-    });
-    it("preserves an already-set gsdPhase from context", async () => {
-        const result = await layer4Gsd(makeCtx({ gsdPhase: "plan", raw: "do something" }));
-        const layer = result.layers.find((l) => l.name === "gsd-workflow-structuring");
-        expect(layer.delta).toContain("phase=plan");
-    });
-    it("emits a HEAVY directive when the model classifies depth=heavy (agent-first, not regex)", async () => {
-        // Depth now comes from ctx.modelDepthTier (the model's 5th classify word),
-        // NOT a regex scan of the raw prompt. A plainly-phrased prompt the model
-        // judged heavy still gets the full discuss → research → check-plan flow.
-        const result = await layer4Gsd(makeCtx({ raw: "rework how auth works", tokenBudget: 8000, modelDepthTier: "heavy" }));
-        const layer = result.layers.find((l) => l.name === "gsd-workflow-structuring");
-        expect(layer.delta).toContain("tier=heavy");
-        expect(layer.delta).toContain("depth=model");
-        expect(result.enriched).toMatch(/HEAVY task/);
-        expect(result.enriched).toMatch(/DISCUSS/);
-        expect(result.enriched).toMatch(/AskUserQuestion/);
-        expect(result.enriched).toMatch(/CHECK-PLAN/);
-    });
-    it("emits a QUICK directive when the model classifies depth=quick", async () => {
-        const result = await layer4Gsd(makeCtx({ raw: "fix typo in README", modelDepthTier: "quick" }));
-        const layer = result.layers.find((l) => l.name === "gsd-workflow-structuring");
-        expect(layer.delta).toContain("tier=quick");
-        expect(layer.delta).toContain("depth=model");
-    });
-    it("defaults to STANDARD tier when the model supplied no depth (no regex fallback)", async () => {
-        const result = await layer4Gsd(makeCtx({ raw: "do the thing", modelDepthTier: null }));
-        const layer = result.layers.find((l) => l.name === "gsd-workflow-structuring");
-        expect(layer.delta).toContain("tier=standard");
-        expect(layer.delta).toContain("depth=default");
-    });
-    it("still records a layer entry even when no phase is detected", async () => {
-        const result = await layer4Gsd(makeCtx({ raw: "hello there", gsdPhase: null }));
-        const layer = result.layers.find((l) => l.name === "gsd-workflow-structuring");
-        expect(layer).toBeDefined();
-        expect(layer.applied).toBe(true);
-        expect(layer.delta).toMatch(/phase=(none|discuss|plan|execute|verify|review)/);
-    });
-    it("floors the directive budget so the rubric survives at the default tokenBudget (regression: directive was truncated to ~500 chars)", async () => {
-        // The playbook directive is a critical behavioural instruction and must NOT
-        // be gutted by the tiny pipeline budget. At the production default
-        // tokenBudget=500 the bare 25% fraction was ~500 chars, which cut the HEAVY
-        // rubric after step 1. The floor (DIRECTIVE_MIN_TOKENS) guarantees the full
-        // ~1.7K-char HEAVY rubric reaches the model intact.
-        const result = await layer4Gsd(makeCtx({ raw: "rework auth", tokenBudget: 500, modelDepthTier: "heavy" }));
-        expect(result.enriched).toMatch(/DISCUSS/);
-        expect(result.enriched).toMatch(/CHECK-PLAN/);
-        expect(result.enriched).toMatch(/VERIFY/);
-        expect(result.enriched).toMatch(/todo_write/);
-    });
-    it("does NOT keyword-detect a phase from the raw prompt (agent-first, no regex)", async () => {
-        // Phase keyword detection was removed: a regex scan of the prompt would
-        // mislabel the directive. Phase is sourced only from ctx.gsdPhase (L1
-        // unified) or the EE brain route. With neither, it stays null/undefined.
-        const result = await layer4Gsd(makeCtx({ raw: "review the pull request" }));
-        expect(result.gsdPhase ?? null).toBeNull();
-        const layer = result.layers.find((l) => l.name === "gsd-workflow-structuring");
-        expect(layer.delta).toContain("phase=none");
-    });
-    it("routes a question-shaped analyze/debug prompt to the QUESTION directive (no 'state a plan')", async () => {
-        // De-robotizing: a plain question must not get the STANDARD "state a 2-3 line
-        // plan" scaffold even when L1 classifies it analyze/debug (not "general").
-        const q = "why does the build fail intermittently?";
-        const result = await layer4Gsd(makeCtx({ raw: q, enriched: q, taskType: "debug", intentKind: "task" }));
-        expect(result.enriched).toContain("QUESTION / explanatory");
-        expect(result.enriched).not.toContain("State a 2-3 line plan");
-    });
-    it("treats a genuine general question (general + task) as informational", async () => {
-        const q = "what does the enrichment layer do?";
-        const result = await layer4Gsd(makeCtx({ raw: q, enriched: q, taskType: "general", intentKind: "task" }));
-        expect(result.enriched).toContain("QUESTION / explanatory");
-    });
-    it("does NOT treat an implementation request as informational even if phrased as a question", async () => {
-        // isImplementationIntent guards the question clause: "can you refactor … and
-        // wire up …" is a real edit task → STANDARD scaffold, not the QUESTION directive.
-        const q = "can you refactor the dropdown and wire up the keyboard handlers?";
-        const result = await layer4Gsd(makeCtx({ raw: q, enriched: q, taskType: "refactor", intentKind: "task" }));
-        expect(result.enriched).not.toContain("QUESTION / explanatory");
-    });
-    it("Phase 2b: deliverableKind='answer' is informational even for an imperative (no '?') prompt", async () => {
-        // The raw text is a plain imperative — the legacy regex (isQuestionLike /
-        // isMetaAnalysisPrompt) would NOT mark it informational. The model's
-        // deliverableKind='answer' must override that and route to the QUESTION
-        // directive — proving L4 consumes the model signal, not the regex.
-        const raw = "go over the auth module and tell me what it does";
-        const result = await layer4Gsd(makeCtx({ raw, enriched: raw, taskType: "analyze", intentKind: "task", deliverableKind: "answer" }));
-        expect(result.enriched).toContain("QUESTION / explanatory");
-    });
-    it("deliverableKind='report' is informational (no council/discuss scaffold) — session 666630479c1a", async () => {
-        // "Đọc và tóm tắt kiến trúc…" classifies as deliverableKind 'report'. A
-        // report is human-facing with NO code change, so it must route to the
-        // QUESTION directive, not the heavy implement/discuss/council scaffold that
-        // over-asked with askcards on a read/summarize task.
-        const raw = "đọc và tóm tắt kiến trúc src/orchestrator, src/pil, src/mcp kèm file:line";
-        const result = await layer4Gsd(makeCtx({ raw, enriched: raw, taskType: "analyze", intentKind: "task", deliverableKind: "report" }));
-        expect(result.enriched).toContain("QUESTION / explanatory");
-        expect(result.enriched).not.toContain("MANDATORY");
-    });
-    it("Phase 2b: deliverableKind='code' is NOT informational even for a question-shaped prompt", async () => {
-        // The raw text reads as a question — the legacy regex would mark it
-        // informational. The model's deliverableKind='code' must override that so
-        // the STANDARD implement scaffold is used (the deliverable is file edits).
-        const raw = "why not just refactor the dropdown and wire the keyboard handlers?";
-        const result = await layer4Gsd(makeCtx({ raw, enriched: raw, taskType: "refactor", intentKind: "task", deliverableKind: "code" }));
-        expect(result.enriched).not.toContain("QUESTION / explanatory");
-    });
-    it("autonomous delegation drops a 'discuss' phase (WhoAmI v4.0 bias toward direct)", async () => {
-        vi.mocked(getWhoAmIProfile).mockReturnValueOnce({
-            level: "standard",
-            dims: { "work_patterns.delegation_style": { value: "autonomous", confidence: 0.68, samples: 19 } },
-        });
-        const result = await layer4Gsd(makeCtx({ gsdPhase: "discuss", raw: "do the thing" }));
-        expect(result.gsdPhase ?? null).toBeNull();
-        const layer = result.layers.find((l) => l.name === "gsd-workflow-structuring");
-        expect(layer.delta).toContain("phase=none");
-        expect(layer.delta).toContain("autonomous:skip-discuss");
-    });
-    it("collaborative delegation keeps the 'discuss' phase", async () => {
-        vi.mocked(getWhoAmIProfile).mockReturnValueOnce({
-            level: "standard",
-            dims: { "work_patterns.delegation_style": { value: "collaborative", confidence: 0.7, samples: 20 } },
-        });
-        const result = await layer4Gsd(makeCtx({ gsdPhase: "discuss", raw: "do the thing" }));
-        expect(result.gsdPhase).toBe("discuss");
-        const layer = result.layers.find((l) => l.name === "gsd-workflow-structuring");
-        expect(layer.delta).toContain("phase=discuss");
-    });
-    it("absent profile leaves 'discuss' untouched (fail-open default)", async () => {
-        // getWhoAmIProfile defaults to null in the mock — the phase must be unchanged.
-        const result = await layer4Gsd(makeCtx({ gsdPhase: "discuss", raw: "do the thing" }));
-        expect(result.gsdPhase).toBe("discuss");
-    });
-    it("uses ctx.gsdPhase from L1 (unified path) without calling routeTask", async () => {
-        const { routeTask } = await import("../../ee/bridge.js");
-        vi.mocked(routeTask).mockClear();
-        await layer4Gsd({
-            raw: "x",
-            enriched: "x",
-            taskType: "debug",
-            domain: null,
-            confidence: 0.85,
-            outputStyle: "balanced",
-            tokenBudget: 2000,
-            metrics: null,
-            layers: [],
-            gsdPhase: "execute",
-            _brainData: { t0_principles: [], t1_rules: [], t2_patterns: [], retrieval_skipped_reason: null },
-        });
-        expect(routeTask).not.toHaveBeenCalled();
-    });
-});
-//# sourceMappingURL=layer4-gsd.test.js.map

package/dist/src/pil/__tests__/layer5-context.test.d.ts

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