muonroi-cli 1.4.1 → 1.5.0

package/dist/src/pil/discovery.js

@@ -1,13 +1,13 @@
 import { randomUUID } from "node:crypto";
-import { shouldAutoPass } from "./clarity-gate.js";
+import { detectNoClarifySignal } from "./clarity-gate.js";
 import { getMaxInterviewQuestions, isDiscoveryEnabled } from "./config.js";
 import { getCachedProjectContext, setCachedProjectContext } from "./discovery-cache.js";
 import { isMetaAnalysisPrompt } from "./layer6-output.js";
 import { scanProjectContext } from "./layer15-context-scan.js";
-import { buildInterviewQuestion, detectClarityGaps, getAutofilledOutcome, resolveGapsNonInteractive, } from "./layer16-clarity.js";
+import { buildInterviewQuestion, getAutofilledOutcome, isProvideOwnDetailsSentinel, PROVIDE_OWN_DETAILS_OPTION_EN, resolveGapsNonInteractive, } from "./layer16-clarity.js";
 import { checkFeasibility } from "./layer17-feasibility.js";
 import { buildAcceptanceCard, buildAcceptanceQuestion } from "./layer18-acceptance.js";
-import { getSessionState, isLikelyFollowUp, markDiscoveryAccepted } from "./session-state.js";
+import { markDiscoveryAccepted } from "./session-state.js";
 function emptyProjectContext(cwd) {
     return {
         language: null,
@@ -44,21 +44,36 @@ export async function runDiscovery(raw, l1, cwd, handler, sessionId = null, clar
         return baseResult();
     if (l1.intentKind === "chitchat" || l1.taskType === null)
         return baseResult();
-    // Session-continuation guard: when the user is on turn >= 2 of an ongoing
-    // session AND the new prompt looks like a continuation (short, modal verb
-    // or context pronoun), skip the interview entirely. The prior turn already
-    // established context; asking "Which part of the codebase?" on "Can you
-    // fix it?" forces the user to re-type their intent as a freetext answer,
-    // which PIL then mis-routes through gap-resolution + acceptance, producing
-    // duplicate askcards (evidence: session 1f29e238a816 timeline).
-    const sessionState = getSessionState(sessionId);
-    if (sessionState && sessionState.turnCount > 1 && isLikelyFollowUp(raw)) {
+    // The user explicitly told the agent not to clarify ("don't ask" / "trả lời
+    // thẳng"). This is the USER's consent decision, not a classification heuristic,
+    // so it stays: skip the entire interview + acceptance ceremony.
+    if (detectNoClarifySignal(raw))
         return baseResult();
-    }
-    const l1Signal = { confidence: l1.confidence, taskType: l1.taskType, complexity: l1.complexity };
-    if (shouldAutoPass(l1Signal, raw))
+    // ── Model-driven clarification gate (Phase 2) ──────────────────────────────
+    // The configured chat model — NOT a regex/keyword heuristic — is the sole
+    // decider of whether this turn has a genuine gray area, what to ask, which
+    // options to offer, why, and which option is recommended (user directive
+    // 2026-06-16: "các askcard bắt buộc xuất phát từ model muốn hỏi"). The CLI only
+    // injects the proposer prompt to open the path.
+    //
+    // There is deliberately NO regex fallback. The old path ran shouldAutoPass() +
+    // detectClarityGaps() keyword heuristics and fabricated questions/outcomes from
+    // them — the exact "phân loại task qua regex từ khoá ... bad bad bad UX, miss
+    // hàng tỷ case" behaviour this phase removes (it also fabricated a build outcome
+    // for a yes/no question — live repro f6f7881a5fae). If the model cannot propose
+    // questions (no proposer wired, or it throws), we log loudly and proceed WITHOUT
+    // an interview; we never invent a question from keywords ("không bao giờ hardcode
+    // fallback... có vấn đề = fail = ghi logs"). The agent can still clarify inline.
+    if (!clarificationProposer) {
+        // Interactive turns always wire a proposer (orchestrator/message-processor).
+        // A missing one there is a wiring bug — surface it, never paper over with regex.
+        if (handler) {
+            console.error("[Agent:discovery] interactive turn has no model clarification proposer — skipping interview (no regex fallback by design)");
+        }
         return baseResult();
-    // L1.5: Context Discovery (cacheable)
+    }
+    // L1.5: Context Discovery (cacheable) — gives the model real project facts so
+    // it never asks for something it can inspect itself (language/framework/modules).
     let projectContext;
     const cached = getCachedProjectContext(cwd);
     if (cached) {
@@ -76,78 +91,23 @@ export async function runDiscovery(raw, l1, cwd, handler, sessionId = null, clar
             projectContext = emptyProjectContext(cwd);
         }
     }
-    // L1.6: Clarity Interview
-    let gaps = detectClarityGaps(raw, l1.taskType, l1.confidence, projectContext);
-    // Effective model-driven interview: if a clarificationProposer (the actual task model) is provided,
-    // let the *model* itself generate the questions based on the user request + CLI enrichment so far.
-    // The model decides what it still needs and is missing from the enrich suggestions.
-    // Always generate model gaps when proposer wired (even if no handler for non-interactive resolve).
-    // This ensures model BE recs drive [Discovery] Intent/Outcome/Scope for native meta prompts.
-    // Handler only decides whether to show interactive askcard.
-    if (clarificationProposer) {
-        try {
-            const additionalContext = [
-                projectContext.language ? `Language: ${projectContext.language}` : "",
-                projectContext.framework ? `Framework: ${projectContext.framework}` : "",
-                projectContext.packageManager ? `Package manager: ${projectContext.packageManager}` : "",
-                projectContext.relevantModules?.length
-                    ? `Relevant modules: ${projectContext.relevantModules.map((m) => m.path).join(", ")}`
-                    : "",
-                projectContext.boundedContexts?.length
-                    ? `Bounded contexts: ${projectContext.boundedContexts.map((b) => `${b.name} (${b.path})`).join(", ")}`
-                    : "",
-                projectContext.eePatterns?.length ? `EE patterns: ${projectContext.eePatterns.slice(0, 3).join(" | ")}` : "",
-                recentTurnsSummary ? `\nRecent Conversation History:\n${recentTurnsSummary}` : "",
-            ]
-                .filter(Boolean)
-                .join("\n");
-            const modelQuestions = await clarificationProposer({
-                raw,
-                l1: { taskType: l1.taskType, confidence: l1.confidence },
-                additionalContext: additionalContext || undefined,
-            });
-            if (modelQuestions.length > 0) {
-                gaps = modelQuestions.slice(0, 3).map((line, idx) => {
-                    let q = line;
-                    let recs = ["I will provide my own details / constraints"];
-                    const m = line.match(/\[MODEL RECS:?\s*(.+?)\]/i) || line.match(/RECS:\s*(.+)$/i);
-                    if (m) {
-                        recs = m[1]
-                            .split(/\s*\|\s*/)
-                            .map((r) => r.trim())
-                            .filter(Boolean)
-                            .slice(0, 3);
-                        q = line
-                            .replace(/\[MODEL RECS:?.*?\]/i, "")
-                            .replace(/RECS:.*$/, "")
-                            .trim();
-                    }
-                    return {
-                        dimension: "outcome",
-                        description: `Model-generated clarification #${idx + 1}`,
-                        suggestedQuestion: q || "What else needs clarification?",
-                        options: [...recs, "Other (type free answer)"],
-                        defaultIndex: 0,
-                    };
-                });
-            }
-        }
-        catch {
-            // fall through to static
-        }
+    // L1.6: Ask the MODEL what (if anything) it still needs. The model owns the
+    // gray-area decision, the questions, the options, the "why", and the
+    // recommended default. An empty result means it sees nothing worth asking →
+    // no interview, no fabricated [Discovery] outcome.
+    let gaps;
+    try {
+        gaps = await proposeModelGaps(clarificationProposer, raw, l1, projectContext, recentTurnsSummary);
     }
-    if (!clarificationProposer && (l1.taskType === "analyze" || l1.taskType === "debug") && gaps.length > 0) {
-        // Fallback open question (non-model path)
-        gaps = [
-            {
-                dimension: "outcome",
-                description: "Specific outcome and constraints the agent/model needs from the user",
-                suggestedQuestion: `Để tôi (agent/model) thực hiện chính xác và có được thông tin cần thiết cho task này, bạn hãy cho tôi biết: kết quả mong muốn cụ thể, các ràng buộc quan trọng, hoặc bất kỳ chi tiết nào khác mà tôi cần làm rõ trước khi bắt đầu?`,
-                options: ["Tôi sẽ trả lời tự do / cung cấp chi tiết cần thiết"],
-                defaultIndex: 0,
-            },
-        ];
+    catch (err) {
+        // No Silent Catch + fail-loud: log with context, then proceed WITHOUT an
+        // interview. We do NOT fall back to regex-generated questions.
+        console.error(`[Agent:discovery] model clarification proposer threw — proceeding without interview (no regex fallback): ${err?.message}`, { stack: err?.stack?.split("\n").slice(0, 3) });
+        return baseResult();
     }
+    // Model decided there is no gray area worth asking about → proceed directly.
+    if (gaps.length === 0)
+        return baseResult();
     let clarifiedIntent;
     let interviewed = false;
     if (gaps.length > 0 && handler) {
@@ -168,15 +128,15 @@ export async function runDiscovery(raw, l1, cwd, handler, sessionId = null, clar
     else {
         clarifiedIntent = resolveGapsNonInteractive(gaps, projectContext, raw);
     }
-    // Auto-fill outcome for analyze/plan/documentation when no outcome gap was asked
-    // Broaden to override bad generics (Local path, In prompts/..., project root literals) that
-    // can leak from detectClarityGaps/resolve when raw contains directory mentions or for native meta.
+    // Auto-fill outcome for analyze/plan/documentation when no outcome gap was asked.
+    // Override only when the resolved outcome is a raw-derived generic ("Complete: …" /
+    // "Complete the task …") or a genuine filesystem-path leak (Local path, project root,
+    // "src/foo.ts" scope-option shapes). It must NOT clobber a legitimate user answer that
+    // merely contains a slash ("support REST/GraphQL", "input/output") — see looksLikePathLeak.
     const autoOutcome = getAutofilledOutcome(l1.taskType, raw);
-    if (autoOutcome &&
-        (!clarifiedIntent.outcome ||
-            clarifiedIntent.outcome.startsWith("Complete the task") ||
-            /Local path|In prompts|directory as|project root|\/|absolute|local\/repo/i.test(clarifiedIntent.outcome) ||
-            clarifiedIntent.outcome.includes("/"))) {
+    const currentOutcome = clarifiedIntent.outcome ?? "";
+    const isGenericComplete = /^Complete(?::| the task)/i.test(currentOutcome);
+    if (autoOutcome && (!currentOutcome || isGenericComplete || looksLikePathLeak(currentOutcome))) {
         clarifiedIntent = { ...clarifiedIntent, outcome: autoOutcome };
     }
     // L1.7: Feasibility Check
@@ -197,33 +157,32 @@ export async function runDiscovery(raw, l1, cwd, handler, sessionId = null, clar
             accepted = false;
         }
         else if (decision === "adjust") {
-            // Re-run interview once — but ONLY for gaps where the user's prior
-            // freetext answer was empty, identical to the raw prompt itself, or
-            // a continuation phrase. Re-asking gaps the user already answered
-            // (with non-trivial text) just produces duplicate askcards (evidence:
-            // session 1f29e238a816 — user picked "adjust", re-interview fired the
-            // same "Which part of codebase?" question they had just answered).
-            const reGaps = detectClarityGaps(raw, l1.taskType, l1.confidence, projectContext);
-            const priorAnswers = new Map((clarifiedIntent.gaps ?? []).map((g) => [g.dimension, g.answer ?? null]));
-            const reAnswered = reGaps.map((g) => ({
-                ...g,
-                answer: priorAnswers.get(g.dimension) ?? null,
-            }));
-            const maxRe = Math.min(reGaps.length, getMaxInterviewQuestions());
-            for (let i = 0; i < maxRe; i++) {
-                const gap = reAnswered[i];
-                const prior = gap.answer?.trim() ?? "";
-                const isTrivialPriorAnswer = prior === "" || prior.toLowerCase() === raw.trim().toLowerCase() || isLikelyFollowUp(prior);
-                if (!isTrivialPriorAnswer) {
-                    // User already gave a substantive answer for this gap. Keep it.
-                    continue;
+            // The user asked to change something — let the MODEL re-propose questions
+            // given the same context (it owns the gray-area decision, exactly like the
+            // initial pass). On a proposer failure we keep the already-resolved intent
+            // rather than fabricate regex questions.
+            let reGaps = [];
+            try {
+                reGaps = await proposeModelGaps(clarificationProposer, raw, l1, projectContext, recentTurnsSummary);
+            }
+            catch (err) {
+                console.error(`[Agent:discovery] re-interview proposer threw — keeping prior intent: ${err?.message}`);
+            }
+            if (reGaps.length > 0) {
+                const reAnswered = reGaps.map((g) => ({
+                    ...g,
+                    answer: null,
+                }));
+                const maxRe = Math.min(reGaps.length, getMaxInterviewQuestions());
+                for (let i = 0; i < maxRe; i++) {
+                    const gap = reAnswered[i];
+                    const q = buildInterviewQuestion(gap, randomUUID());
+                    const ans = await handler.askQuestion(q);
+                    reAnswered[i] = { ...gap, answer: ans.text };
                 }
-                const q = buildInterviewQuestion(gap, randomUUID());
-                const ans = await handler.askQuestion(q);
-                reAnswered[i] = { ...gap, answer: ans.text };
+                clarifiedIntent = buildClarifiedIntentFromAnswers(reAnswered, raw, projectContext);
+                feasibility = await checkFeasibility(clarifiedIntent, projectContext).catch(() => feasibility);
             }
-            clarifiedIntent = buildClarifiedIntentFromAnswers(reAnswered, raw, projectContext);
-            feasibility = await checkFeasibility(clarifiedIntent, projectContext).catch(() => feasibility);
             accepted = true;
         }
     }
@@ -250,11 +209,39 @@ export async function runDiscovery(raw, l1, cwd, handler, sessionId = null, clar
         discoveryMs: Date.now() - start,
     };
 }
+/**
+ * True only for outcomes that are genuine filesystem-path leakage — known
+ * leaked-scope phrases ("Local path", "project root", …) or a real path segment
+ * ("src/foo.ts", a "src/cli (cli)" scope-option shape) that also carries a
+ * path-ish signal (file extension, path keyword, or trailing "(name)").
+ *
+ * A bare "/" is NOT sufficient: "support REST/GraphQL", "validate input/output",
+ * and "details / constraints" use the slash as an "or" separator and must be
+ * preserved. The previous implementation matched any "/" and silently clobbered
+ * such legitimate answers with the generic taskType default.
+ */
+function looksLikePathLeak(outcome) {
+    // Anchored known leaked-scope phrases (preserves prior override behaviour).
+    if (/(?:\b(?:local path|in prompts|directory as|project root|absolute)\b)|local\/repo/i.test(outcome)) {
+        return true;
+    }
+    // word/word path segment (no spaces around the slash) — e.g. "src/foo.ts".
+    if (!/\b[\w.-]+\/[\w./-]+/.test(outcome))
+        return false;
+    const hasFileExtension = /\/[\w-]+\.[a-z0-9]{1,5}\b/i.test(outcome); // ".../foo.ts"
+    const hasPathKeyword = /\b(?:path|dir|directory|folder|repo|root|module|src|lib|dist|tests?)\b/i.test(outcome);
+    const hasScopeOptionSuffix = /\([^)]+\)\s*$/.test(outcome); // "src/cli (cli)" scope-option shape
+    return hasFileExtension || hasPathKeyword || hasScopeOptionSuffix;
+}
 function buildClarifiedIntentFromAnswers(answeredGaps, raw, projectContext) {
     const outcomeGap = answeredGaps.find((g) => g.dimension === "outcome");
     const scopeGap = answeredGaps.find((g) => g.dimension === "scope");
     const constraintGap = answeredGaps.find((g) => g.dimension === "constraint");
-    const outcome = outcomeGap?.answer ?? `Complete: ${raw.slice(0, 80)}`;
+    // The "provide my own details" meta-option is a no-answer sentinel; treat it
+    // as missing so the raw-derived generic (and downstream inferred outcome) is
+    // used instead of the sentinel string surviving verbatim as the outcome.
+    const outcomeAnswer = isProvideOwnDetailsSentinel(outcomeGap?.answer) ? null : (outcomeGap?.answer ?? null);
+    const outcome = outcomeAnswer ?? `Complete: ${raw.slice(0, 80)}`;
     const scope = (() => {
         if (scopeGap?.answer)
             return [scopeGap.answer.replace(/\s*\(.*\)\s*$/, "").trim()];
@@ -279,6 +266,72 @@ function buildClarifiedIntentFromAnswers(answeredGaps, raw, projectContext) {
         })),
     };
 }
+/**
+ * Build the enrichment context the model sees, call the proposer, and map each
+ * returned line into a ClarityGap. This is the SINGLE place discovery turns a
+ * model response into askcard gaps — the model owns the question, the options
+ * (recommends), the recommended default (first option), and the "why" (threaded
+ * into the gap description → askcard context). No regex/keyword gap synthesis.
+ *
+ * Throws on proposer error so the caller can decide how to degrade (initial pass
+ * proceeds without interview; the "adjust" pass keeps the prior intent).
+ */
+async function proposeModelGaps(proposer, raw, l1, projectContext, recentTurnsSummary) {
+    const additionalContext = [
+        projectContext.language ? `Language: ${projectContext.language}` : "",
+        projectContext.framework ? `Framework: ${projectContext.framework}` : "",
+        projectContext.packageManager ? `Package manager: ${projectContext.packageManager}` : "",
+        projectContext.relevantModules?.length
+            ? `Relevant modules: ${projectContext.relevantModules.map((m) => m.path).join(", ")}`
+            : "",
+        projectContext.boundedContexts?.length
+            ? `Bounded contexts: ${projectContext.boundedContexts.map((b) => `${b.name} (${b.path})`).join(", ")}`
+            : "",
+        projectContext.eePatterns?.length ? `EE patterns: ${projectContext.eePatterns.slice(0, 3).join(" | ")}` : "",
+        recentTurnsSummary ? `\nRecent Conversation History:\n${recentTurnsSummary}` : "",
+    ]
+        .filter(Boolean)
+        .join("\n");
+    const modelQuestions = await proposer({
+        raw,
+        l1: { taskType: l1.taskType, confidence: l1.confidence },
+        additionalContext: additionalContext || undefined,
+    });
+    return modelQuestions.slice(0, 3).map(parseModelQuestionToGap);
+}
+/**
+ * Parse one proposer line ("question [MODEL RECS: a | b] [WHY: reason]") into a
+ * ClarityGap. The recommends become the askcard options (first = recommended
+ * default); the WHY clause becomes the askcard context so the user sees the
+ * model's own reason for asking.
+ */
+function parseModelQuestionToGap(line, idx) {
+    let recs = [PROVIDE_OWN_DETAILS_OPTION_EN];
+    const recMatch = line.match(/\[MODEL RECS:?\s*(.+?)\]/i) || line.match(/RECS:\s*(.+)$/i);
+    if (recMatch) {
+        const parsed = recMatch[1]
+            .split(/\s*\|\s*/)
+            .map((r) => r.trim())
+            .filter(Boolean)
+            .slice(0, 3);
+        if (parsed.length > 0)
+            recs = parsed;
+    }
+    const whyMatch = line.match(/\[WHY:\s*(.+?)\]/i);
+    const why = whyMatch ? whyMatch[1].trim() : "";
+    const question = line
+        .replace(/\[WHY:.*?\]/i, "")
+        .replace(/\[MODEL RECS:?.*?\]/i, "")
+        .replace(/RECS:.*$/, "")
+        .trim();
+    return {
+        dimension: "outcome",
+        description: why || `Model-generated clarification #${idx + 1}`,
+        suggestedQuestion: question || "What else needs clarification?",
+        options: [...recs, "Other (type free answer)"],
+        defaultIndex: 0,
+    };
+}
 /**
  * Create a ModelClarificationProposer backed by the actual task model.
  * The model receives the user raw + CLI enrichment (l1, project modules, etc.)
@@ -297,43 +350,65 @@ export function createModelClarificationProposer(providerFactory, modelId) {
             const special = isMetaAnalysisPrompt(input.raw)
                 ? `\nIf the request is a self-evaluation, meta-analysis or review of the CLI by the agent running inside it, do NOT ask about repo path, current directory, absolute path, local repo location or "which directory". Scope is always the full project root. Focus questions and recommends on which CLI internals (PIL, discovery, tools, compaction, EE, model BE, loop guard) to evaluate or specific improvements to assess after fixes. Use the enrichment context.`
                 : "";
+            // Environment/self header — the main system prompt has buildEnvironmentBlock,
+            // but THIS discovery question-generator is a separate LLM call that lacked it,
+            // so it assumed Python and asked the user to paste the directory tree despite
+            // running inside the repo (live grok session). Escape hatch:
+            // MUONROI_DISCOVERY_SKIP_ENV_CONTEXT=1.
+            const osLabel = process.platform === "win32" ? "Windows" : process.platform === "darwin" ? "macOS" : "Linux";
+            const envHeader = process.env.MUONROI_DISCOVERY_SKIP_ENV_CONTEXT === "1"
+                ? ""
+                : `Runtime: ${osLabel} (${process.platform}); \`bash\` is POSIX. The project's language/framework is in the context below — do NOT assume Python or a POSIX-only layout. Do NOT ask the user to paste the directory tree, file list, or project structure: you run INSIDE the repository and can inspect it with your own tools. Ask only about genuine intent / scope ambiguities.\n`;
             const prompt = `You are the AI agent executing inside muonroi-cli.
-User request: "${input.raw}"
+${envHeader}User request: "${input.raw}"
 Task type from CLI: ${input.l1.taskType}
 ${contextStr}
 
-Based on the above, output 1-3 specific, concise questions you (the model) still need the user to answer right now so you have all the information required to complete the task accurately, without guessing.
-If the User request is a follow-up or continuation of the recent conversation history (if provided above), do NOT ask for new project details; assume the context is already established and return an empty array [] unless there is a critical new ambiguity.
-Consider the provided language/framework/modules/EE patterns when suggesting questions and recs — only ask what is missing from this context.${special}
-For each question also provide 1-2 short concrete recommendations the user can pick from (model-backed choices).
+You decide whether this turn has a genuine gray area that BLOCKS you from delivering correctly. Output the FEW specific, concise questions you (the model) genuinely still need answered — ask only what is truly blocking, not a quota. Most well-scoped requests need 0-1 questions. If everything you need is already inferable from the request + context above, OR the request is a plain question you can simply answer, return an empty array [].
+If the User request is a follow-up or continuation of the recent conversation history (if provided above), do NOT ask for new project details; assume the context is already established and return [] unless there is a critical new ambiguity.
+Consider the provided language/framework/modules/EE patterns when suggesting questions and recs — never ask something the context above already answers.${special}
+For each question: (1) provide 1-2 short concrete recommendations the user can pick from, ALWAYS listing the ONE you would choose FIRST — it becomes the default the user accepts with one keypress; (2) give a short "reason" clause explaining WHY answering it changes what you do. Be decisive; do not hand back an unranked list.
 Return ONLY valid JSON array, nothing else:
-[{"question":"...","recommends":["rec1","rec2"]}, ...]
+[{"question":"...","recommends":["rec1","rec2"],"reason":"why this matters"}, ...]
 Max 3 items.`;
             const result = await generateText({
                 model: runtime.model,
                 prompt,
-                maxOutputTokens: 256,
+                maxOutputTokens: 320,
             });
-            let items = [];
+            let items;
             try {
                 const txt = result.text
                     .trim()
                     .replace(/```json|```/g, "")
                     .trim();
-                items = JSON.parse(txt);
+                const parsed = JSON.parse(txt);
+                items = Array.isArray(parsed) ? parsed : [];
             }
-            catch {
-                // degrade: treat whole text as one question with no recs
-                items = [{ question: result.text.trim(), recommends: [] }];
+            catch (parseErr) {
+                // A malformed (non-JSON) model response must NOT be coerced into a junk
+                // askcard — log and return no questions (proceed without interview).
+                console.error(`[Agent:discovery] clarification proposer returned non-JSON — no questions this turn: ${parseErr?.message}`, { sample: result.text.slice(0, 160) });
+                return [];
             }
-            return items.slice(0, 3).map((it) => {
+            return items
+                .filter((it) => it && typeof it.question === "string" && it.question.trim())
+                .slice(0, 3)
+                .map((it) => {
                 const recs = (it.recommends || []).slice(0, 2).join(" | ");
-                const tag = recs ? ` [MODEL RECS: ${recs}]` : "";
-                return `${it.question || "Clarify needed details"}${tag}`;
+                const recTag = recs ? ` [MODEL RECS: ${recs}]` : "";
+                const why = (it.reason || "").trim();
+                const whyTag = why ? ` [WHY: ${why}]` : "";
+                return `${it.question.trim()}${recTag}${whyTag}`;
             });
         }
         catch (err) {
-            // Silent degrade: no model questions, fall back to static
+            // No Silent Catch + fail-loud: the model call failed. Log with context and
+            // return no questions — discovery proceeds WITHOUT an interview rather than
+            // fabricating a regex-derived one ("có vấn đề = fail = ghi logs").
+            console.error(`[Agent:discovery] clarification proposer failed (${modelId}): ${err?.message}`, {
+                stack: err?.stack?.split("\n").slice(0, 3),
+            });
             return [];
         }
     };

package/dist/src/pil/layer1-intent.d.ts

@@ -51,6 +51,18 @@ export declare function scoreComplexity(input: ComplexityInput): ComplexityOutpu
 export declare function isTestGenerationTask(raw: string): boolean;
 /** Detect optimization-verb prompts where refactor is the correct taskType. */
 export declare function isPerformanceRefactor(raw: string): boolean;
+/**
+ * Detect a greenfield CREATE/BUILD request whose correct taskType is `build`.
+ * Tight by construction: requires a LEADING creation verb + a software-artifact
+ * object, and vetoes build-failure/debug context. When unsure it returns false
+ * so the prompt cascades to the classifier + brain (no wrong deterministic pin).
+ *
+ * `build` is a first-class TaskType (greenfield project/feature creation) — it is
+ * the sole producer of that label. It mirrors `generate` for routing (tier/role/
+ * tokens/ceiling) but carries greenfield-specific outcome options + output rules.
+ * This replaces the F17 band-aid that pinned greenfield prompts to `generate`.
+ */
+export declare function isGreenfieldBuildTask(raw: string): boolean;
 /** Detect short continuation prompts ("tiếp tục", "ok", "continue", …). */
 export declare function isContinuationPhrase(raw: string): boolean;
 /**