muonroi-cli 1.8.5 → 1.9.0

package/dist/src/pil/repo-grounding-probe.d.ts

@@ -0,0 +1,15 @@
+import type { RepoStructureHint } from "./repo-structure-hints.js";
+export type GroundingBucket = "none" | "small" | "medium" | "large";
+export interface RepoGroundingProbeResult {
+    ran: boolean;
+    targets: string[];
+    matchedFiles: number;
+    totalLoc: number;
+    matchedDirs: number;
+    collision: boolean;
+    bucket: GroundingBucket;
+    groundingUncertainty: boolean;
+}
+export declare function probeRepoGrounding(prompt: string, hints: RepoStructureHint[], opts?: {
+    cwd?: string;
+}): RepoGroundingProbeResult;

package/dist/src/pil/repo-grounding-probe.js

@@ -0,0 +1,136 @@
+/**
+ * src/pil/repo-grounding-probe.ts
+ *
+ * Deterministic repo-grounding probe (Design B). Given a prompt + the
+ * checked-in REPO_DEEP_MAP index, measure how much repository surface the
+ * prompt's targets actually cover — file count, total LOC, directory spread,
+ * symbol collisions — so routing sizes on facts, not on the sentence length.
+ *
+ * PURE + deterministic: NO LLM call, NO network. Filesystem access is bounded
+ * to at most one existsSync + line-count read per distinct target that is an
+ * exact path absent from the index. Buckets come from a monotonic threshold
+ * FORMULA over measured counts — never a fixed depth→route table.
+ *
+ * See docs/superpowers/plans/2026-07-16-pil-repo-grounding-probe.md and the
+ * council synthesis (Design B) for the accepted invariants.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { extractPathTokens } from "./layer1_5-complexity-size.js";
+/** Distinct top-two path segments, e.g. "src/auth/login.ts" → "src/auth". */
+function topDir(path) {
+    const segs = path.split("/");
+    return segs.length >= 2 ? `${segs[0]}/${segs[1]}` : (segs[0] ?? path);
+}
+/** A target is a "bare basename" when it has no slash (a symbol/file name, not a path). */
+function isBareName(target) {
+    return !target.includes("/");
+}
+/**
+ * Measured LOC/file bucket. Monotonic in every input: more files, more LOC, or
+ * wider directory spread never lowers the bucket. Thresholds are counts (not a
+ * depth map) and are covered by fixture tests — the only knob the council
+ * permits for sizing.
+ */
+function bucketOf(matchedFiles, totalLoc, matchedDirs) {
+    if (matchedFiles === 0)
+        return "none";
+    if (matchedFiles >= 8 || totalLoc >= 4000 || matchedDirs >= 4)
+        return "large";
+    if (matchedFiles <= 2 && totalLoc < 500 && matchedDirs <= 1)
+        return "small";
+    return "medium";
+}
+export function probeRepoGrounding(prompt, hints, opts) {
+    const targets = extractPathTokens(prompt);
+    if (targets.length === 0) {
+        return {
+            ran: false,
+            targets: [],
+            matchedFiles: 0,
+            totalLoc: 0,
+            matchedDirs: 0,
+            collision: false,
+            bucket: "none",
+            groundingUncertainty: false,
+        };
+    }
+    const index = new Map(hints.map((h) => [h.path.toLowerCase(), h]));
+    // basename → the distinct indexed paths carrying it (for collision detection).
+    const byBasename = new Map();
+    for (const h of hints) {
+        const base = h.path.toLowerCase().split("/").pop() ?? h.path.toLowerCase();
+        const set = byBasename.get(base) ?? new Set();
+        set.add(h.path.toLowerCase());
+        byBasename.set(base, set);
+    }
+    const matchedPaths = new Set();
+    let totalLoc = 0;
+    let collision = false;
+    for (const target of targets) {
+        // 1. Exact indexed path.
+        const exact = index.get(target);
+        if (exact) {
+            if (!matchedPaths.has(exact.path.toLowerCase())) {
+                matchedPaths.add(exact.path.toLowerCase());
+                totalLoc += exact.lineCount;
+            }
+            continue;
+        }
+        // 2. Bare basename/symbol resolving across >1 indexed path → collision.
+        if (isBareName(target)) {
+            const carriers = byBasename.get(target);
+            if (carriers && carriers.size > 1) {
+                collision = true;
+                for (const p of carriers) {
+                    if (!matchedPaths.has(p)) {
+                        matchedPaths.add(p);
+                        totalLoc += index.get(p)?.lineCount ?? 0;
+                    }
+                }
+                continue;
+            }
+            if (carriers && carriers.size === 1) {
+                const only = [...carriers][0];
+                if (only && !matchedPaths.has(only)) {
+                    matchedPaths.add(only);
+                    totalLoc += index.get(only)?.lineCount ?? 0;
+                }
+                continue;
+            }
+        }
+        // 3. Exact path not in the index but present on disk → confirm + count (bounded).
+        const cwd = opts?.cwd;
+        if (cwd && target.includes("/")) {
+            const abs = join(cwd, target);
+            try {
+                if (existsSync(abs)) {
+                    const loc = readFileSync(abs, "utf8").split(/\r?\n/).length;
+                    if (!matchedPaths.has(target)) {
+                        matchedPaths.add(target);
+                        totalLoc += loc;
+                    }
+                }
+            }
+            catch (err) {
+                console.error(`[repo-grounding-probe] on-disk LOC read failed for ${target}: ${err?.message}`);
+            }
+        }
+        // else: unmatched target — contributes to a zero-match uncertainty signal.
+    }
+    const matchedFiles = matchedPaths.size;
+    const matchedDirs = new Set([...matchedPaths].map(topDir)).size;
+    const bucket = bucketOf(matchedFiles, totalLoc, matchedDirs);
+    const groundingUncertainty = matchedFiles === 0 || collision;
+    return {
+        ran: true,
+        targets,
+        matchedFiles,
+        totalLoc,
+        matchedDirs,
+        collision,
+        bucket,
+        groundingUncertainty,
+    };
+}
+//# sourceMappingURL=repo-grounding-probe.js.map

package/dist/src/pil/repo-structure-hints.d.ts

@@ -0,0 +1,7 @@
+export interface RepoStructureHint {
+    path: string;
+    lineCount: number;
+}
+export declare function parseRepoStructureHints(markdown: string): RepoStructureHint[];
+export declare function getRepoStructureHints(cwd: string): RepoStructureHint[];
+export declare function clearRepoStructureHintsCache(): void;

package/dist/src/pil/repo-structure-hints.js

@@ -0,0 +1,45 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+const MAP_FILE = "REPO_DEEP_MAP.md";
+const MAP_LINE_RE = /`([^`]+)`[^\n]*?\(~(\d+)\s+lines\b/gi;
+const cache = new Map();
+export function parseRepoStructureHints(markdown) {
+    const hints = [];
+    const seen = new Set();
+    for (const match of markdown.matchAll(MAP_LINE_RE)) {
+        const path = match[1]?.trim();
+        const lineCount = Number.parseInt(match[2] ?? "", 10);
+        if (!path || !Number.isFinite(lineCount))
+            continue;
+        const key = path.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        hints.push({ path, lineCount });
+    }
+    return hints;
+}
+export function getRepoStructureHints(cwd) {
+    const cached = cache.get(cwd);
+    if (cached)
+        return cached;
+    const mapPath = join(cwd, MAP_FILE);
+    if (!existsSync(mapPath)) {
+        cache.set(cwd, []);
+        return [];
+    }
+    try {
+        const raw = readFileSync(mapPath, "utf8");
+        const hints = parseRepoStructureHints(raw);
+        cache.set(cwd, hints);
+        return hints;
+    }
+    catch {
+        cache.set(cwd, []);
+        return [];
+    }
+}
+export function clearRepoStructureHintsCache() {
+    cache.clear();
+}
+//# sourceMappingURL=repo-structure-hints.js.map

package/dist/src/product-loop/artifact-io.js

@@ -92,6 +92,8 @@ export async function appendIteration(flowDir, runId, entry) {
         `CriteriaPartial: ${entry.criteriaPartial}`,
         `CriteriaUnmet: ${entry.criteriaUnmet}`,
     ];
+    if (entry.totalCriteria !== undefined)
+        lines.push(`TotalCriteria: ${entry.totalCriteria}`);
     if (entry.crashed)
         lines.push("Crashed: true");
     if (entry.retryOf !== undefined)
@@ -137,6 +139,8 @@ export async function readIterations(flowDir, runId) {
             iter.crashed = true;
         if (data.RetryOf !== undefined)
             iter.retryOf = Number.parseInt(data.RetryOf, 10);
+        if (data.TotalCriteria !== undefined)
+            iter.totalCriteria = Number.parseInt(data.TotalCriteria, 10);
         results.push(iter);
     }
     return results.sort((a, b) => a.sprintN - b.sprintN);

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-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

@@ -27,6 +27,12 @@ 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);
+    // 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
@@ -38,18 +44,30 @@ export async function iterateInterview(opts) {
     // 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 = specificity === "minimal" || collapseForExisting;
-    // 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" || collapseForExisting) &&
-        process.env.MUONROI_DISCOVERY_AUTOFILL !== "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
@@ -113,12 +131,13 @@ 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;
-        // Keep backendArchitecture interactive under existing-repo collapse (the one
-        // field whose answer shapes the technical work), 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 = collapseForExisting && KEEP_CARD_FOR_EXISTING.has(question.id);
+        // 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 &&

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

@@ -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

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>;