muonroi-cli 1.8.4 → 1.9.0

package/dist/src/product-loop/criteria-seed.d.ts

@@ -0,0 +1,51 @@
+import type { CouncilLLM } from "../council/types.js";
+/**
+ * Extract acceptance-criteria strings from a council synthesis blob. The synthesis
+ * is `<json>---READABLE---<prose>` (see council/planner.parseOutcome); the JSON
+ * block carries `acceptance_criteria: string[]`. Falls back to a markdown
+ * "Acceptance Criteria" bullet section when JSON is absent/malformed so a
+ * readable-only plan still seeds something.
+ */
+export declare function extractAcceptanceCriteria(planSynthesis: string): string[];
+/**
+ * Stable, single-line id for a criterion (used as the gray-areas.md section
+ * heading). Deterministic so re-seeding the same criterion is idempotent.
+ */
+export declare function criterionIdFromText(text: string): string;
+/**
+ * Merge the plan's acceptance criteria into gray-areas.md as unmet Criterion rows.
+ * Idempotent and non-clobbering: criteria already present (any status) are left
+ * untouched so a re-plan/retry never resets progress.
+ * Returns the count of NEW criteria seeded.
+ */
+export declare function seedCriteriaFromPlan(flowDir: string, runId: string, criteriaTexts: string[], sprintN: number): Promise<number>;
+/**
+ * Non-blocking plan-quality check. The per-sprint plan is auto-approved (there is
+ * no plan-check gate by design, to avoid stranding the loop), so a weak plan reaches
+ * the implementer silently. This surfaces the two failure modes that let Sprint 1
+ * diverge undetected: (1) no acceptance_criteria → done-gate can't score/gate,
+ * (2) no file_edits → the plan is prose, not an executable target list. Callers
+ * emit these as warnings and may inject a corrective note; they never halt.
+ */
+export declare function planQualityIssues(planSynthesis: string, seededCriteriaCount: number): string[];
+/**
+ * Judge the still-unmet criteria against the sprint's verify output + a diff
+ * summary, using a single bounded LLM call, then persist met/partial statuses
+ * with evidence. This is what lets the done-gate score reflect what was actually
+ * implemented (and blocks ship when the impl diverged from the plan).
+ *
+ * Fail-open: any parse/LLM error leaves criteria unmet (conservative — a sprint
+ * cannot pass on a judging failure). Returns the number of criteria upgraded.
+ */
+export declare function judgeCriteriaAgainstVerify(args: {
+    flowDir: string;
+    runId: string;
+    llm: CouncilLLM;
+    modelId: string;
+    verifyVerdict: string;
+    verifyOutput: string;
+    diffSummary: string;
+}): Promise<{
+    judged: number;
+    total: number;
+}>;

package/dist/src/product-loop/criteria-seed.js

@@ -0,0 +1,200 @@
+import { readCriteria, updateCriteria } from "./artifact-io.js";
+/**
+ * Slice fidelity fix (2026-07-11): the per-sprint council synthesis (planSynthesis)
+ * already carries a rich `acceptance_criteria` array, but nothing extracted it into
+ * the criteria store (gray-areas.md). readCriteria therefore returned [], the
+ * done-gate's calculateScore returned 0, and every sprint scored 0.00 — the
+ * implementation could diverge from the plan (wrong LSP op, stub tools) with no
+ * gate to catch it. This module closes that gap: seed the plan's acceptance
+ * criteria as real Criterion rows, then judge them against the verify output so the
+ * score reflects what was actually built and a failing criterion forces a retry.
+ */
+const MAX_CRITERIA_PER_SPRINT = 24;
+const ID_MAX_LEN = 70;
+/**
+ * Extract acceptance-criteria strings from a council synthesis blob. The synthesis
+ * is `<json>---READABLE---<prose>` (see council/planner.parseOutcome); the JSON
+ * block carries `acceptance_criteria: string[]`. Falls back to a markdown
+ * "Acceptance Criteria" bullet section when JSON is absent/malformed so a
+ * readable-only plan still seeds something.
+ */
+export function extractAcceptanceCriteria(planSynthesis) {
+    if (!planSynthesis || !planSynthesis.trim())
+        return [];
+    // 1) Prefer the JSON block before the ---READABLE--- separator.
+    const jsonPart = planSynthesis.includes("---READABLE---") ? planSynthesis.split("---READABLE---")[0] : planSynthesis;
+    const jsonMatch = jsonPart.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+        try {
+            const parsed = JSON.parse(jsonMatch[0]);
+            const raw = parsed.acceptance_criteria ?? parsed.acceptanceCriteria;
+            if (Array.isArray(raw)) {
+                const items = raw
+                    .map((c) => (typeof c === "string" ? c : typeof c === "object" && c ? JSON.stringify(c) : ""))
+                    .map((s) => s.trim())
+                    .filter((s) => s.length > 0);
+                if (items.length > 0)
+                    return dedupe(items).slice(0, MAX_CRITERIA_PER_SPRINT);
+            }
+        }
+        catch {
+            /* fall through to markdown */
+        }
+    }
+    // 2) Markdown fallback: bullets under an "Acceptance Criteria" heading.
+    const lines = planSynthesis.split("\n");
+    const out = [];
+    let inSection = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (/^#{1,6}\s|^\*\*/.test(trimmed) && /acceptance\s+criteria/i.test(trimmed)) {
+            inSection = true;
+            continue;
+        }
+        if (inSection) {
+            if (/^#{1,6}\s/.test(trimmed) || /^\*\*[A-Z]/.test(trimmed))
+                break; // next heading
+            const bullet = trimmed.match(/^[-*]\s+(.*)$/) ?? trimmed.match(/^\d+\.\s+(.*)$/);
+            if (bullet && bullet[1].trim())
+                out.push(bullet[1].trim());
+        }
+    }
+    return dedupe(out).slice(0, MAX_CRITERIA_PER_SPRINT);
+}
+function dedupe(items) {
+    const seen = new Set();
+    const out = [];
+    for (const it of items) {
+        const key = it.toLowerCase().replace(/\s+/g, " ");
+        if (!seen.has(key)) {
+            seen.add(key);
+            out.push(it);
+        }
+    }
+    return out;
+}
+/**
+ * Stable, single-line id for a criterion (used as the gray-areas.md section
+ * heading). Deterministic so re-seeding the same criterion is idempotent.
+ */
+export function criterionIdFromText(text) {
+    const oneLine = text.replace(/\s+/g, " ").trim();
+    if (oneLine.length <= ID_MAX_LEN)
+        return oneLine;
+    // Truncate but append a short hash so two long criteria that share a prefix
+    // don't collapse to the same heading.
+    let hash = 0;
+    for (let i = 0; i < oneLine.length; i++)
+        hash = (hash * 31 + oneLine.charCodeAt(i)) | 0;
+    const suffix = (hash >>> 0).toString(36).slice(0, 6);
+    return `${oneLine.slice(0, ID_MAX_LEN - 8).trim()}… #${suffix}`;
+}
+/**
+ * Merge the plan's acceptance criteria into gray-areas.md as unmet Criterion rows.
+ * Idempotent and non-clobbering: criteria already present (any status) are left
+ * untouched so a re-plan/retry never resets progress.
+ * Returns the count of NEW criteria seeded.
+ */
+export async function seedCriteriaFromPlan(flowDir, runId, criteriaTexts, sprintN) {
+    if (criteriaTexts.length === 0)
+        return 0;
+    const existing = await readCriteria(flowDir, runId);
+    const existingIds = new Set(existing.map((c) => c.id.trim()));
+    const fresh = [];
+    for (const text of criteriaTexts) {
+        const id = criterionIdFromText(text);
+        if (existingIds.has(id.trim()))
+            continue;
+        existingIds.add(id.trim());
+        fresh.push({ id, status: "unmet", sprint: sprintN });
+    }
+    if (fresh.length === 0)
+        return 0;
+    await updateCriteria(flowDir, runId, fresh);
+    return fresh.length;
+}
+/**
+ * Non-blocking plan-quality check. The per-sprint plan is auto-approved (there is
+ * no plan-check gate by design, to avoid stranding the loop), so a weak plan reaches
+ * the implementer silently. This surfaces the two failure modes that let Sprint 1
+ * diverge undetected: (1) no acceptance_criteria → done-gate can't score/gate,
+ * (2) no file_edits → the plan is prose, not an executable target list. Callers
+ * emit these as warnings and may inject a corrective note; they never halt.
+ */
+export function planQualityIssues(planSynthesis, seededCriteriaCount) {
+    const issues = [];
+    if (seededCriteriaCount === 0) {
+        issues.push("plan carries no acceptance_criteria — the done-gate cannot score this sprint against the plan");
+    }
+    if (!/"?file_edits"?\s*:/.test(planSynthesis) && !/##\s*file edits/i.test(planSynthesis)) {
+        issues.push("plan lists no file_edits — implementation has no concrete target files to follow");
+    }
+    return issues;
+}
+/**
+ * Judge the still-unmet criteria against the sprint's verify output + a diff
+ * summary, using a single bounded LLM call, then persist met/partial statuses
+ * with evidence. This is what lets the done-gate score reflect what was actually
+ * implemented (and blocks ship when the impl diverged from the plan).
+ *
+ * Fail-open: any parse/LLM error leaves criteria unmet (conservative — a sprint
+ * cannot pass on a judging failure). Returns the number of criteria upgraded.
+ */
+export async function judgeCriteriaAgainstVerify(args) {
+    const criteria = await readCriteria(args.flowDir, args.runId);
+    const unmet = criteria.filter((c) => c.status !== "met");
+    if (unmet.length === 0)
+        return { judged: 0, total: criteria.length };
+    // Evidence must be verifiable (done-gate condition #2 rejects criteria marked
+    // met/partial without a valid evidence string), so only allow upgrades when
+    // verify did not hard-fail. On FAIL/ERROR, leave everything unmet.
+    if (args.verifyVerdict !== "PASS") {
+        return { judged: 0, total: criteria.length };
+    }
+    const list = unmet.map((c, i) => `${i + 1}. [${c.id}] ${c.id}`).join("\n");
+    const prompt = `You are grading whether each acceptance criterion is satisfied by a sprint's ` +
+        `actual work. Be strict: mark "met" ONLY when the diff + verify output show it ` +
+        `is truly satisfied; "partial" if started but incomplete; "unmet" otherwise.\n\n` +
+        `Verify verdict: ${args.verifyVerdict}\n` +
+        `Verify output (truncated):\n${args.verifyOutput.slice(0, 4000)}\n\n` +
+        `Changed files / diff summary (truncated):\n${args.diffSummary.slice(0, 4000)}\n\n` +
+        `Criteria:\n${list}\n\n` +
+        `Return ONLY a JSON array: [{"n": <number>, "status": "met"|"partial"|"unmet", ` +
+        `"evidence": "<one concrete sentence citing a file/test/output; required for met/partial>"}]`;
+    let raw;
+    try {
+        raw = await args.llm.generate(args.modelId, "You are a strict acceptance-criteria grader.", prompt);
+    }
+    catch {
+        return { judged: 0, total: criteria.length };
+    }
+    const jsonMatch = raw.match(/\[[\s\S]*\]/);
+    if (!jsonMatch)
+        return { judged: 0, total: criteria.length };
+    let verdicts;
+    try {
+        verdicts = JSON.parse(jsonMatch[0]);
+    }
+    catch {
+        return { judged: 0, total: criteria.length };
+    }
+    const updates = [];
+    for (const v of verdicts) {
+        if (typeof v.n !== "number" || v.n < 1 || v.n > unmet.length)
+            continue;
+        const target = unmet[v.n - 1];
+        const status = v.status === "met" || v.status === "partial" ? v.status : "unmet";
+        const evidence = typeof v.evidence === "string" ? v.evidence.trim() : "";
+        // Don't upgrade without evidence — the done-gate would reject it anyway.
+        if ((status === "met" || status === "partial") && evidence.length < 8)
+            continue;
+        if (status === "unmet")
+            continue;
+        updates.push({ id: target.id, status, evidence, sprint: target.sprint });
+    }
+    if (updates.length > 0) {
+        await updateCriteria(args.flowDir, args.runId, updates);
+    }
+    return { judged: updates.length, total: criteria.length };
+}
+//# sourceMappingURL=criteria-seed.js.map

package/dist/src/product-loop/discovery-context-format.js

@@ -34,7 +34,9 @@ export function formatProjectContextForPrompt(ctx) {
         lines.push(`Backend stack: ${lang} / ${fw}${runtime}`);
     }
     if (c.dbStrategy) {
-        lines.push(`Database: ${c.dbStrategy.mode ?? "(unspecified)"} ${c.dbStrategy.engine ?? ""}`.trimEnd());
+        lines.push(c.dbStrategy.mode === "none"
+            ? "Database: none (stateless — no persistent storage)"
+            : `Database: ${c.dbStrategy.mode ?? "(unspecified)"} ${c.dbStrategy.engine ?? ""}`.trimEnd());
     }
     if (c.frontendApproach) {
         const harness = c.frontendApproach.agentHarness

package/dist/src/product-loop/discovery-ecosystem.js

@@ -164,7 +164,10 @@ export function buildEcosystemPreamble() {
         "- Angular with @muonroi/agent-harness-angular directive.",
         'When recommending `frontendApproach`, ALWAYS fill the optional `agentHarness` slot — pick "react" for React/Next, "angular" for Angular, "opentui" for terminal UI, "core" for non-DOM integration. Only use "none" when the project has no UI at all.',
         "",
-        "Recommend non-ecosystem options ONLY when the user's prompt explicitly opts out (e.g. mentions Node.js/Express/Django by name).",
+        "Strongest-default, still extensible:",
+        "- Keep the Muonroi/.NET path as the PRIMARY recommendation — it is the ecosystem's strongest, best-supported option.",
+        "- BUT for stack choices (architecture/stack/platform) ALWAYS include at least one mainstream NON-ecosystem alternative in `alternatives` (pick what genuinely fits the task — e.g. Python for data/ML/scripting, Go or Rust for a fast static-binary CLI, Node/TypeScript for JS-native tooling), with a one-line rationale. A user outside the Muonroi ecosystem must always see a real, viable path — never a .NET-only menu.",
+        "- Promote the non-ecosystem option to PRIMARY only when the prompt names another stack, or the task is a poor fit for .NET (e.g. a shell-glue one-liner, a data-science notebook, an npm-ecosystem plugin). Otherwise it stays a first-class alternative, not the default.",
     ].join("\n");
 }
 /**

package/dist/src/product-loop/discovery-interview.d.ts

@@ -1,4 +1,5 @@
 import { type RecommendInput, type RecommendOutput } from "./discovery-recommender.js";
+import type { InterviewTriage } from "./discovery-triage.js";
 import type { ExistingProjectSignals, ProjectContext } from "./types.js";
 export type UserPromptResult = {
     action: "accept";
@@ -62,5 +63,13 @@ export interface IterateOpts {
      * sandboxed temp dir to exercise existing-project paths deterministically.
      */
     cwd?: string;
+    /**
+     * Model-decided interview triage (see discovery-triage.ts). When present it is
+     * the PRIMARY signal for how deep to interview — replacing the legacy keyword
+     * `computePromptSpecificity` heuristic (kept only as the graceful-degrade
+     * fallback inside `triageInterview`). Absent → the old specificity behaviour is
+     * used verbatim, so existing callers/tests are unaffected.
+     */
+    triage?: InterviewTriage;
 }
 export declare function iterateInterview(opts: IterateOpts): Promise<ProjectContext>;

package/dist/src/product-loop/discovery-interview.js

@@ -3,6 +3,13 @@ import { appendUserOverride, buildProjectContextFromState, markDone, markUserGat
 import { computePromptSpecificity, toEntry, } from "./discovery-recommender.js";
 import { DISCOVERY_QUESTIONS, isFePolicyAccepted, isRequiredForPlatform, REQUIRED_QUESTION_IDS, validateAnswer, } from "./discovery-schema.js";
 import { buildRepoBrief } from "./repo-brief.js";
+/**
+ * Under existing-repo collapse, keep ONLY these questions as interactive
+ * per-field cards — they are the fields whose answers actually shape the
+ * technical change. Everything else in DISCOVERY_QUESTIONS is auto-filled and
+ * surfaced together on the compact __user_gate__ confirm card.
+ */
+const KEEP_CARD_FOR_EXISTING = new Set(["backendArchitecture"]);
 export async function iterateInterview(opts) {
     const { flowDir, runId, detection } = opts;
     const _itvDbg = process.env.MUONROI_DEBUG_LEADER === "1";
@@ -20,17 +27,47 @@ export async function iterateInterview(opts) {
     // but optional ones (baStatus, designStatus, deployment, frontendApproach when
     // not web) are deferred unless the user explicitly re-runs with more context.
     const specificity = computePromptSpecificity(opts.idea);
-    const skipOptionalForMinimal = specificity === "minimal";
-    // G2-b: for a minimal OR well-specified ("detailed") prompt the recommender's
-    // primary is high-confidence — minimal picks smallest-scope defaults, detailed
-    // respects the stated context. In both cases surfacing a card for EVERY
-    // required question (productType/targetPlatform/audience/…) is over-asking the
-    // user already complained about: they accept by reflex. Instead auto-accept
-    // the recommender primary for required questions and surface ONE summary card
-    // (the user gate) listing the assumptions so the user can proceed or adjust.
-    // "moderate" prompts keep the per-question cards (genuinely ambiguous). Escape
-    // hatch: MUONROI_DISCOVERY_AUTOFILL=0 restores per-question cards everywhere.
-    const autoFillRequired = (specificity === "minimal" || specificity === "detailed") && process.env.MUONROI_DISCOVERY_AUTOFILL !== "0";
+    // Interview-depth tier. PRIMARY signal is the model-decided triage
+    // (opts.triage); the legacy keyword specificity is used ONLY when no triage was
+    // supplied (older callers / tests), mapped: minimal→trivial, else→standard.
+    // "detailed" no longer force-collapses on the heuristic alone — a precise-but-
+    // complex idea should be triaged as complex by the model, not auto-filled blind.
+    const tier = opts.triage?.complexity ?? (specificity === "minimal" ? "trivial" : "standard");
+    // Existing-codebase work (refactor / migration / feature-add on a repo that
+    // already has source) should NOT re-run the full greenfield product-scoping
+    // questionnaire. productType/audience/targetPlatform/frontend/design/deployment
+    // are derivable from the codebase and inert for the technical change — asking
+    // them per-field is the over-ask users complained about. For any non-greenfield
+    // classification (existing OR ambiguous polyglot) we collapse to the ONE
+    // decision-relevant card (backendArchitecture) plus the compact "assumed from
+    // codebase" confirm gate (the same __user_gate__ path used for minimal/detailed
+    // prompts). This mirrors the repoBrief-build condition below. Escape hatch:
+    // MUONROI_DISCOVERY_EXISTING_COLLAPSE=0 restores the full per-field interview.
+    const collapseForExisting = detection.classification !== "greenfield" && process.env.MUONROI_DISCOVERY_EXISTING_COLLAPSE !== "0";
+    const skipOptionalForMinimal = tier === "trivial" || collapseForExisting;
+    // Which REQUIRED questions stay as interactive per-question cards. Everything
+    // else auto-fills the recommender primary and is surfaced together on the ONE
+    // summary confirm card (__user_gate__). This is the crux of the "sharper, less
+    // hardcoded" interview:
+    //   - existing-repo collapse → only the decision-relevant field(s)
+    //   - trivial → NONE (e.g. a hello-world script: don't interrogate audience
+    //     scale / backend architecture / db strategy — just confirm the defaults)
+    //   - complex → ONLY the questions the model flagged as genuinely shaping this
+    //     build (triage.relevant); auto-fill the rest
+    //   - standard (or model unavailable) → ALL required stay cards (unchanged UX)
+    const interactiveRequired = collapseForExisting
+        ? new Set(KEEP_CARD_FOR_EXISTING)
+        : tier === "trivial"
+            ? new Set()
+            : tier === "complex" && opts.triage
+                ? new Set(opts.triage.relevant)
+                : new Set(REQUIRED_QUESTION_IDS);
+    // Auto-accept the recommender primary for required questions NOT kept interactive
+    // above, and surface ONE summary card listing the assumptions so the user can
+    // proceed or adjust. Enabled whenever ANY required question is being auto-filled
+    // (i.e. the interactive set is a strict subset of the required set). Escape hatch:
+    // MUONROI_DISCOVERY_AUTOFILL=0 restores per-question cards everywhere.
+    const autoFillRequired = process.env.MUONROI_DISCOVERY_AUTOFILL !== "0" && REQUIRED_QUESTION_IDS.some((id) => !interactiveRequired.has(id));
     const assumed = [];
     // G1 follow-up: keep the recommendation behind each auto-filled assumption so
     // the user-gate "edit: <field>" path can re-render the SAME per-question card
@@ -94,7 +131,18 @@ export async function iterateInterview(opts) {
         // policy) so a malformed recommendation falls back to the normal card flow.
         // The assumed answers are surfaced together on the single user-gate card.
         let autoAccepted = false;
-        if (autoFillRequired && effectivelyRequired && recommendation.primary?.value != null) {
+        // Keep the interview-relevant fields interactive (existing-repo →
+        // backendArchitecture; complex → the model-flagged `triage.relevant`), and
+        // NEVER silently auto-accept a weakly-grounded recommendation (synthFailed =
+        // the rationale failed the repo-brief citation check twice) — fall through to a
+        // per-question card so the user can catch a hallucinated value instead of it
+        // being assumed.
+        const keepInteractive = interactiveRequired.has(question.id);
+        if (autoFillRequired &&
+            effectivelyRequired &&
+            recommendation.primary?.value != null &&
+            !recommendation.synthFailed &&
+            !keepInteractive) {
             const v = recommendation.primary.value;
             const validation = validateAnswer(question.id, v);
             const feLib = question.id === "frontendApproach" ? v?.library : undefined;

package/dist/src/product-loop/discovery-recommender.js

@@ -79,7 +79,8 @@ const LEADER_SYSTEM = "You are a product context recommender. Output ONE JSON ob
     "## Scope-sizing discipline\n" +
     "You will be told the user's original prompt and its specificity bucket (minimal/moderate/detailed).\n" +
     '- When specificity is "minimal" (e.g. user typed "build a todo app" or "tạo wiki"), pick the SMALLEST-SCOPE primary that still works: ' +
-    'productType="other" or "consumer-app" (NOT "saas"), audience scale="1-100" (NOT "100-1k" or above), ' +
+    'productType="consumer-app" for a small app, or "cli-tool"/"script"/"library" for a stand-alone tool/snippet ' +
+    '(prefer these over the catch-all "other" — a hello-world script is a "script", not "other"), audience scale="1-100" (NOT "100-1k" or above), ' +
     "single-user / no auth / web-only / simplest stack. Put richer multi-tenant/team-scale alternatives in `alternatives`, NOT primary. " +
     "Rationale: short prompts mean the user has NOT asked for enterprise complexity. Inflating scope here cascades into wasted debate and over-built code.\n" +
     '- When specificity is "moderate", pick pragmatic defaults grounded in any stated context; surface ONE richer alternative.\n' +

package/dist/src/product-loop/discovery-schema.js

@@ -18,7 +18,7 @@ export const DISCOVERY_QUESTIONS = [
         id: "dbStrategy",
         required: true,
         recommendMode: "council",
-        prompt: "Database strategy: greenfield, existing schema, or migration?",
+        prompt: "Database strategy: none (stateless — no persistent storage), greenfield, existing schema, or migration? Choose none for a CLI/tool/filter that keeps no data.",
     },
     {
         id: "frontendApproach",
@@ -48,7 +48,20 @@ export function isRequiredForPlatform(questionId, platforms) {
     }
     return false;
 }
-const PRODUCT_TYPES = new Set(["saas", "internal-tool", "consumer-app", "b2b-platform", "marketplace", "other"]);
+const PRODUCT_TYPES = new Set([
+    "saas",
+    "internal-tool",
+    "consumer-app",
+    "b2b-platform",
+    "marketplace",
+    // Small-scope builds that previously had no home in the enum and so were
+    // forced to "other" — the exact "recommend other" bad UX users hit for a
+    // hello-world script. A trivial CLI/script/library now maps cleanly.
+    "cli-tool",
+    "script",
+    "library",
+    "other",
+]);
 const SCALES = new Set(["1-100", "100-1k", "1k-100k", "100k-1M", "1M+"]);
 /**
  * Schema hint for the leader prompt — surfaces the enum/shape that
@@ -74,6 +87,10 @@ export function getSchemaHintForLeader(questionId) {
             return `value MUST be an object {"persona": string, "scale": one of ${Array.from(SCALES)
                 .map((s) => JSON.stringify(s))
                 .join("|")}, "geography": string}`;
+        case "dbStrategy":
+            // F7 — give the recommender an explicit "no persistence" option so it
+            // stops mis-ranking "greenfield" for stateless products (CLI/tool/filter).
+            return `value MUST be an object {"mode": one of "none"|"greenfield"|"existing-schema"|"migrate-from", "engine": string, "notes"?: string}. Pick "mode":"none" with "engine":"" when the product keeps NO persistent data (e.g. a stateless CLI, filter, or one-shot tool) — do NOT default to "greenfield" in that case.`;
         case "frontendApproach":
             return `value MUST be an object {"library": one of ${Array.from(ACCEPTED_FE_LIBRARIES)
                 .map((l) => JSON.stringify(l))

package/dist/src/product-loop/discovery-triage.d.ts

@@ -0,0 +1,23 @@
+import type { LeaderLike } from "./discovery-prompt-parser.js";
+import { type DiscoveryQuestion } from "./discovery-schema.js";
+export type ComplexityTier = "trivial" | "standard" | "complex";
+export interface InterviewTriage {
+    complexity: ComplexityTier;
+    /**
+     * Required question ids (subset of REQUIRED_QUESTION_IDS) whose answers
+     * genuinely shape THIS build and must stay interactive cards. Only meaningful
+     * for `complexity === "complex"`; empty for trivial (auto-fill all) and ignored
+     * for standard (keep all cards).
+     */
+    relevant: string[];
+    rationale: string;
+    source: "model" | "fallback";
+}
+/** Graceful-degrade triage derived from the legacy specificity heuristic. */
+export declare function fallbackTriage(idea: string): InterviewTriage;
+/**
+ * Triage the interview depth for `idea` via one leader call. Never throws —
+ * returns a fallback triage on any LLM/parse failure. Skips the call entirely
+ * (and returns the fallback) when the idea is empty.
+ */
+export declare function triageInterview(idea: string, leader: LeaderLike, requiredQuestions: DiscoveryQuestion[]): Promise<InterviewTriage>;

package/dist/src/product-loop/discovery-triage.js

@@ -0,0 +1,109 @@
+// src/product-loop/discovery-triage.ts
+//
+// Model-decided interview triage.
+//
+// The discover/gather interview used to size itself off `computePromptSpecificity`
+// — a hardcoded word-count + keyword-list heuristic. That misclassifies precise-
+// but-trivial ideas: "build a Python script hello.py that prints … and a pytest
+// test" is ~18 words with no keyword hit → "moderate" → the user is dragged
+// through 6 generic cards (productType/platform/audience/architecture/stack/db)
+// and the productType recommender falls back to "other". That is the "hời hợt /
+// hardcode" UX users complained about, and it violates the project's
+// agent-first-no-regex principle (interview depth must be model-decided).
+//
+// This module asks the leader model to triage the idea into a complexity tier and,
+// for genuinely complex ideas, name which of the fixed required questions actually
+// shape the build. The interview then:
+//   - trivial → auto-fill every required answer → ONE summary confirm card
+//   - complex → keep only the model-relevant questions as cards, auto-fill the rest
+//   - standard → unchanged per-question flow
+//
+// Fail-safe: any parse/LLM failure returns a `fallback` triage derived from the
+// old specificity heuristic, so the interview degrades to today's behaviour rather
+// than breaking. Pure decision + one bounded LLM call → unit-testable.
+import { computePromptSpecificity } from "./discovery-recommender.js";
+import { REQUIRED_QUESTION_IDS } from "./discovery-schema.js";
+const TRIAGE_SYSTEM = "You triage a software build request to decide how much of an interview it warrants. " +
+    "Output ONE JSON object, no prose, no code fences: " +
+    '{"complexity":"trivial"|"standard"|"complex","relevant":[<question-id>...],"rationale":"<short>"}.\n\n' +
+    "Tiers:\n" +
+    '- "trivial": a self-contained script, snippet, one-off tool, or exercise with ONE obvious stack and NO ' +
+    "persistence / scale / architecture / integration decisions. Examples: a hello-world script + a test, " +
+    "a regex to validate an email, a bash one-liner, a single pure function + unit test. The user should just " +
+    "confirm sensible defaults — asking about audience scale, backend architecture, or database strategy is noise.\n" +
+    '- "standard": a real but conventional app with a few genuine but well-trodden choices. Examples: a todo web ' +
+    "app, a CRUD REST API, a small CLI with a couple of subcommands.\n" +
+    '- "complex": multiple non-obvious architecture / scale / integration / security decisions. Examples: a ' +
+    "multi-tenant SaaS, an OAuth / SSO service, an event-driven pipeline, anything naming enterprise scale.\n\n" +
+    'For "complex" ONLY, set `relevant` to the question ids (from the provided list) whose answers genuinely ' +
+    "shape this build and MUST be asked; auto-filled defaults are fine for the rest. For trivial/standard, " +
+    "set `relevant` to []. Bias toward FEWER questions: every card the user accepts by reflex becomes locked-in spec.";
+function buildTriagePrompt(idea, requiredQuestions) {
+    const qList = requiredQuestions.map((q) => `- ${q.id}: ${q.prompt}`).join("\n");
+    return [
+        `Build request: ${JSON.stringify(idea)}`,
+        "",
+        "Required question ids you may cite in `relevant`:",
+        qList,
+    ].join("\n");
+}
+function stripFences(s) {
+    return s
+        .trim()
+        .replace(/^```(?:json)?\s*/, "")
+        .replace(/\s*```$/, "");
+}
+const TIERS = new Set(["trivial", "standard", "complex"]);
+/** Graceful-degrade triage derived from the legacy specificity heuristic. */
+export function fallbackTriage(idea) {
+    const specificity = computePromptSpecificity(idea);
+    // minimal prompt → treat as trivial (collapse to one confirm card, matching the
+    // old minimal-autofill path); everything else stays "standard" so the current
+    // per-question behaviour is preserved when the model is unavailable.
+    const complexity = specificity === "minimal" ? "trivial" : "standard";
+    return { complexity, relevant: [], rationale: `fallback from specificity=${specificity}`, source: "fallback" };
+}
+function parseTriage(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stripFences(raw));
+    }
+    catch {
+        return null;
+    }
+    const obj = parsed;
+    if (typeof obj?.complexity !== "string" || !TIERS.has(obj.complexity))
+        return null;
+    const requiredSet = new Set(REQUIRED_QUESTION_IDS);
+    const relevant = Array.isArray(obj.relevant)
+        ? obj.relevant.filter((r) => typeof r === "string" && requiredSet.has(r))
+        : [];
+    const rationale = typeof obj.rationale === "string" ? obj.rationale : "";
+    return { complexity: obj.complexity, relevant, rationale };
+}
+/**
+ * Triage the interview depth for `idea` via one leader call. Never throws —
+ * returns a fallback triage on any LLM/parse failure. Skips the call entirely
+ * (and returns the fallback) when the idea is empty.
+ */
+export async function triageInterview(idea, leader, requiredQuestions) {
+    if (!idea || idea.trim().length === 0)
+        return fallbackTriage(idea);
+    try {
+        const res = await leader.generate({
+            system: TRIAGE_SYSTEM,
+            prompt: buildTriagePrompt(idea, requiredQuestions),
+            maxTokens: 1024,
+        });
+        const parsed = parseTriage(res?.content ?? "");
+        if (!parsed)
+            return fallbackTriage(idea);
+        // `relevant` is only meaningful for complex; normalize the others to [].
+        const relevant = parsed.complexity === "complex" ? parsed.relevant : [];
+        return { complexity: parsed.complexity, relevant, rationale: parsed.rationale, source: "model" };
+    }
+    catch {
+        return fallbackTriage(idea);
+    }
+}
+//# sourceMappingURL=discovery-triage.js.map