muonroi-cli 1.3.4 → 1.4.1

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

@@ -0,0 +1,129 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { CHEAP_MODEL_CONVERGENCE, getCheapModelWorkbook, injectCheapModelWorkbook, shouldInjectCheapModelWorkbook, subagentTaskType, } from "./cheap-model-workbooks.js";
+const base = { id: "x", name: "x", description: "", provider: "x", contextWindow: 100_000 };
+const info = (tier) => ({ ...base, tier });
+describe("shouldInjectCheapModelWorkbook", () => {
+    let saved;
+    beforeEach(() => {
+        saved = process.env.MUONROI_DISABLE_CHEAP_MODEL_WORKBOOK;
+        delete process.env.MUONROI_DISABLE_CHEAP_MODEL_WORKBOOK;
+    });
+    afterEach(() => {
+        if (saved === undefined)
+            delete process.env.MUONROI_DISABLE_CHEAP_MODEL_WORKBOOK;
+        else
+            process.env.MUONROI_DISABLE_CHEAP_MODEL_WORKBOOK = saved;
+    });
+    it("fires on fast tier only", () => {
+        expect(shouldInjectCheapModelWorkbook(info("fast"))).toBe(true);
+        expect(shouldInjectCheapModelWorkbook(info("balanced"))).toBe(false);
+        expect(shouldInjectCheapModelWorkbook(info("premium"))).toBe(false);
+        expect(shouldInjectCheapModelWorkbook(undefined)).toBe(false);
+    });
+    it("env override disables it", () => {
+        process.env.MUONROI_DISABLE_CHEAP_MODEL_WORKBOOK = "1";
+        expect(shouldInjectCheapModelWorkbook(info("fast"))).toBe(false);
+    });
+});
+describe("getCheapModelWorkbook", () => {
+    it("always includes the convergence (anti-ramble) block", () => {
+        expect(getCheapModelWorkbook("debug")).toContain(CHEAP_MODEL_CONVERGENCE);
+        expect(getCheapModelWorkbook(null)).toContain(CHEAP_MODEL_CONVERGENCE);
+    });
+    it("specialises per task type", () => {
+        expect(getCheapModelWorkbook("debug")).toMatch(/read the ACTUAL error|smallest root cause/i);
+        expect(getCheapModelWorkbook("debug")).toContain("continue-on-error");
+        expect(getCheapModelWorkbook("generate")).toMatch(/GENERATE/);
+        expect(getCheapModelWorkbook("refactor")).toMatch(/only what was named/i);
+        expect(getCheapModelWorkbook("analyze")).toMatch(/do not read the whole codebase/i);
+    });
+    it("analyze addendum steers code inspection over doc-skimming", () => {
+        // Live (gemini-flash Task A, 2026-06-04): a repo eval based mostly on
+        // AGENTS.md/CLAUDE.md docs, with little code inspection → shallow findings.
+        expect(getCheapModelWorkbook("analyze")).toMatch(/actual code|inspect the code|not just (the )?docs/i);
+    });
+    it("falls back to convergence-only for an unlisted task type", () => {
+        const general = getCheapModelWorkbook("general");
+        expect(general).toContain(CHEAP_MODEL_CONVERGENCE);
+        // no per-type addendum line for "general"
+        expect(general).not.toMatch(/DEBUG:|GENERATE:|REFACTOR:|ANALYZE:/);
+    });
+    it("emphasises minimising tool calls (the cost lever)", () => {
+        expect(CHEAP_MODEL_CONVERGENCE).toMatch(/FEWEST|minimise tool calls/i);
+        expect(CHEAP_MODEL_CONVERGENCE).toMatch(/STOP investigating/i);
+    });
+    it("steers a crisp completion line — finish the action, don't stop mid-step (A4)", () => {
+        // Live obs (workbook run 3308b3d02e11): the model's FINAL message was a
+        // mid-action narration ("I'm verifying the final workflow content now…")
+        // instead of stating completion. Steer it to finish, then state done.
+        expect(CHEAP_MODEL_CONVERGENCE).toMatch(/finish the action|don't stop mid|do not stop mid/i);
+        expect(CHEAP_MODEL_CONVERGENCE).toMatch(/one line|1 line|state.*(done|complet)/i);
+    });
+    it("stays compact (under 1300 chars) to preserve attention budget", () => {
+        // Bumped 900 → 1000 when the A4 completion-line rule was added; 1000 → 1300
+        // when the universal grounding (anti-hallucination) rule was added,
+        // and 1300 -> 1600 when anti-mù compaction recovery was added.
+        expect(getCheapModelWorkbook("debug").length).toBeLessThan(1600);
+    });
+});
+describe("grounding (anti-hallucination) directive", () => {
+    // Live obs (deepseek-v4-flash repo-eval, session 17fc23f0): the model
+    // fabricated a test count (claimed 67, actual ~479), invented a "model
+    // display bug" with fake file:line refs, and falsely claimed the finding
+    // was "already documented this session". That eval classified taskType=null
+    // on deepseek, so it received the convergence-ONLY block — which is why the
+    // grounding rule must live in the UNIVERSAL convergence block, not the
+    // per-type analyze addendum (or it would miss the exact observed case).
+    it("convergence block carries a grounding rule", () => {
+        expect(CHEAP_MODEL_CONVERGENCE).toMatch(/GROUND every claim/i);
+        expect(CHEAP_MODEL_CONVERGENCE).toMatch(/never invent/i);
+        expect(CHEAP_MODEL_CONVERGENCE).toMatch(/unverified/i);
+    });
+    it("applies even when taskType is null (the deepseek null-classified eval case)", () => {
+        expect(getCheapModelWorkbook(null)).toMatch(/GROUND every claim/i);
+        expect(getCheapModelWorkbook(null)).toMatch(/never invent/i);
+    });
+    it("applies to analyze/eval tasks too (inherited from convergence)", () => {
+        expect(getCheapModelWorkbook("analyze")).toMatch(/GROUND every claim/i);
+    });
+});
+describe("subagentTaskType", () => {
+    // Sub-agents have no PIL classifier run of their own; their role IS their
+    // task type. The Explore agent is read-only research → analyze; the verify
+    // family runs tests/diagnoses failures → debug. Everything else (general,
+    // vision, computer, custom) gets the convergence-only block (null).
+    it("maps explore → analyze", () => {
+        expect(subagentTaskType("explore")).toBe("analyze");
+    });
+    it("maps the verify family → debug", () => {
+        expect(subagentTaskType("verify")).toBe("debug");
+        expect(subagentTaskType("verify-detect")).toBe("debug");
+        expect(subagentTaskType("verify-manifest")).toBe("debug");
+    });
+    it("returns null (convergence-only) for general/vision/computer", () => {
+        expect(subagentTaskType("general")).toBeNull();
+        expect(subagentTaskType("vision")).toBeNull();
+        expect(subagentTaskType("computer")).toBeNull();
+    });
+    it("returns null for an unknown/custom sub-agent name", () => {
+        expect(subagentTaskType("my-custom-agent")).toBeNull();
+        expect(subagentTaskType("")).toBeNull();
+    });
+    it("feeds the workbook builder — explore yields the ANALYZE addendum", () => {
+        const wb = getCheapModelWorkbook(subagentTaskType("explore"));
+        expect(wb).toMatch(/do not read the whole codebase/i);
+    });
+});
+describe("injectCheapModelWorkbook", () => {
+    it("prepends the workbook to the system prompt", () => {
+        const out = injectCheapModelWorkbook("You are an agent.", "debug");
+        expect(out.startsWith(getCheapModelWorkbook("debug"))).toBe(true);
+        expect(out.endsWith("You are an agent.")).toBe(true);
+    });
+    it("is idempotent for the same task type", () => {
+        const once = injectCheapModelWorkbook("Sys.", "debug");
+        const twice = injectCheapModelWorkbook(once, "debug");
+        expect(twice).toBe(once);
+    });
+});
+//# sourceMappingURL=cheap-model-workbooks.test.js.map

package/dist/src/pil/clarity-gate.d.ts

@@ -0,0 +1,22 @@
+import type { TaskType } from "./types.js";
+export interface L1Signal {
+    confidence: number;
+    taskType: TaskType | null;
+    complexity: "low" | "medium" | "high";
+}
+export declare function isDirectImperative(raw: string): boolean;
+export declare function canInferOutcome(taskType: TaskType | null, raw: string): boolean;
+/**
+ * PIL-L6 fix — operational-domain scope (CI, deploy, build, lint) implies
+ * scope is the project's pipeline/infra, not a specific file. "fix ci fail"
+ * doesn't have a file path but the scope is unambiguous: it's the .github/
+ * workflows + whatever those workflows run. Treat as scoped for auto-pass.
+ */
+export declare function hasOperationalScope(raw: string): boolean;
+export declare function countFileReferences(raw: string): number;
+export declare function hasExplicitScope(raw: string): boolean;
+export declare function hasImageScope(raw: string): boolean;
+export declare function hasExternalInfoScope(raw: string): boolean;
+export declare function hasWholeRepoScope(raw: string): boolean;
+export declare function hasSelfContainedComputationScope(raw: string): boolean;
+export declare function shouldAutoPass(l1: L1Signal, raw: string): boolean;

package/dist/src/pil/clarity-gate.js

@@ -0,0 +1,162 @@
+import { getAutoPassThreshold } from "./config.js";
+/**
+ * A direct imperative command — "run the tests", "echo ok", "show the config",
+ * "list the ports" — has a self-evident outcome (the command executes / the
+ * thing is shown), so it should NOT trigger an outcome-clarification askcard.
+ * Requires an executable verb at the very start followed by a concrete object
+ * (a bare "run" with no object stays ambiguous → false).
+ */
+const DIRECT_IMPERATIVE_RE = /^\s*(run|execute|show|list|print|echo)\b\s+\S/i;
+export function isDirectImperative(raw) {
+    return DIRECT_IMPERATIVE_RE.test(raw);
+}
+export function canInferOutcome(taskType, raw) {
+    if (!taskType)
+        return false;
+    // PIL clarity over-trigger fix: a "general" prompt normally can't infer its
+    // outcome, but a direct imperative command is the exception — its outcome is
+    // obvious, so asking "what's the expected outcome?" is pure noise.
+    if (taskType === "general")
+        return isDirectImperative(raw);
+    const hasErrorRef = /error|exception|stack|TypeError|Cannot|failed|crash|fail(?:s|ed|ing)?|broken|red/i.test(raw);
+    const hasFileLineRef = /\.\w+:\d+/.test(raw);
+    const hasTargetState = /should|must|expect|return|produce|output|become/i.test(raw);
+    const hasAddPattern = /\b(add|create|implement|write|generate)\b.*\b(to|in|for|into)\b/i.test(raw);
+    // PIL-L6 fix — explicit goal phrase in the prompt is itself an outcome
+    // ("goal sẽ là ci green", "want: tests passing", "expect: 0 errors").
+    // Without this, debug prompts that name the desired end-state still
+    // tripped the interview because none of the verb-noun patterns matched.
+    const hasExplicitGoal = /\b(goal|target|expect|want|mong muốn|mong muon|kết quả|ket qua)\b[:\s]/i.test(raw);
+    return hasErrorRef || hasFileLineRef || hasTargetState || hasAddPattern || hasExplicitGoal;
+}
+/**
+ * PIL-L6 fix — operational-domain scope (CI, deploy, build, lint) implies
+ * scope is the project's pipeline/infra, not a specific file. "fix ci fail"
+ * doesn't have a file path but the scope is unambiguous: it's the .github/
+ * workflows + whatever those workflows run. Treat as scoped for auto-pass.
+ */
+export function hasOperationalScope(raw) {
+    return /\b(ci|cd|build|deploy(?:ment)?|action(?:s)?|workflow|pipeline|lint|tests?|coverage|gh\s+(check|run|workflow))\b/i.test(raw);
+}
+export function countFileReferences(raw) {
+    return (raw.match(/[\w-]+\.\w{1,5}/g) ?? []).filter((m) => /\.(ts|tsx|js|jsx|py|rs|go|java|cs|rb|vue|svelte|css|scss|json|yaml|yml|toml|md)$/i.test(m)).length;
+}
+export function hasExplicitScope(raw) {
+    return /\b(src\/|lib\/|app\/|pages\/|components\/|modules\/|packages\/)\S+/.test(raw);
+}
+/**
+ * An image-analysis prompt is scoped to the IMAGE, not the codebase. "analyze
+ * diagram.png", "take a screenshot and describe it" name their target directly,
+ * so the "Which part of the codebase should this target?" askcard is
+ * nonsensical for them — exactly like operational (CI/build) prompts are scoped
+ * to the pipeline (see hasOperationalScope). Detect a concrete image signal: an
+ * image file extension, a data:image URI, or an unambiguous image noun.
+ *
+ * Deliberately NARROW: a false positive here SUPPRESSES a legitimate clarifying
+ * question (quality risk), so overloaded words are excluded —
+ *   - "logo" / "icon" / "diagram" / "chart" / "mockup" appear in real codebase
+ *     tasks ("add a logo to the header"),
+ *   - bare "image" collides with container/Docker usage ("rebuild the image"),
+ *   - "picture" collides with the "bigger picture" idiom,
+ *   - Vietnamese substrings (ảnh/hình) collide with frequent non-image words
+ *     ("ảnh hưởng", "màn hình", "hình thức").
+ * Only a file extension, data:image URI, "screenshot", or "photo" qualify.
+ */
+const IMAGE_SCOPE_RE = /\.(png|jpe?g|gif|webp|svg|bmp|tiff?|heic|avif|ico)\b|data:image\/|\bscreen-?shots?\b|\bphotos?\b/i;
+export function hasImageScope(raw) {
+    return IMAGE_SCOPE_RE.test(raw);
+}
+/**
+ * A web-search / external-information prompt ("search the web for X", "google
+ * the error", a bare URL, "latest news on Y") is scoped to the WEB, not the
+ * codebase, so the "Which part of the codebase should this target?" askcard is
+ * nonsensical for it — symmetric to hasOperationalScope / hasImageScope. (Live:
+ * "search the web for the latest vitest release notes" → taskType=analyze fired
+ * the scope askcard and recorded a wrong scope of "src/mcp".)
+ *
+ * Deliberately NARROW — only UNAMBIGUOUSLY-external intent. It must not reuse
+ * the broad hasDocsSignal vocabulary (library/api/install/package), because
+ * those words routinely describe real codebase tasks ("add the zod library to
+ * the auth module") that genuinely need the scope askcard. In particular a bare
+ * "search" is excluded so "search the codebase" / "implement the search
+ * feature" still get scoped.
+ */
+const EXTERNAL_INFO_SCOPE_RE = /https?:\/\/\S+|\bsearch\s+(the\s+)?(web|internet|online)\b|\bweb\s*search\b|\bon\s+the\s+(web|internet)\b|\bgoogle\b|\b(news|weather|headlines)\b/i;
+export function hasExternalInfoScope(raw) {
+    return EXTERNAL_INFO_SCOPE_RE.test(raw);
+}
+/**
+ * A whole-repo / whole-project prompt ("đánh giá repo này", "review the entire
+ * codebase", "audit the whole project") is ALREADY scoped — to everything — so
+ * the "Which part of the codebase should this target?" askcard is nonsensical
+ * (and worse, it recommends a single bounded context like "src/cli" as the
+ * default, which is wrong for a repo-wide eval). Symmetric to the other scope
+ * predicates. Live: gemini-2.5-flash classified "đánh giá repo …" as analyze and
+ * got the scope askcard whose recommended option was a narrow subdir.
+ *
+ * Deliberately NARROW — it must NOT fire on a narrow task that merely mentions a
+ * repo/project ("add X to this repo", "fix the bug in the project"), or those
+ * would wrongly skip a legitimate scope question. So it requires EITHER an
+ * explicit wholeness qualifier (whole/entire/all/toàn bộ/cả) on a repo/project/
+ * codebase noun, OR an evaluation/overview verb (review/audit/evaluate/assess/
+ * analyze/overview · đánh giá/phân tích/tổng quan/kiểm tra) applied to that noun.
+ */
+const WHOLE_REPO_SCOPE_RE = 
+// NOTE: leading anchors on Vietnamese-initial alternatives use (?:^|\s) not
+// \b — JS \b is ASCII-only and never matches before a non-ASCII letter like
+// "đ", so "\bđánh" would silently fail to match "đánh giá repo".
+/\b(whole|entire|overall|all\s+of\s+the|across\s+the)\s+(repo(?:sitory)?|code-?base|project)\b|(?:^|\s)(toàn\s*bộ|toan\s*bo|cả|ca)\s+(repo|dự\s*án|du\s*an|m[ãa]\s*ngu[ồo]n|code-?base|project)\b|\b(review|audit|evaluate|assess|analy[sz]e|summari[sz]e|overview\s+of|summary\s+of)\s+(?:\S+\s+){0,2}?(repo(?:sitory)?|code-?base|project)\b|(?:^|\s)(đánh\s*giá|danh\s*gia|phân\s*tích|phan\s*tich|tổng\s*quan|tong\s*quan|kiểm\s*tra|kiem\s*tra|tóm\s*tắt|tom\s*tat)\s+(?:\S+\s+){0,2}?(toàn|toan|repo|dự\s*án|du\s*an|m[ãa]\s*ngu[ồo]n|code-?base|project)\b/i;
+export function hasWholeRepoScope(raw) {
+    return WHOLE_REPO_SCOPE_RE.test(raw);
+}
+/**
+ * A self-contained computation / reasoning prompt supplies its operand data
+ * INLINE ("Compute f([3,1,2]) …", "what is the median of [10, 4, 7]?") — the
+ * task's target is the data in the prompt, not the codebase, so the "Which part
+ * of the codebase should this target?" askcard is nonsensical for it. Symmetric
+ * to hasOperationalScope / hasImageScope / hasExternalInfoScope / hasWholeRepoScope.
+ *
+ * Live: "Compute f([3,1,2]) where f sorts the list ascending then returns the
+ * sum of the first two elements." classified taskType=analyze — the regex
+ * classifier matched the bare word "list" (regex:read, conf 0.80, which also
+ * skips the brain) — and fired BOTH the pil-interview scope askcard (auto
+ * "Entire project") and the pil-acceptance card on a pure math problem.
+ *
+ * Deliberately NARROW — a false positive here SUPPRESSES a legitimate scope
+ * question (quality risk), so it requires BOTH:
+ *   1. an inline DATA literal — a bracketed comma-list of >=2 numeric or quoted
+ *      string values (`[3, 1, 2]`, `["a", "b"]`). A bracketed list of bare
+ *      identifiers (`[auth.ts, session.ts]`) is NOT data — those are file/symbol
+ *      references and stay codebase-scoped; the regex only accepts numbers and
+ *      quoted strings, so it never matches them. Single-element `[0]` (array
+ *      indexing) is excluded by the >=2-element requirement.
+ *   2. computation framing — a compute/evaluate/sort/sum/statistic verb or a
+ *      "what is …" / "given the array …" question frame.
+ * The AND keeps real codebase tasks that merely embed a literal (e.g. "set the
+ * default retry delays to [100, 200, 400] in the config") correctly scoped.
+ */
+const INLINE_DATA_LITERAL_RE = /\[\s*(?:-?\d+(?:\.\d+)?|"[^"]*"|'[^']*')(?:\s*,\s*(?:-?\d+(?:\.\d+)?|"[^"]*"|'[^']*'))+\s*\]/;
+const COMPUTE_FRAMING_RE = /\b(comput(?:e|ing)|calculat(?:e|ing|ion)|evaluat(?:e|ing)|solve|sort(?:s|ed|ing)?|sum|median|mean|average|max(?:imum)?|min(?:imum)?|largest|smallest|reverse[ds]?|result\s+of|what(?:'?s|\s+is|\s+are)|given\s+(?:the\s+)?(?:array|list|sequence|set|matrix|string|numbers?))\b/i;
+export function hasSelfContainedComputationScope(raw) {
+    return INLINE_DATA_LITERAL_RE.test(raw) && COMPUTE_FRAMING_RE.test(raw);
+}
+export function shouldAutoPass(l1, raw) {
+    if (l1.confidence < getAutoPassThreshold())
+        return false;
+    if (!canInferOutcome(l1.taskType, raw))
+        return false;
+    // PIL-L6 fix — debug prompts about CI/build/deploy don't need a file path
+    // because their scope is the pipeline itself. Operational scope counts.
+    if (countFileReferences(raw) === 0 &&
+        !hasExplicitScope(raw) &&
+        !hasOperationalScope(raw) &&
+        !hasImageScope(raw) &&
+        !hasExternalInfoScope(raw) &&
+        !hasWholeRepoScope(raw) &&
+        !hasSelfContainedComputationScope(raw))
+        return false;
+    if (l1.complexity === "high")
+        return false;
+    return true;
+}
+//# sourceMappingURL=clarity-gate.js.map

package/dist/src/pil/config.d.ts

@@ -5,3 +5,6 @@
  *   Default OFF during rollout; flip to ON after dual-run validation.
  */
 export declare function isUnifiedPilEnabled(): boolean;
+export declare function isDiscoveryEnabled(): boolean;
+export declare function getAutoPassThreshold(): number;
+export declare function getMaxInterviewQuestions(): number;

package/dist/src/pil/config.js

@@ -11,4 +11,15 @@ export function isUnifiedPilEnabled() {
         return true;
     return false;
 }
+export function isDiscoveryEnabled() {
+    return process.env.MUONROI_PIL_DISCOVERY !== "0";
+}
+export function getAutoPassThreshold() {
+    const v = Number(process.env.MUONROI_PIL_AUTOPASS_THRESHOLD);
+    return Number.isFinite(v) && v >= 0.5 && v <= 1.0 ? v : 0.85;
+}
+export function getMaxInterviewQuestions() {
+    const v = Number(process.env.MUONROI_PIL_MAX_QUESTIONS);
+    return Number.isFinite(v) && v >= 1 && v <= 5 ? v : 3;
+}
 //# sourceMappingURL=config.js.map

package/dist/src/pil/discovery-cache.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectContext } from "./discovery-types.js";
+export declare function getCachedProjectContext(cwd: string): ProjectContext | null;
+export declare function setCachedProjectContext(ctx: ProjectContext): void;
+export declare function clearDiscoveryCache(): void;

package/dist/src/pil/discovery-cache.js

@@ -0,0 +1,18 @@
+const CACHE_TTL_MS = 5 * 60_000;
+let _cached = null;
+export function getCachedProjectContext(cwd) {
+    if (!_cached)
+        return null;
+    if (_cached.cwd !== cwd)
+        return null;
+    if (Date.now() - _cached.scannedAt > CACHE_TTL_MS)
+        return null;
+    return _cached;
+}
+export function setCachedProjectContext(ctx) {
+    _cached = ctx;
+}
+export function clearDiscoveryCache() {
+    _cached = null;
+}
+//# sourceMappingURL=discovery-cache.js.map

package/dist/src/pil/discovery-types.d.ts

@@ -0,0 +1,94 @@
+import type { CouncilQuestionData } from "../types/index.js";
+import type { CouncilQuestionAnswer } from "../ui/components/council-question-card.js";
+import type { OutputStyle, TaskType } from "./types.js";
+export interface ProjectContext {
+    language: string | null;
+    framework: string | null;
+    packageManager: string | null;
+    domain: string | null;
+    boundedContexts: BoundedContext[];
+    eePatterns: string[];
+    relevantModules: RelevantModule[];
+    scannedAt: number;
+    cwd: string;
+}
+export interface BoundedContext {
+    path: string;
+    name: string;
+    entryFiles: string[];
+    exportedSymbols: string[];
+}
+export interface RelevantModule {
+    path: string;
+    relevance: string;
+    exists: boolean;
+}
+export type ClarityDimension = "outcome" | "scope" | "constraint";
+export interface ClarityGap {
+    dimension: ClarityDimension;
+    description: string;
+    suggestedQuestion: string;
+    options: string[];
+    defaultIndex: number;
+}
+export interface ClarifiedIntent {
+    intentStatement?: string;
+    outcome: string;
+    scope: string[];
+    feasibilityWarnings?: string[];
+    interviewed?: boolean;
+    accepted?: boolean;
+    constraints?: string[];
+    gaps?: Array<{
+        dimension: string;
+        answer: string | null;
+        options: string[];
+        defaultIndex: number;
+    }>;
+    modelClarifications?: Array<{
+        question: string;
+        answer: string;
+    }>;
+}
+export type ModelClarificationProposer = (input: {
+    raw: string;
+    l1: {
+        taskType: TaskType | null;
+        confidence: number;
+        complexity?: "low" | "medium" | "high";
+        domain?: string | null;
+    };
+    additionalContext?: string;
+}) => Promise<string[]>;
+export interface FeasibilityResult {
+    viable: boolean;
+    warnings: string[];
+    adjustedScope: string[];
+}
+export interface DiscoveryResult {
+    raw: string;
+    projectContext: ProjectContext;
+    clarifiedIntent: ClarifiedIntent;
+    feasibility: FeasibilityResult;
+    interviewed: boolean;
+    intentStatement: string;
+    outcome: string;
+    scope: string[];
+    feasibilityWarnings: string[];
+    accepted: boolean;
+    taskType: TaskType | null;
+    confidence: number;
+    domain: string | null;
+    outputStyle: OutputStyle | null;
+    discoveryMs: number;
+}
+export interface AcceptanceCardData {
+    intentStatement: string;
+    outcome: string;
+    scope: string[];
+    warnings: string[];
+}
+export interface DiscoveryInteractionHandler {
+    askQuestion(question: CouncilQuestionData): Promise<CouncilQuestionAnswer>;
+    showAcceptance(card: AcceptanceCardData): Promise<"accept" | "adjust" | "cancel">;
+}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=discovery-types.js.map

package/dist/src/pil/discovery.d.ts

@@ -0,0 +1,18 @@
+import type { DiscoveryInteractionHandler, DiscoveryResult, ModelClarificationProposer } from "./discovery-types.js";
+import type { OutputStyle, TaskType } from "./types.js";
+export interface L1Result {
+    taskType: TaskType | null;
+    confidence: number;
+    complexity: "low" | "medium" | "high";
+    domain: string | null;
+    outputStyle: OutputStyle | null;
+    intentKind: "task" | "chitchat" | null;
+}
+export declare function runDiscovery(raw: string, l1: L1Result, cwd: string, handler: DiscoveryInteractionHandler | null, sessionId?: string | null, clarificationProposer?: ModelClarificationProposer | null, recentTurnsSummary?: string | null): Promise<DiscoveryResult>;
+/**
+ * Create a ModelClarificationProposer backed by the actual task model.
+ * The model receives the user raw + CLI enrichment (l1, project modules, etc.)
+ * and outputs the specific questions *it* needs the user to answer.
+ * This is the effective way to let the model interview based on what is still missing.
+ */
+export declare function createModelClarificationProposer(providerFactory: any, modelId: string): ModelClarificationProposer;