muonroi-cli 1.4.0 → 1.5.0

package/src/pil/__tests__/layer1-intent.test.ts

@@ -1,365 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { PipelineContext } from "../types.js";
-
-vi.mock("../../router/classifier/index.js", () => ({
-  classify: vi.fn(),
-}));
-
-vi.mock("../config.js", () => ({
-  isUnifiedPilEnabled: vi.fn(() => false),
-}));
-
-vi.mock("../../ee/bridge.js", () => ({
-  classifyViaBrain: vi.fn().mockResolvedValue(null),
-  pilContext: vi.fn().mockResolvedValue(null),
-}));
-
-import { classifyViaBrain, pilContext } from "../../ee/bridge.js";
-import { classify } from "../../router/classifier/index.js";
-import { isUnifiedPilEnabled } from "../config.js";
-import { layer1Intent } from "../layer1-intent.js";
-
-const mockClassify = vi.mocked(classify);
-const mockClassifyViaBrain = vi.mocked(classifyViaBrain);
-const mockPilContext = vi.mocked(pilContext);
-const mockIsUnifiedPilEnabled = vi.mocked(isUnifiedPilEnabled);
-
-const makeCtx = (raw = "test prompt"): PipelineContext => ({
-  raw,
-  enriched: raw,
-  taskType: null,
-  domain: null,
-  confidence: 0,
-  outputStyle: null,
-  tokenBudget: 500,
-  metrics: null,
-  layers: [],
-});
-
-beforeEach(() => {
-  vi.clearAllMocks();
-});
-
-describe("layer1Intent — classifier pass", () => {
-  it("regex:refactor → refactor, confidence stored", async () => {
-    mockClassify.mockReturnValue({ tier: "hot", confidence: 0.85, reason: "regex:refactor" });
-    const result = await layer1Intent(makeCtx("refactor this function"));
-    expect(result.taskType).toBe("refactor");
-    expect(result.confidence).toBe(0.85);
-    expect(result.layers[0].applied).toBe(true);
-    expect(result.layers[0].delta).toContain("taskType=refactor");
-    expect(result.layers[0].delta).toContain("conf=0.85");
-  });
-
-  it("regex:edit → generate", async () => {
-    mockClassify.mockReturnValue({ tier: "hot", confidence: 0.8, reason: "regex:edit" });
-    const result = await layer1Intent(makeCtx("edit the file"));
-    expect(result.taskType).toBe("generate");
-  });
-
-  it("regex:install → analyze", async () => {
-    mockClassify.mockReturnValue({ tier: "hot", confidence: 0.85, reason: "regex:install" });
-    const result = await layer1Intent(makeCtx("install the package"));
-    expect(result.taskType).toBe("analyze");
-    expect(result.layers[0].applied).toBe(true);
-  });
-
-  it("regex:run-command → analyze", async () => {
-    mockClassify.mockReturnValue({ tier: "hot", confidence: 0.85, reason: "regex:run-command" });
-    const result = await layer1Intent(makeCtx("run bun test"));
-    expect(result.taskType).toBe("analyze");
-  });
-
-  it("tree-sitter:typescript → no intent signal (Phase 4 4P-1), domain still extracted", async () => {
-    // Phase 4 4P-1: tree-sitter parse reasons no longer imply refactor.
-    // They indicate code PRESENCE but carry no intent. taskType falls through
-    // to Pass 2 keyword fallback; here "const x = 1" matches nothing → null.
-    mockClassify.mockReturnValue({ tier: "hot", confidence: 0.8, reason: "tree-sitter:typescript" });
-    const result = await layer1Intent(makeCtx("const x = 1"));
-    expect(result.taskType).toBeNull();
-    expect(result.domain).toBe("typescript");
-    expect(result.layers[0].applied).toBe(false);
-  });
-
-  it("tree-sitter:python → no intent signal (Phase 4 4P-1), domain still extracted", async () => {
-    mockClassify.mockReturnValue({ tier: "hot", confidence: 0.8, reason: "tree-sitter:python" });
-    const result = await layer1Intent(makeCtx("def foo(): pass"));
-    expect(result.taskType).toBeNull();
-    expect(result.domain).toBe("python");
-    expect(result.layers[0].applied).toBe(false);
-  });
-
-  it("low-confidence → null taskType, applied=false", async () => {
-    mockClassify.mockReturnValue({ tier: "abstain", confidence: 0.3, reason: "low-confidence" });
-    // Use a non-social low-signal phrase: a greeting like "hello there" now
-    // correctly resolves to chitchat via the Pass 2.6 social-pleasantry gate,
-    // so it would no longer be null. This asserts the low-confidence→null path
-    // for genuinely-ambiguous (non-pleasantry) input.
-    const result = await layer1Intent(makeCtx("lorem ipsum dolor sit"));
-    expect(result.taskType).toBeNull();
-    expect(result.layers[0].applied).toBe(false);
-    expect(result.layers[0].delta).toBeNull();
-  });
-
-  it("regex:search → analyze", async () => {
-    mockClassify.mockReturnValue({ tier: "hot", confidence: 0.8, reason: "regex:search" });
-    const result = await layer1Intent(makeCtx("search for the function"));
-    expect(result.taskType).toBe("analyze");
-  });
-});
-
-describe("layer1Intent — keyword fallback (classifier returns null)", () => {
-  beforeEach(() => {
-    // Simulate classifier abstain so keyword fallback activates
-    mockClassify.mockReturnValue({ tier: "abstain", confidence: 0.2, reason: "low-confidence" });
-  });
-
-  it('keyword "bug" → debug', async () => {
-    const result = await layer1Intent(makeCtx("there is a bug in the login flow"));
-    expect(result.taskType).toBe("debug");
-    expect(result.confidence).toBe(0.65);
-    expect(result.layers[0].applied).toBe(true);
-  });
-
-  it('keyword "error" → debug', async () => {
-    const result = await layer1Intent(makeCtx("getting an error on line 42"));
-    expect(result.taskType).toBe("debug");
-  });
-
-  it('keyword "plan" → plan', async () => {
-    const result = await layer1Intent(makeCtx("plan the refactor approach"));
-    expect(result.taskType).toBe("plan");
-    expect(result.confidence).toBe(0.6);
-  });
-
-  it('keyword "docs" → documentation', async () => {
-    const result = await layer1Intent(makeCtx("write docs for this module"));
-    expect(result.taskType).toBe("documentation");
-    expect(result.confidence).toBe(0.6);
-  });
-
-  // Phase 5 BUG-E — "write tests for X" is a test-generation task, not analyze.
-  // Pass 0 pins it to `generate` deterministically before the Pass 2 keyword
-  // fallback (which used to map any test-keyword to analyze).
-  it('keyword "write tests" → generate (Pass 0 test-generation pin)', async () => {
-    const result = await layer1Intent(makeCtx("write tests for the auth module"));
-    expect(result.taskType).toBe("generate");
-  });
-
-  // The bare "test" / "kiểm thử" keyword without a write/add verb still falls
-  // through Pass 0 (verb guard) — Pass 2 keyword fallback can then label it
-  // analyze when the request is about REVIEWING the test surface.
-  it('keyword "review tests" (no write verb) → analyze via Pass 2 keyword', async () => {
-    const result = await layer1Intent(makeCtx("review the tests for the auth module"));
-    expect(result.taskType).toBe("analyze");
-  });
-
-  it("no keyword match → null (still conversational)", async () => {
-    const result = await layer1Intent(makeCtx("hello how are you"));
-    expect(result.taskType).toBeNull();
-    expect(result.layers[0].applied).toBe(false);
-  });
-});
-
-describe("layer1Intent — outputStyle detection", () => {
-  it("coding task via pass1 → outputStyle defaults to balanced without brain call", async () => {
-    mockClassify.mockReturnValue({ tier: "hot", confidence: 0.85, reason: "regex:refactor" });
-    const result = await layer1Intent(makeCtx("refactor this function"));
-    // Style brain is skipped when pass1 decided cheaply — default "balanced"
-    expect(result.outputStyle).toBe("balanced");
-    expect(mockClassifyViaBrain).not.toHaveBeenCalledWith(expect.stringContaining("preferred output style"), 800);
-  });
-
-  it("coding task via pass2 (keyword) → outputStyle defaults to balanced without brain call", async () => {
-    mockClassify.mockReturnValue({ tier: "abstain", confidence: 0.2, reason: "low-confidence" });
-    const result = await layer1Intent(makeCtx("there is a bug here"));
-    expect(result.outputStyle).toBe("balanced");
-    expect(mockClassifyViaBrain).not.toHaveBeenCalledWith(expect.stringContaining("preferred output style"), 800);
-  });
-
-  it("conversational turn (taskType=null) → outputStyle=null, no style brain call", async () => {
-    mockClassify.mockReturnValue({ tier: "abstain", confidence: 0.2, reason: "low-confidence" });
-    mockClassifyViaBrain.mockResolvedValue(null);
-    const result = await layer1Intent(makeCtx("hello how are you"));
-    expect(result.outputStyle).toBeNull();
-  });
-});
-
-describe("layer1Intent — EE brain bridge fallback (Pass 3)", () => {
-  beforeEach(() => {
-    mockClassify.mockReturnValue({ tier: "abstain", confidence: 0.2, reason: "low-confidence" });
-    mockClassifyViaBrain.mockResolvedValue(null);
-  });
-
-  it("classifyViaBrain called when classifier and keywords both miss", async () => {
-    await layer1Intent(makeCtx("some ambiguous input without keywords"));
-    expect(mockClassifyViaBrain).toHaveBeenCalled();
-    expect(mockClassifyViaBrain).toHaveBeenCalledWith(expect.stringContaining("multilingual prompt classifier"), 1500);
-  });
-
-  it("classifyViaBrain called with prompt containing task type and style instruction", async () => {
-    await layer1Intent(makeCtx("some ambiguous input"));
-    const [promptArg] = mockClassifyViaBrain.mock.calls[0];
-    expect(promptArg).toContain("refactor");
-    expect(promptArg).toContain("debug");
-    expect(promptArg).toContain("concise");
-    expect(promptArg).toContain("detailed");
-  });
-
-  it("classifyViaBrain called with 1500ms timeout for combined detection (brain-LLM realistic latency)", async () => {
-    await layer1Intent(makeCtx("some ambiguous input"));
-    expect(mockClassifyViaBrain).toHaveBeenCalledWith(expect.any(String), 1500);
-  });
-
-  it("brain returns 'debug' → taskType='debug', confidence=0.55", async () => {
-    mockClassifyViaBrain.mockResolvedValue("debug");
-    const result = await layer1Intent(makeCtx("some ambiguous input"));
-    expect(result.taskType).toBe("debug");
-    expect(result.confidence).toBe(0.55);
-  });
-
-  it("brain returns null (absent/timeout) → taskType stays null", async () => {
-    mockClassifyViaBrain.mockResolvedValue(null);
-    const result = await layer1Intent(makeCtx("some ambiguous input"));
-    expect(result.taskType).toBeNull();
-  });
-
-  it("brain returns 'none' → marked as chitchat (intentKind), taskType=general", async () => {
-    mockClassifyViaBrain.mockResolvedValue("none");
-    const result = await layer1Intent(makeCtx("some ambiguous input"));
-    expect(result.taskType).toBe("general");
-    expect(result.intentKind).toBe("chitchat");
-  });
-
-  it("brain returns garbage → taskType stays null", async () => {
-    mockClassifyViaBrain.mockResolvedValue("I cannot classify this prompt");
-    const result = await layer1Intent(makeCtx("some ambiguous input"));
-    expect(result.taskType).toBeNull();
-  });
-
-  it("style brain NOT called when pass1 already decided coding task (saves 800ms)", async () => {
-    mockClassify.mockReturnValue({ tier: "hot", confidence: 0.85, reason: "regex:refactor" });
-    await layer1Intent(makeCtx("refactor this"));
-    const styleCall = mockClassifyViaBrain.mock.calls.find((c) => String(c[0]).includes("preferred output style"));
-    expect(styleCall).toBeUndefined();
-  });
-
-  it("style brain NOT called when pass2 keyword fallback decided task", async () => {
-    await layer1Intent(makeCtx("there is a bug here"));
-    const styleCall = mockClassifyViaBrain.mock.calls.find((c) => String(c[0]).includes("preferred output style"));
-    expect(styleCall).toBeUndefined();
-  });
-
-  it("style brain IS called when task itself was ambiguous and needed brain classification", async () => {
-    // Task brain returns task only (no style token) → style brain fires next.
-    mockClassifyViaBrain
-      .mockResolvedValueOnce("debug") // task brain: no style token
-      .mockResolvedValueOnce("balanced"); // style brain
-    await layer1Intent(makeCtx("some completely ambiguous input without keywords"));
-    const styleCall = mockClassifyViaBrain.mock.calls.find((c) => String(c[0]).includes("preferred output style"));
-    expect(styleCall).toBeDefined();
-  });
-});
-
-describe("Layer 1 unified path", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    // default: low-signal classifier so unified path becomes eligible
-    mockClassify.mockReturnValue({ tier: "abstain", confidence: 0.2, reason: "low-confidence" });
-  });
-
-  it("calls pilContext when flag enabled AND local classify is low confidence", async () => {
-    mockIsUnifiedPilEnabled.mockReturnValue(true);
-    mockPilContext.mockResolvedValueOnce({
-      taskType: "debug",
-      intentKind: "task",
-      outputStyle: "balanced",
-      confidence: 0.85,
-      domain: "typescript",
-      gsd_phase: "execute",
-      gsd_route_source: "ee",
-      t0_principles: [{ text: "p1", score: 0.9 }],
-      t1_rules: ["r1"],
-      t2_patterns: [{ text: "x", score: 0.7 }],
-      retrieval_skipped_reason: null,
-      cache_hit: false,
-      inference_ms: 200,
-      schema_version: "1.0",
-    });
-    const result = await layer1Intent({
-      raw: "ambiguous prompt",
-      enriched: "",
-      taskType: null,
-      domain: null,
-      confidence: 0,
-      outputStyle: null,
-      tokenBudget: 500,
-      metrics: null,
-      layers: [],
-    });
-    expect(result.taskType).toBe("debug");
-    expect(result.outputStyle).toBe("balanced");
-    expect(result._brainData?.t0_principles).toHaveLength(1);
-    expect(result._brainData?.t1_rules).toEqual(["r1"]);
-    expect(result.layers[0].delta).toContain("unified=ok");
-  });
-
-  it("skips pilContext when local classify yields high confidence (>= 0.7)", async () => {
-    mockIsUnifiedPilEnabled.mockReturnValue(true);
-    mockClassify.mockReturnValue({ tier: "hot", confidence: 0.85, reason: "regex:refactor" });
-    await layer1Intent({
-      raw: "refactor this function please",
-      enriched: "",
-      taskType: null,
-      domain: null,
-      confidence: 0,
-      outputStyle: null,
-      tokenBudget: 500,
-      metrics: null,
-      layers: [],
-    });
-    expect(mockPilContext).not.toHaveBeenCalled();
-  });
-
-  it("does NOT fall back to legacy classifyViaBrain when pilContext returns null (cost optimization)", async () => {
-    // When unified PIL is enabled and its single call fails, calling the same
-    // backend a second time via classifyViaBrain wastes ~2.3s and tokens on a
-    // network that just timed out. We mark _brainData with a sentinel so L6
-    // also skips its rescue call.
-    mockIsUnifiedPilEnabled.mockReturnValue(true);
-    mockPilContext.mockResolvedValueOnce(null);
-    const result = await layer1Intent({
-      raw: "vague question",
-      enriched: "",
-      taskType: null,
-      domain: null,
-      confidence: 0,
-      outputStyle: null,
-      tokenBudget: 500,
-      metrics: null,
-      layers: [],
-    });
-    expect(mockClassifyViaBrain).not.toHaveBeenCalled();
-    expect(result.taskType).toBeNull();
-    expect(result._brainData).toEqual({
-      t0_principles: [],
-      t1_rules: [],
-      t2_patterns: [],
-      retrieval_skipped_reason: "unified-failed",
-    });
-    expect(result.layers[0].delta).toContain("unified=fail");
-  });
-});
-
-describe("layer1Intent — error handling", () => {
-  it("classify throws → ctx unchanged, applied=false", async () => {
-    mockClassify.mockImplementation(() => {
-      throw new Error("classify failed");
-    });
-    const ctx = makeCtx("some prompt");
-    const result = await layer1Intent(ctx);
-    expect(result.taskType).toBeNull();
-    expect(result.layers[0].applied).toBe(false);
-    expect(result.enriched).toBe(ctx.enriched);
-  });
-});

package/src/pil/__tests__/layer15-context-scan.test.ts

@@ -1,76 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-vi.mock("../../ee/bridge.js", () => ({
-  searchByText: vi.fn().mockResolvedValue([]),
-}));
-
-import {
-  detectFramework,
-  detectLanguage,
-  detectPackageManager,
-  findRelevantModules,
-  scanProjectContext,
-} from "../layer15-context-scan.js";
-
-describe("detectLanguage()", () => {
-  it("detects typescript from tsconfig.json", () => {
-    const exists = (p: string) => p.endsWith("tsconfig.json");
-    expect(detectLanguage("/proj", exists)).toBe("typescript");
-  });
-  it("detects python from pyproject.toml", () => {
-    const exists = (p: string) => p.endsWith("pyproject.toml") || p.endsWith("requirements.txt");
-    expect(detectLanguage("/proj", exists)).toBe("python");
-  });
-  it("returns null when no signal", () => {
-    expect(detectLanguage("/proj", () => false)).toBeNull();
-  });
-});
-
-describe("detectFramework()", () => {
-  it("detects next.js from next.config.js", () => {
-    const exists = (p: string) => p.includes("next.config");
-    expect(detectFramework("/proj", exists, {})).toBe("next");
-  });
-  it("detects express from deps", () => {
-    expect(detectFramework("/proj", () => false, { express: "4.0.0" })).toBe("express");
-  });
-  it("detects angular from angular.json", () => {
-    const exists = (p: string) => p.endsWith("angular.json");
-    expect(detectFramework("/proj", exists, {})).toBe("angular");
-  });
-});
-
-describe("detectPackageManager()", () => {
-  it("detects bun from bun.lockb", () => {
-    const exists = (p: string) => p.endsWith("bun.lockb") || p.endsWith("bun.lock");
-    expect(detectPackageManager("/proj", exists)).toBe("bun");
-  });
-  it("detects npm from package-lock.json", () => {
-    const exists = (p: string) => p.endsWith("package-lock.json");
-    expect(detectPackageManager("/proj", exists)).toBe("npm");
-  });
-});
-
-describe("findRelevantModules()", () => {
-  it("matches keyword against bounded context names", () => {
-    const bcs = [
-      { path: "src/auth/", name: "auth", entryFiles: [], exportedSymbols: [] },
-      { path: "src/billing/", name: "billing", entryFiles: [], exportedSymbols: [] },
-    ];
-    const result = findRelevantModules("fix auth bug", bcs);
-    expect(result).toHaveLength(1);
-    expect(result[0]!.path).toBe("src/auth/");
-  });
-  it("returns empty for no keyword matches", () => {
-    const bcs = [{ path: "src/auth/", name: "auth", entryFiles: [], exportedSymbols: [] }];
-    expect(findRelevantModules("refactor code", bcs)).toHaveLength(0);
-  });
-});
-
-describe("scanProjectContext()", () => {
-  it("returns a ProjectContext with cwd set", async () => {
-    const ctx = await scanProjectContext("hello world", "/proj");
-    expect(ctx.cwd).toBe("/proj");
-    expect(ctx.scannedAt).toBeGreaterThan(0);
-  });
-});

package/src/pil/__tests__/layer16-clarity.test.ts

@@ -1,184 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { ProjectContext } from "../discovery-types.js";
-import { buildInterviewQuestion, detectClarityGaps, resolveGapsNonInteractive } from "../layer16-clarity.js";
-
-const EMPTY_PROJECT: ProjectContext = {
-  language: "typescript",
-  framework: null,
-  packageManager: null,
-  domain: null,
-  boundedContexts: [
-    { path: "src/auth/", name: "auth", entryFiles: ["src/auth/index.ts"], exportedSymbols: ["login", "logout"] },
-    { path: "src/billing/", name: "billing", entryFiles: [], exportedSymbols: [] },
-  ],
-  eePatterns: [],
-  relevantModules: [],
-  scannedAt: Date.now(),
-  cwd: "/proj",
-};
-
-describe("detectClarityGaps()", () => {
-  it("detects outcome gap for vague non-debug prompt", () => {
-    // PIL-L6 fix — debug now joins the autofill set, so vague debug prompts
-    // ("fix auth") no longer trigger an outcome question. Use a generate
-    // prompt instead to still cover the gap-detection path.
-    const gaps = detectClarityGaps("build something", "generate", 0.7, EMPTY_PROJECT);
-    const outcomeGap = gaps.find((g) => g.dimension === "outcome");
-    expect(outcomeGap).toBeDefined();
-  });
-
-  it("does NOT detect outcome gap for vague debug prompt (autofilled)", () => {
-    const gaps = detectClarityGaps("fix auth", "debug", 0.7, EMPTY_PROJECT);
-    const outcomeGap = gaps.find((g) => g.dimension === "outcome");
-    expect(outcomeGap).toBeUndefined();
-  });
-
-  it("does NOT detect an outcome gap for a vague general prompt (B2 intent-swallow guard)", () => {
-    // B2 — a `general` prompt's only outcome options are tautological
-    // ("Task completed" / "Issue resolved"). Asking them lets the default
-    // answer overwrite the user's real request, so the intent collapses to
-    // "general: Task completed" and the original prompt is lost. Skip the
-    // askcard so the outcome falls back to the raw request downstream.
-    const gaps = detectClarityGaps("the project feels messy", "general", 0.7, EMPTY_PROJECT);
-    const outcomeGap = gaps.find((g) => g.dimension === "outcome");
-    expect(outcomeGap).toBeUndefined();
-  });
-
-  it("detects scope gap when no file reference", () => {
-    const gaps = detectClarityGaps("fix auth", "debug", 0.7, EMPTY_PROJECT);
-    const scopeGap = gaps.find((g) => g.dimension === "scope");
-    expect(scopeGap).toBeDefined();
-  });
-
-  it("returns no gaps for specific prompt", () => {
-    const gaps = detectClarityGaps("fix TypeError in src/auth/login.ts:42", "debug", 0.9, EMPTY_PROJECT);
-    expect(gaps).toHaveLength(0);
-  });
-
-  it("scope options include matching bounded contexts", () => {
-    const gaps = detectClarityGaps("fix auth", "debug", 0.7, EMPTY_PROJECT);
-    const scopeGap = gaps.find((g) => g.dimension === "scope");
-    expect(scopeGap?.options.some((o) => o.includes("auth"))).toBe(true);
-  });
-
-  it("does NOT detect a scope gap for a general prompt with no codebase signal (B2-symmetric scope guard)", () => {
-    // Live drive (session 8a87aa060c6a): the pure non-codebase prompt "Reply
-    // with exactly one word: PONG" fired the scope askcard "Which part of the
-    // codebase should this target?" because countFileReferences /
-    // hasExplicitScope / hasOperationalScope were all empty — the detector
-    // assumes every prompt is a codebase task. A general/unclassified prompt
-    // has no codebase dimension to scope, so the question is nonsensical (and
-    // its acceptance card is downstream noise). Skip it, symmetric to the B2
-    // outcome guard; scope falls back to project-root downstream.
-    const gaps = detectClarityGaps("Reply with exactly one word: PONG", "general", 0.6, EMPTY_PROJECT);
-    expect(gaps.find((g) => g.dimension === "scope")).toBeUndefined();
-    // The only candidate gap was scope → general prompt now yields zero gaps,
-    // so discovery never marks interviewed=true and shows no acceptance card.
-    expect(gaps).toHaveLength(0);
-  });
-
-  it("STILL detects a scope gap for a classified (non-general) task with no file reference", () => {
-    // Guard must stay narrow: a real code task that simply omitted a path still
-    // benefits from the scope-narrowing askcard. Only general/null is skipped.
-    const gaps = detectClarityGaps("implement the search feature", "generate", 0.7, EMPTY_PROJECT);
-    expect(gaps.find((g) => g.dimension === "scope")).toBeDefined();
-  });
-
-  it("does NOT detect a scope gap for an image-analysis prompt (image is the scope)", () => {
-    // Live drive (PR#34 probe): "Take a screenshot of the homepage and analyze
-    // the diagram.png image to describe its layout" fired the codebase-scope
-    // askcard "Which part of the codebase should this target?" — nonsensical for
-    // an image-analysis task. The image (screenshot / diagram.png) IS the scope,
-    // symmetric to how operational (CI/build) prompts are scoped to the pipeline.
-    const gaps = detectClarityGaps(
-      "Take a screenshot of the homepage and analyze the diagram.png image to describe its layout",
-      "analyze",
-      0.7,
-      EMPTY_PROJECT,
-    );
-    expect(gaps.find((g) => g.dimension === "scope")).toBeUndefined();
-    // analyze autofills outcome, so with scope suppressed there are zero gaps →
-    // no interview, no acceptance card.
-    expect(gaps).toHaveLength(0);
-  });
-
-  it("STILL detects a scope gap for a code task that mentions an ambiguous non-image word", () => {
-    // Narrowness guard: image-scope suppression must not swallow real codebase
-    // tasks. "add a logo to the header" carries no concrete image signal (no
-    // file extension / screenshot / photo), so the scope askcard stays.
-    const gaps = detectClarityGaps("add a logo to the header", "generate", 0.7, EMPTY_PROJECT);
-    expect(gaps.find((g) => g.dimension === "scope")).toBeDefined();
-  });
-
-  it("does NOT detect a scope gap for a web-search / external-info prompt", () => {
-    // Live drive (tavily probe, session d7a45a2dba30): "search the web for the
-    // latest vitest release notes" classified taskType=analyze fired the
-    // codebase-scope askcard and recorded a wrong scope ("src/mcp"). A
-    // web-search task is scoped to the web, not the codebase — symmetric to the
-    // image-scope and operational-scope guards.
-    const gaps = detectClarityGaps("search the web for the latest vitest release notes", "analyze", 0.7, EMPTY_PROJECT);
-    expect(gaps.find((g) => g.dimension === "scope")).toBeUndefined();
-    expect(gaps).toHaveLength(0);
-  });
-
-  it("does NOT detect a scope gap for a self-contained computation prompt (data is inline)", () => {
-    // Live drive (deepseek-vs-grok A/B, session 17fc23f0): "Compute f([3,1,2])
-    // where f sorts the list ascending then returns the sum of the first two
-    // elements." classified taskType=analyze (regex:read matched the bare word
-    // "list", conf 0.80 → skipped the brain) fired BOTH the pil-interview scope
-    // askcard ("Which part of the codebase should this target?" → auto "Entire
-    // project") AND the pil-acceptance card. The operand [3,1,2] is supplied
-    // inline — the task has no codebase dimension to scope. Symmetric to the
-    // image / web / operational scope guards.
-    const gaps = detectClarityGaps(
-      "Compute f([3,1,2]) where f sorts the list ascending then returns the sum of the first two elements.",
-      "analyze",
-      0.8,
-      EMPTY_PROJECT,
-    );
-    expect(gaps.find((g) => g.dimension === "scope")).toBeUndefined();
-    // analyze autofills outcome, so with scope suppressed there are zero gaps →
-    // no interview, no acceptance card.
-    expect(gaps).toHaveLength(0);
-  });
-
-  it("STILL detects a scope gap for a code task that embeds a literal but no compute framing", () => {
-    // Narrowness guard: the inline-literal suppression must not swallow real
-    // codebase tasks. "set the default retry delays to [100, 200, 400] in the
-    // config" carries a literal but is scoped to the codebase (no compute verb),
-    // so the scope askcard stays.
-    const gaps = detectClarityGaps(
-      "set the default retry delays to [100, 200, 400] in the config",
-      "generate",
-      0.7,
-      EMPTY_PROJECT,
-    );
-    expect(gaps.find((g) => g.dimension === "scope")).toBeDefined();
-  });
-});
-
-describe("buildInterviewQuestion()", () => {
-  it("builds a CouncilQuestionData with pil-interview phase", () => {
-    const gap = {
-      dimension: "outcome" as const,
-      description: "no outcome",
-      suggestedQuestion: "What outcome?",
-      options: ["test passes", "no error"],
-      defaultIndex: 0,
-    };
-    const q = buildInterviewQuestion(gap, "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);
-  });
-});
-
-describe("resolveGapsNonInteractive()", () => {
-  it("fills gaps with best-effort from project context", () => {
-    const gaps = detectClarityGaps("fix auth", "debug", 0.7, EMPTY_PROJECT);
-    const resolved = resolveGapsNonInteractive(gaps, EMPTY_PROJECT, "fix auth");
-    expect(resolved.outcome).toBeTruthy();
-    expect(resolved.scope.length).toBeGreaterThan(0);
-  });
-});

package/src/pil/__tests__/layer17-feasibility.test.ts

@@ -1,42 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-vi.mock("../../ee/bridge.js", () => ({
-  searchByText: vi.fn().mockResolvedValue([]),
-}));
-
-import type { ClarifiedIntent, ProjectContext } from "../discovery-types.js";
-import { checkFeasibility } from "../layer17-feasibility.js";
-
-const PROJECT: ProjectContext = {
-  language: "typescript",
-  framework: null,
-  packageManager: null,
-  domain: null,
-  boundedContexts: [{ path: "src/auth/", name: "auth", entryFiles: ["src/auth/index.ts"], exportedSymbols: [] }],
-  eePatterns: [],
-  relevantModules: [],
-  scannedAt: Date.now(),
-  cwd: "/proj",
-};
-
-describe("checkFeasibility()", () => {
-  it("returns no warnings when scope files exist", async () => {
-    const intent: ClarifiedIntent = { outcome: "done", scope: ["src/auth/"], constraints: [], gaps: [] };
-    const result = await checkFeasibility(intent, PROJECT, () => true);
-    expect(result.viable).toBe(true);
-    expect(result.warnings).toHaveLength(0);
-  });
-
-  it("returns warning when scope file does not exist", async () => {
-    const intent: ClarifiedIntent = { outcome: "done", scope: ["src/billing/pay.ts"], constraints: [], gaps: [] };
-    const result = await checkFeasibility(intent, PROJECT, () => false);
-    expect(result.warnings.length).toBeGreaterThan(0);
-    expect(result.warnings[0]).toContain("src/billing/pay.ts");
-  });
-
-  it("still returns viable=true even with warnings", async () => {
-    const intent: ClarifiedIntent = { outcome: "done", scope: ["missing.ts"], constraints: [], gaps: [] };
-    const result = await checkFeasibility(intent, PROJECT, () => false);
-    expect(result.viable).toBe(true);
-  });
-});