muonroi-cli 1.8.5 → 1.9.0

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

package/dist/src/product-loop/gather.js

@@ -2,12 +2,18 @@
 // Dispatcher that wires the discover phase into the adaptive interview flow.
 // buildDiscoveryDebateRunner ← Task 16
 // buildGatherUserPrompt      ← Task 17
-import { resolveLeaderModelDetailed } from "../council/leader.js";
+import { runClarification } from "../council/clarifier.js";
+import { resolveLeaderModelDetailed, resolveParticipants } from "../council/leader.js";
+import { isCouncilMultiProviderPreferred } from "../utils/settings.js";
 import { detectExistingProject } from "./discovery-detection.js";
 import { iterateInterview, } from "./discovery-interview.js";
-import { acquireRunLock, initDiscoveryState, readDiscoveryState, readProjectContext, releaseRunLock, resumeArtifactWriteIfNeeded, } from "./discovery-persistence.js";
+import { acquireRunLock, initDiscoveryState, markDone, readDiscoveryState, readProjectContext, releaseRunLock, resumeArtifactWriteIfNeeded, writeProjectContext, } from "./discovery-persistence.js";
 import { parsePromptForContext } from "./discovery-prompt-parser.js";
 import { councilRecommend, leaderRecommend, shouldFallbackToLeader } from "./discovery-recommender.js";
+import { DISCOVERY_QUESTIONS } from "./discovery-schema.js";
+import { triageInterview } from "./discovery-triage.js";
+import { buildRepoBrief } from "./repo-brief.js";
+import { SEED_DIMENSIONS } from "./seed-questions.js";
 /**
  * Decide whether detection signals are STRONG enough to synthesize a
  * backendStack answer (skipping the interview question). Returns null when
@@ -251,6 +257,30 @@ llm, sessionModelId, io) {
             },
             prefillAnswers: { ...prefillFromDetection, ...prompted },
         });
+        // Unified agent-driven interview (default). The LLM leader generates every
+        // clarification question itself from the idea + injected context and emits
+        // its own askcards — the same engine `/council` uses (runClarification) —
+        // instead of walking the fixed DISCOVERY_QUESTIONS list. The CLI only
+        // injects context (repo brief / prompt-extracted hints); it hardcodes no
+        // questions. Requires a wired driver (emit + respondToQuestion); pure-unit
+        // callers without io fall through to the legacy fixed-question path below.
+        // Opt out with MUONROI_IDEAL_AGENT_INTERVIEW=0.
+        if (process.env.MUONROI_IDEAL_AGENT_INTERVIEW !== "0" && io?.emit && io?.respondToQuestion) {
+            return await runAgentDrivenGather({
+                flowDir,
+                runId,
+                idea,
+                cwd,
+                detection,
+                leaderModelId,
+                sessionModelId,
+                llm: llm,
+                prompted,
+                prefillFromDetection,
+                emit: io.emit,
+                respondToQuestion: io.respondToQuestion,
+            });
+        }
         // Recommender: always leader-only. The council debate runner (Task 16) is
         // a stub that throws; until it is wired we delegate council asks to the
         // leader so the gather phase doesn't crash on greenfield projects with
@@ -270,6 +300,22 @@ llm, sessionModelId, io) {
         // (only hit by tests that don't supply io).
         const tuiAsk = io?.emit && io?.respondToQuestion ? buildLiveTuiAsk(io.emit, io.respondToQuestion) : async () => "";
         const userPrompt = buildGatherUserPrompt(tuiAsk);
+        // Model-decided interview triage — the PRIMARY signal for how deep to
+        // interview (replaces the keyword `computePromptSpecificity` heuristic as the
+        // lead). A trivial idea (e.g. a hello-world script) collapses to ONE confirm
+        // card instead of 6 generic productType/audience/architecture/db cards; a
+        // complex idea keeps only the questions the model flags as decision-shaping.
+        // Only the required questions are triaged (optional ones are gated separately).
+        // Never throws — degrades to the specificity fallback (see discovery-triage.ts).
+        const requiredQuestions = DISCOVERY_QUESTIONS.filter((q) => q.required);
+        const triage = await triageInterview(idea, leader, requiredQuestions);
+        if (process.env.MUONROI_DEBUG_LEADER === "1") {
+            process.stderr.write(`[interview-triage] ${JSON.stringify({
+                complexity: triage.complexity,
+                relevant: triage.relevant,
+                source: triage.source,
+            })}\n`);
+        }
         return await iterateInterview({
             flowDir,
             runId,
@@ -278,6 +324,7 @@ llm, sessionModelId, io) {
             detection,
             userPrompt,
             recommender,
+            triage,
         });
     }
     finally {
@@ -285,6 +332,90 @@ llm, sessionModelId, io) {
     }
 }
 // ---------------------------------------------------------------------------
+// Agent-driven interview (unified clarifier engine)
+// ---------------------------------------------------------------------------
+/**
+ * Run the gather interview by delegating to the SAME agent-driven clarifier the
+ * council uses (`runClarification`): the LLM leader generates its own
+ * clarification questions from the idea + injected context, emits its own
+ * `council_question` askcards, self-judges readiness, and synthesizes a
+ * `ClarifiedSpec`. The CLI contributes only context (repo brief for existing
+ * repos, prompt-extracted hints) and the askcard plumbing — it hardcodes no
+ * questions and no answer enums.
+ *
+ * Output is a `ProjectContext` that carries the clarifier's `ClarifiedSpec`
+ * verbatim (`clarified`), so `clarifiedSpecFromContext` returns the real
+ * LLM-synthesized successCriteria/constraints/scope instead of re-deriving a
+ * thin persona+scale spec. `context` is populated best-effort from detection +
+ * prompt hints purely as a supplement for the (fully-guarded) downstream
+ * `formatProjectContextForPrompt`.
+ */
+async function runAgentDrivenGather(args) {
+    // Context the CLI injects for the agent to interview AGAINST — never questions.
+    let conversationContext = "";
+    if (args.detection.classification !== "greenfield") {
+        try {
+            const brief = await buildRepoBrief(args.cwd, args.detection);
+            // The "## Current Project" header switches the clarifier into existing-repo
+            // mode (drops generic greenfield questions, grounds rationales in real files).
+            conversationContext += `## Current Project\n${brief.markdown}\n\n`;
+        }
+        catch {
+            // Brief failure must NEVER block the interview — fall through context-light.
+        }
+    }
+    if (Object.keys(args.prompted).length > 0) {
+        conversationContext += `## Extracted from the request\n${JSON.stringify(args.prompted, null, 2)}\n`;
+    }
+    // Reachable panel models — passed as the clarifier's fallbackModels so its
+    // research-first step can prefer a native-web-research model on any reachable
+    // provider (and spec-synth can fall back off a flaky leader proxy). Never
+    // blocks gather: resolution failure degrades to leader-only.
+    let panelModels = [];
+    try {
+        const participants = await resolveParticipants(args.sessionModelId, isCouncilMultiProviderPreferred());
+        panelModels = participants.map((p) => p.model).filter(Boolean);
+    }
+    catch {
+        // leader-only reachability is fine — research-first still runs on the leader.
+    }
+    // Drive the clarifier generator; forward each emitted chunk to the driver so
+    // the TUI renders each dynamically-generated askcard, then capture the spec.
+    // seedQuestions is intentionally empty — the clarifier's own research-first
+    // step (runClarification) now grounds the questions; no CLI-owned seed list.
+    const gen = runClarification(args.idea, args.leaderModelId, conversationContext, args.respondToQuestion, args.llm, undefined, // signal — no abort wired through gather today
+    undefined, // seedQuestions
+    undefined, // maxRounds → clarifier default
+    undefined, // prefillAnswers
+    false, // costAware
+    panelModels);
+    let result;
+    do {
+        result = await gen.next();
+        if (!result.done && result.value)
+            args.emit(result.value);
+    } while (!result.done);
+    const clarified = result.value;
+    const context = { ...args.prefillFromDetection, ...args.prompted };
+    const projectContext = {
+        version: 1,
+        schemaName: "project-context",
+        generatedAt: new Date().toISOString(),
+        idea: args.idea,
+        detection: args.detection,
+        context,
+        clarified,
+        recommendations: {
+            byField: {},
+            constraints: { fePolicy: "headless-ui-only", feEnforced: true },
+        },
+        userOverrides: [],
+    };
+    await writeProjectContext(args.flowDir, args.runId, projectContext);
+    await markDone(args.flowDir, args.runId);
+    return projectContext;
+}
+// ---------------------------------------------------------------------------
 // ClarifiedSpec bridge
 // ---------------------------------------------------------------------------
 /**
@@ -294,6 +425,23 @@ llm, sessionModelId, io) {
  * has passed (or all required questions are answered).
  */
 export function clarifiedSpecFromContext(pc) {
+    // Agent-driven path: the clarifier already synthesized a full ClarifiedSpec
+    // (real LLM-derived successCriteria/constraints/scope + rawQA). Return it
+    // verbatim, deriving the loop-driver resolution gate from the agent's OWN
+    // readiness judgment rather than the hardcoded 6-dimension answered-check:
+    // when the clarifier declared the spec ready (or didn't flag it not-ready),
+    // mark every SEED_DIMENSION resolved so the gate passes; otherwise leave them
+    // unspecified so the existing insufficient_resolution safety net still fires.
+    if (pc.clarified) {
+        const ready = pc.clarified.ready !== false;
+        const status = ready ? "answered" : "unspecified";
+        const resolved = {
+            ...(pc.clarified.resolved ?? {}),
+        };
+        for (const d of SEED_DIMENSIONS)
+            resolved[d.id] = status;
+        return { ...pc.clarified, resolved };
+    }
     const ctx = pc.context;
     const problemStatement = pc.idea;
     const constraints = [];

package/dist/src/product-loop/index.js

@@ -1204,6 +1204,12 @@ async function* runPhasesPath(args) {
             currentPhaseId = sc.phaseId ?? null;
             sprintHistory = [];
         }
+        // Carry the previous sprint's failure focus (unmet criteria / verify failures
+        // / residual plan deviations) into this sprint so each iteration continues the
+        // specific risky parts instead of restarting blind — parity with the legacy
+        // drainSprints path. Without this the phase-orchestrated loop dropped the
+        // feedback-routing focus between sprints.
+        const prevSprint = sprintHistory[sprintHistory.length - 1];
         const inner = runSprint({
             sprintN: sc.sprintN,
             ctx,
@@ -1211,6 +1217,7 @@ async function* runPhasesPath(args) {
             roleAssignments,
             history: [...sprintHistory],
             phaseScope: sc.phaseScope,
+            carryOver: prevSprint?.nextFocus ? { focus: prevSprint.nextFocus } : undefined,
         });
         let result;
         while (true) {

package/dist/src/product-loop/loop-driver.js

@@ -32,21 +32,33 @@ import { deriveTasksFromSpec, writeTasks } from "./typed-artifacts.js";
 // the debate llm and double-counted nothing else; recording at the source removes
 // both the leak and the risk of a double count here.
 /**
- * Best-effort interaction_logs writer for the loop-driver. Swallows failures
- * so a broken DB never blocks the FSM. `ctx.sessionId` falls back to runId
- * for legacy callers that don't pass a chat session id.
+ * Best-effort interaction_logs writer for the loop-driver. Logs and continues on
+ * failure so a broken DB never blocks the FSM. `ctx.sessionId` falls back to
+ * runId for legacy callers that don't pass a chat session id. `cols` carries
+ * fields that belong in real columns rather than metadata_json.
  */
-function logLoopEvent(ctx, subtype, data) {
+function logLoopEvent(ctx, subtype, data, cols) {
     try {
         const sid = ctx.sessionId ?? ctx.runId;
         // Stamp runId on every row so multi-run sessions can be demuxed during
         // forensics — previously only route_decision carried this field. Caller
         // overrides win if the payload already contained a runId.
         const enriched = "runId" in data ? data : { ...data, runId: ctx.runId };
-        logInteraction(sid, "council", { eventSubtype: subtype, data: enriched });
+        // `cols` promotes fields out of metadata_json into real columns so they are
+        // aggregatable in SQL. Without it every council_message row landed with
+        // duration_ms NULL, leaving `debate_complete` (the whole debate) as the only
+        // timed row — an aggregate that cannot name which speaker was slow.
+        logInteraction(sid, "council", {
+            eventSubtype: subtype,
+            data: enriched,
+            ...(cols?.model ? { model: cols.model } : {}),
+            ...(typeof cols?.durationMs === "number" ? { durationMs: cols.durationMs } : {}),
+        });
     }
-    catch {
-        /* non-critical — audit trail only */
+    catch (err) {
+        // Audit trail only — never block the FSM. Logged so a broken DB surfaces
+        // instead of silently emptying the forensics table. (No-Silent-Catch.)
+        console.error(`[loop-driver] logLoopEvent failed for subtype "${subtype}": ${err instanceof Error ? err.message : String(err)}`);
     }
 }
 /**
@@ -668,7 +680,8 @@ export async function* runLoopDriver(ctx) {
                                     // text limits even for the most verbose speaker turn.
                                     textExcerpt: cm.text.slice(0, 4000),
                                     textLength: cm.text.length,
-                                });
+                                    durationMs: cm.durationMs ?? null,
+                                }, { model: cm.speaker.model, durationMs: cm.durationMs });
                             }
                             yield chunk;
                         }

package/dist/src/product-loop/phase-plan.d.ts

@@ -7,6 +7,22 @@ export declare const PHASE_PLANNER_SYSTEM: string;
  * Normalise `id` + `dependsOn` on every phase to the canonical string form.
  * Mutates and returns the same plan object. Safe on already-normalised plans.
  */
+/**
+ * Coerce a plan's per-phase `maxSprints` to a usable sprint COUNT: an integer
+ * in [1, 20]. This is a pure VALIDITY FLOOR — it does NOT allocate or divide any
+ * budget. The PO/leader decides each phase's `maxSprints` from that phase's
+ * difficulty (see PHASE_PLANNER_SYSTEM); this only defends the executor against a
+ * malformed value the model might still emit.
+ *
+ * The sprint loop is `for (sprintN = 1; sprintN <= phase.maxSprints; sprintN++)`,
+ * so any value < 1 makes `1 <= 0.n` false → the loop body NEVER runs → `runSprint`
+ * is never called → implementation is silently skipped (the historical
+ * "plan is great but implement never starts / hangs" bug — a small `--max-sprints`
+ * once made the old "divide the budget across phases" prompt emit fractions like
+ * `0.3 / 0.2 / 0.5`). Flooring to an integer ≥ 1 guarantees every planned phase
+ * executes at least one sprint regardless of what the model returns.
+ */
+export declare function clampMaxSprints(raw: unknown): number;
 export declare function normalizePhasePlan(plan: PhasePlanArtifact): PhasePlanArtifact;
 export declare function parsePhasePlanJson(raw: string): PhasePlanArtifact;
 export declare function validatePhasePlan(plan: PhasePlanArtifact, spec: ClarifiedSpec): void;

package/dist/src/product-loop/phase-plan.js

@@ -3,9 +3,17 @@ import { promises as fs } from "node:fs";
 import * as path from "node:path";
 import { readArtifact, writeArtifact } from "../flow/artifact-io.js";
 import { withRateLimitBackoff } from "./discovery-recommender.js";
-export const PHASE_PLANNER_SYSTEM = "You decompose a product idea into 3–5 sequential phases. Output strict JSON only. " +
-    "Each phase covers a subset of successCriteria verbatim from the input spec. " +
-    "Union of all phases.successCriteria MUST equal the input successCriteria array (no drift, no omission).";
+export const PHASE_PLANNER_SYSTEM = "You are the PO/tech-lead planning an agile delivery. Decompose a product idea into 3–5 " +
+    "sequential phases. Output strict JSON only. Each phase covers a subset of successCriteria " +
+    "verbatim from the input spec. Union of all phases.successCriteria MUST equal the input " +
+    "successCriteria array (no drift, no omission).\n\n" +
+    "Size each phase to its REAL difficulty. For every phase, YOU decide its `maxSprints` — the " +
+    "maximum sprint iterations that phase may need — from that phase's own scope, risk, and " +
+    "uncertainty, exactly as a tech lead would in agile planning: a simple/mechanical phase needs " +
+    "1; a phase with hard, uncertain, or risky work needs more (2–5). Do NOT split a fixed budget " +
+    "evenly, do NOT pad to a quota, and never emit a fraction. `maxSprints` is a CEILING — the " +
+    "done-gate ends a phase early once its criteria are met — so give genuinely hard phases enough " +
+    "room to iterate rather than rationing them.";
 /**
  * Coerce a phase id / dependsOn element to the canonical `phase-N` string form.
  *
@@ -32,11 +40,33 @@ function normalizePhaseRef(ref) {
  * Normalise `id` + `dependsOn` on every phase to the canonical string form.
  * Mutates and returns the same plan object. Safe on already-normalised plans.
  */
+/**
+ * Coerce a plan's per-phase `maxSprints` to a usable sprint COUNT: an integer
+ * in [1, 20]. This is a pure VALIDITY FLOOR — it does NOT allocate or divide any
+ * budget. The PO/leader decides each phase's `maxSprints` from that phase's
+ * difficulty (see PHASE_PLANNER_SYSTEM); this only defends the executor against a
+ * malformed value the model might still emit.
+ *
+ * The sprint loop is `for (sprintN = 1; sprintN <= phase.maxSprints; sprintN++)`,
+ * so any value < 1 makes `1 <= 0.n` false → the loop body NEVER runs → `runSprint`
+ * is never called → implementation is silently skipped (the historical
+ * "plan is great but implement never starts / hangs" bug — a small `--max-sprints`
+ * once made the old "divide the budget across phases" prompt emit fractions like
+ * `0.3 / 0.2 / 0.5`). Flooring to an integer ≥ 1 guarantees every planned phase
+ * executes at least one sprint regardless of what the model returns.
+ */
+export function clampMaxSprints(raw) {
+    const n = typeof raw === "number" ? raw : Number(raw);
+    if (!Number.isFinite(n) || n < 1)
+        return 1;
+    return Math.min(20, Math.round(n));
+}
 export function normalizePhasePlan(plan) {
     if (Array.isArray(plan?.phases)) {
         for (const phase of plan.phases) {
             phase.id = normalizePhaseRef(phase.id);
             phase.dependsOn = Array.isArray(phase.dependsOn) ? phase.dependsOn.map(normalizePhaseRef) : [];
+            phase.maxSprints = clampMaxSprints(phase.maxSprints);
         }
     }
     return plan;
@@ -133,7 +163,15 @@ function buildPhasePlannerPrompt(args) {
         `Scope: ${args.clarifiedSpec.scope}`,
         `SuccessCriteria (return these verbatim, distributed across 3-5 phases):`,
         ...args.clarifiedSpec.successCriteria.map((c, i) => `  ${i + 1}. ${c}`),
-        `MaxSprints budget: ${args.manifest.maxSprints} (divide across phases).`,
+        // maxSprints is PO-decided PER PHASE from that phase's difficulty (see the
+        // system prompt) — NOT a global budget to divide. The user's --max-sprints is
+        // only a SOFT guide for overall ambition, never an arithmetic cap the planner
+        // must partition. Each phase's "maxSprints" MUST be a whole integer >= 1.
+        `Sprint sizing: decide each phase's "maxSprints" from its own difficulty/scope/risk — a whole ` +
+            `integer >= 1, more for harder phases. The user suggested roughly ${args.manifest.maxSprints} ` +
+            `sprint(s) total as a soft guide to overall ambition; you may use fewer if the work is simple ` +
+            `or allocate more per phase if the work genuinely needs it. Do not divide it evenly and do not ` +
+            `treat it as a hard budget.`,
         `Output JSON shape: { version:1, generatedAt:<ISO>, phases:[{id,name,goal,successCriteria,scope,exitCondition:{type:"criteria-threshold",min:${args.manifest.doneThreshold}},dependsOn,maxSprints}] }`,
     ].join("\n");
 }

package/dist/src/product-loop/phase-rituals.d.ts

@@ -6,6 +6,9 @@ export interface SprintState {
     scoreAfter: number;
     criteriaMet: number;
     totalCriteria: number;
+    /** Verify verdict for this sprint (PASS/FAIL/ERROR) — grounds the review so it
+     * describes what actually happened instead of confabulating an agile narrative. */
+    verifyVerdict?: string;
 }
 export declare function generateSprintReview(args: {
     sprintState: SprintState;

package/dist/src/product-loop/phase-rituals.js

@@ -15,9 +15,14 @@ export async function generateSprintReview(args) {
     if (args.remainingUsd < reviewFloor(args.capUsd)) {
         return { summary: deterministicReview(args.sprintState), usedFallback: true };
     }
-    const prompt = `Sprint ${args.sprintState.sprintN} of phase ${args.phase.id}: score ${args.sprintState.scoreBefore.toFixed(2)} → ${args.sprintState.scoreAfter.toFixed(2)}, ` +
-        `met ${args.sprintState.criteriaMet}/${args.sprintState.totalCriteria} criteria. ` +
-        `Write a ≤500-char demo summary for the customer.`;
+    const s = args.sprintState;
+    const verifyLine = s.verifyVerdict ? ` Verify: ${s.verifyVerdict}.` : "";
+    const goal = args.phase.goal ? ` Phase goal: ${args.phase.goal}.` : "";
+    const prompt = `Sprint ${s.sprintN} of phase ${args.phase.id}: score ${s.scoreBefore.toFixed(2)} → ${s.scoreAfter.toFixed(2)}, ` +
+        `met ${s.criteriaMet}/${s.totalCriteria} acceptance criteria.${verifyLine}${goal} ` +
+        `Write a ≤500-char demo summary describing ONLY what these numbers show — the concrete progress on criteria and verify status. ` +
+        `Do NOT invent activities (e.g. "team alignment", "environment setup") that the metrics do not evidence. ` +
+        `If 0/${s.totalCriteria} criteria are met, say plainly that no criteria passed yet and why (verify status), not that setup was done.`;
     try {
         const res = await withRateLimitBackoff(() => args.leader.generate({ system: "You write concise sprint demo summaries.", prompt, maxTokens: 250 }), { delays: args.backoffDelays });
         return { summary: res.content.trim().slice(0, 500), usedFallback: false };

package/dist/src/product-loop/phase-runner.js

@@ -313,7 +313,11 @@ export async function* runPhases(args) {
             lastSprintState = sprintResult;
             totalSprints += 1;
             const review = await generateSprintReview({
-                sprintState: { sprintN, ...sprintResult },
+                sprintState: {
+                    sprintN,
+                    ...sprintResult,
+                    verifyVerdict: sprintResult.lastVerifyResult,
+                },
                 phase,
                 leader: args.leader,
                 capUsd: args.capUsd,
@@ -323,15 +327,29 @@ export async function* runPhases(args) {
             if (!args.suppressPush) {
                 yield { type: "push_notification", content: review.summary };
             }
-            await markAwaitingCustomerReview(args.flowDir, args.runId, phase.id, sprintN);
-            const verdict = await args.awaitCustomerVerdict({
-                flowDir: args.flowDir,
-                runId: args.runId,
-                phaseId: phase.id,
-                sprintN,
-                reviewSummary: review.summary,
-            });
-            await clearAwaitingCustomerReview(args.flowDir, args.runId, phase.id, sprintN);
+            // Autonomy fix: by default /ideal advances between sprints WITHOUT a blocking
+            // human verdict (previously the loop parked in discordAwaitVerdict's poll and
+            // never reached sprint 2 unless a human replied). Set
+            // MUONROI_IDEAL_REQUIRE_VERDICT=1 to restore the human customer-review gate.
+            const requireVerdict = process.env.MUONROI_IDEAL_REQUIRE_VERDICT === "1";
+            let verdict;
+            if (requireVerdict) {
+                await markAwaitingCustomerReview(args.flowDir, args.runId, phase.id, sprintN);
+                verdict = await args.awaitCustomerVerdict({
+                    flowDir: args.flowDir,
+                    runId: args.runId,
+                    phaseId: phase.id,
+                    sprintN,
+                    reviewSummary: review.summary,
+                });
+                await clearAwaitingCustomerReview(args.flowDir, args.runId, phase.id, sprintN);
+            }
+            else {
+                verdict = {
+                    verdict: "accept",
+                    feedback: "[auto-advance: autonomous mode (MUONROI_IDEAL_REQUIRE_VERDICT unset)]",
+                };
+            }
             await appendCustomerDecision(args.flowDir, args.runId, {
                 phaseId: phase.id,
                 sprintN,
@@ -360,7 +378,8 @@ export async function* runPhases(args) {
                 // retro skipped
             }
             await clearRetroPending(args.flowDir, args.runId, phase.id, sprintN);
-            const phaseRatio = sprintResult.criteriaMet / Math.max(1, sprintResult.totalCriteria);
+            const phaseTotal = sprintResult.totalCriteria ?? phase.successCriteria.length;
+            const phaseRatio = sprintResult.criteriaMet / Math.max(1, phaseTotal);
             if (phaseRatio >= phase.exitCondition.min)
                 break;
         }

package/dist/src/product-loop/plan-adherence-review.d.ts

@@ -0,0 +1,26 @@
+import type { StreamChunk, TaskRequest, ToolResult } from "../types/index.js";
+/**
+ * Plan-adherence review gate (requested 2026-07-12): after implementation, spawn a
+ * HIGH-TIER reviewer agent to check the actual diff against the approved plan
+ * (file_edits + acceptance_criteria). When it finds deviations, hand a concrete fix
+ * task to a LOWER-TIER agent and re-review. Bounded rounds; never halts the sprint
+ * (verify + the criteria done-gate remain the hard gates). This catches the Sprint-1
+ * failure mode where a cheap implementer received a rich plan but diverged (wrong
+ * LSP op, stub tools) with nothing to notice.
+ */
+export interface AdherenceVerdict {
+    rounds: number;
+    adherent: boolean;
+    deviations: string[];
+}
+export declare function runPlanAdherenceReview(args: {
+    sprintN: number;
+    planSynthesis: string;
+    cwd: string;
+    reviewModelId: string;
+    fixModelId: string;
+    runIsolatedTask: (req: TaskRequest) => Promise<ToolResult>;
+    maxRounds?: number;
+    /** Injectable for tests; defaults to `git diff HEAD` in cwd. */
+    diffProvider?: (cwd: string) => string;
+}): AsyncGenerator<StreamChunk, AdherenceVerdict, unknown>;