muonroi-cli 1.2.3 → 1.3.2

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

@@ -0,0 +1,1154 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { resolveLeaderModel } from "../council/leader.js";
+import { routeModel as eeRouteModel } from "../ee/bridge.js";
+import { fireAndForgetPhaseOutcome } from "../ee/phase-outcome.js";
+import { readArtifact } from "../flow/artifact-io.js";
+import { createRun, loadRun } from "../flow/run-manager.js";
+import { getModelsForProvider } from "../models/registry.js";
+import { loadKeyForProvider } from "../providers/keychain.js";
+import { ALL_PROVIDER_IDS } from "../providers/types.js";
+import { logInteraction, logUIInteraction } from "../storage/index.js";
+import { markIterationCrashed, readIterations, readManifest, writeManifest } from "./artifact-io.js";
+import { formatCostPreview, previewRunCost } from "./cost-preview.js";
+import { extractRunToEE } from "./cross-run-memory.js";
+import { buildContinueFeedback } from "./feedback-routing.js";
+import { runLoopDriver } from "./loop-driver.js";
+import { resolveRoles } from "./role-registry.js";
+import { polishDelivery } from "./ship-polish.js";
+import { runSprint } from "./sprint-runner.js";
+/**
+ * Entry point for the Product Ideal Loop.
+ *
+ * Subcommands:
+ *  - start (default): create run → drive FSM → run sprints → done | halted
+ *  - status:  list runs (or detail one when runId provided)
+ *  - resume:  re-enter the FSM from state.md, marking any in-flight sprint as crashed
+ *  - abort:   write manifest aborted=true and post EE phase-outcome=aborted
+ *  - ship:    skip Cond #1-#4 if already passing; force final user gate (Cond #5)
+ */
+export async function* runProductLoop(opts) {
+    const sub = opts.subcommand ?? "start";
+    switch (sub) {
+        case "status":
+            return yield* runStatus(opts);
+        case "resume":
+            return yield* runResume(opts);
+        case "abort":
+            return yield* runAbort(opts);
+        case "ship":
+            return yield* runShip(opts);
+        default: {
+            // Sufficiency gate: if Layer 1 flagged missing context dimensions
+            // (scope/target/intent), Council MUST run so AskCard can fill them
+            // in before any scaffolding. Hot-path is for context-complete prompts
+            // only (e.g. "fix typo in foo.ts:42"), not for vague briefs like
+            // "todo app" — those are exactly when an Agile team would discover.
+            const hasGaps = !!(opts.sufficiencyMissing && opts.sufficiencyMissing.length > 0);
+            if (hasGaps) {
+                const forcedOpts = {
+                    ...opts,
+                    flags: { ...opts.flags, forceCouncil: true },
+                };
+                return yield* runStart(forcedOpts);
+            }
+            if (opts.complexity === "low" && !opts.flags.forceCouncil) {
+                return yield* runHotPath(opts);
+            }
+            return yield* runStart(opts);
+        }
+    }
+}
+/**
+ * P2.5 — Hot-path for complexity=low ideas.
+ *
+ * Skips Council debate + scoping. Goes straight from idea → single sprint → ship.
+ * extractRunToEE still fires so cross-run memory continues to build.
+ */
+async function* runHotPath(opts) {
+    const { idea, flowDir, flags } = opts;
+    if (!idea?.trim()) {
+        yield { type: "content", content: "error: /ideal start requires an idea" };
+        return { runId: "", stage: "error", success: false, reason: "missing_idea" };
+    }
+    const runState = await createRun(flowDir);
+    const runId = runState.id;
+    await writeManifest(flowDir, runId, {
+        idea,
+        capUsd: flags.maxCost,
+        maxSprints: 1, // hot-path always caps at 1 sprint
+        doneThreshold: flags.doneThreshold,
+        stack: flags.stack,
+        createdAt: new Date(),
+    });
+    yield {
+        type: "content",
+        content: "\n> hot-path: complexity=low → single sprint, no council debate\n",
+    };
+    // Emit route-decision harness event (agent-mode only; no-op otherwise).
+    try {
+        const _ar = globalThis.__muonroiAgentRuntime;
+        _ar?.emitEvent({
+            t: "event",
+            kind: "route-decision",
+            path: "hot-path",
+            complexity: opts.complexity ?? "low",
+            forceCouncil: false,
+            runId,
+        });
+    }
+    catch {
+        /* best-effort */
+    }
+    // Telemetry: log routing decision.
+    try {
+        logInteraction(opts.sessionId ?? runId, "routing", {
+            eventSubtype: "ideal_hot_path",
+            data: { complexity: "low", forceCouncil: false },
+        });
+    }
+    catch {
+        // DB errors must not break /ideal
+    }
+    logUIInteraction(opts.sessionId, {
+        subtype: "route_decision",
+        data: { path: "hot-path", complexity: opts.complexity ?? "low", forceCouncil: false, runId },
+    });
+    try {
+        const _ar = globalThis.__muonroiAgentRuntime;
+        _ar?.emitEvent({
+            t: "event",
+            kind: "sprint-plan-committed",
+            runId,
+            projectDir: opts.cwd ?? null,
+            sprintCount: 1,
+            sprintIds: ["sprint-1"],
+            source: "auto",
+            ts: Date.now(),
+        });
+    }
+    catch {
+        /* best-effort */
+    }
+    // Build a minimal ProductSpec inline (no LLM calls needed for the hot-path).
+    const productSpec = {
+        idea,
+        persona: "users",
+        mvp: [],
+        phase2: [],
+        architecture: "",
+        ioContract: "",
+        folderStructure: "",
+        sprintEstimate: 1,
+        costEstimate: 1,
+        stack: flags.stack,
+        createdAt: new Date(),
+    };
+    const ctx = {
+        runId,
+        flowDir,
+        idea,
+        sessionModelId: opts.sessionModelId,
+        llm: opts.llm,
+        flags,
+        respondToQuestion: opts.respondToQuestion,
+        respondToPreflight: opts.respondToPreflight,
+        cwd: opts.cwd,
+        sessionId: opts.sessionId,
+        processMessageFn: opts.processMessageFn,
+        detectVerifyRecipe: opts.detectVerifyRecipe,
+        skipPriorContext: opts.skipPriorContext,
+        sufficiencyMissing: opts.sufficiencyMissing,
+    };
+    const roleAssignments = opts.roleAssignments ?? (await resolveRoleAssignments(opts.sessionModelId));
+    // Run a single sprint (maxSprints=1 enforced regardless of opts.flags.maxSprints).
+    let iter;
+    try {
+        const sprintGen = runSprint({
+            sprintN: 1,
+            ctx,
+            productSpec,
+            roleAssignments,
+            history: [],
+        });
+        let result;
+        while (true) {
+            const step = await sprintGen.next();
+            if (step.done) {
+                result = step.value;
+                break;
+            }
+            // Site 1 — forward halt chunk to UI, mark stage halted, stop iteration.
+            if (step.value && step.value.type === "halt") {
+                yield step.value;
+                const manifest = await readManifest(flowDir, runId);
+                const haltReason = step.value.haltChunk?.reason ?? "no_recipe";
+                if (manifest) {
+                    await writeManifest(flowDir, runId, {
+                        ...manifest,
+                        verdict: { pass: false, score: 0, reason: haltReason, failedCondition: undefined },
+                    });
+                }
+                return { runId, stage: "halted", success: false, reason: haltReason, sprintsRun: 0 };
+            }
+            yield step.value;
+        }
+        iter = result;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        yield { type: "content", content: `\n> Sprint 1 halted: ${msg}\n` };
+        const manifest = await readManifest(flowDir, runId);
+        if (manifest) {
+            await writeManifest(flowDir, runId, {
+                ...manifest,
+                verdict: { pass: false, score: 0, reason: msg, failedCondition: undefined },
+            });
+        }
+        return { runId, stage: "halted", success: false, reason: msg, sprintsRun: 0 };
+    }
+    if (iter.stage !== "shipped") {
+        return {
+            runId,
+            stage: "halted",
+            success: false,
+            reason: iter.lastVerifyResult ?? "sprint_not_shipped",
+            sprintsRun: 1,
+        };
+    }
+    // Sprint shipped — write final manifest.
+    const manifest = await readManifest(flowDir, runId);
+    if (manifest) {
+        await writeManifest(flowDir, runId, {
+            ...manifest,
+            doneAt: new Date(),
+            verdict: {
+                pass: true,
+                score: iter.scoreAfter,
+                failedCondition: undefined,
+                reason: "all_conditions_met",
+            },
+        });
+    }
+    // Delivery polish.
+    if (opts.cwd) {
+        try {
+            const polish = await polishDelivery({
+                cwd: opts.cwd,
+                runDir: path.join(flowDir, "runs", runId),
+                productSpec,
+                runId,
+            });
+            if (polish.notes.length > 0) {
+                yield {
+                    type: "content",
+                    content: `\n**Delivery polish:**\n${polish.notes.map((n) => `- ${n}`).join("\n")}\n`,
+                };
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            yield { type: "content", content: `\n_Delivery polish skipped: ${msg}_\n` };
+        }
+    }
+    // P1.3: extract run artifacts to EE for cross-run memory.
+    if (opts.cwd) {
+        const eeResult = await extractRunToEE(flowDir, runId, opts.cwd);
+        try {
+            logInteraction(opts.sessionId ?? runId, "ee_injection", {
+                eventSubtype: "extract",
+                durationMs: Math.round(eeResult.durationMs),
+                data: {
+                    ok: eeResult.ok,
+                    mistakes: eeResult.mistakes ?? null,
+                    stored: eeResult.stored ?? null,
+                },
+            });
+        }
+        catch {
+            // DB errors must not break /ideal
+        }
+    }
+    return { runId, stage: "approved", success: true, reason: "shipped", sprintsRun: 1, shipped: true };
+}
+/** start: createRun → loop-driver (gather/research/scoping) → sprint loop → done|halted. */
+async function* runStart(opts) {
+    const { idea, flowDir, llm, flags, respondToQuestion, respondToPreflight } = opts;
+    if (!idea || !idea.trim()) {
+        yield { type: "content", content: "error: /ideal start requires an idea" };
+        return { runId: "", stage: "error", success: false, reason: "missing_idea" };
+    }
+    const runState = await createRun(flowDir);
+    const runId = runState.id;
+    await writeManifest(flowDir, runId, {
+        idea,
+        capUsd: flags.maxCost,
+        maxSprints: flags.maxSprints,
+        doneThreshold: flags.doneThreshold,
+        stack: flags.stack,
+        createdAt: new Date(),
+    });
+    // Surface a cost-vs-cap preview before the loop kicks off so $50 isn't
+    // an arbitrary number — show predicted spend per sprint × max-sprints
+    // against the configured cap, with a recommended max-sprints if it
+    // would exceed. Falls back gracefully for unknown-pricing models.
+    const preview = previewRunCost({
+        sessionModelId: opts.sessionModelId,
+        maxSprints: flags.maxSprints,
+        capUsd: flags.maxCost,
+    });
+    yield { type: "content", content: `\n${formatCostPreview(preview)}\n` };
+    // Emit route-decision harness event (agent-mode only; no-op otherwise).
+    try {
+        const _ar = globalThis.__muonroiAgentRuntime;
+        _ar?.emitEvent({
+            t: "event",
+            kind: "route-decision",
+            path: "council",
+            complexity: opts.complexity ?? "unknown",
+            forceCouncil: !!opts.flags.forceCouncil,
+            sufficiencyMissing: opts.sufficiencyMissing ?? [],
+            runId,
+        });
+    }
+    catch {
+        /* best-effort */
+    }
+    logUIInteraction(opts.sessionId, {
+        subtype: "route_decision",
+        data: {
+            path: "council",
+            complexity: opts.complexity ?? "unknown",
+            forceCouncil: !!opts.flags.forceCouncil,
+            sufficiencyMissing: opts.sufficiencyMissing ?? [],
+            runId,
+        },
+    });
+    const ctx = {
+        runId,
+        flowDir,
+        idea,
+        sessionModelId: opts.sessionModelId,
+        llm,
+        flags,
+        respondToQuestion,
+        respondToPreflight,
+        cwd: opts.cwd,
+        sessionId: opts.sessionId,
+        processMessageFn: opts.processMessageFn,
+        detectVerifyRecipe: opts.detectVerifyRecipe,
+        skipPriorContext: opts.skipPriorContext,
+        sufficiencyMissing: opts.sufficiencyMissing,
+    };
+    // Phase 1: outer FSM (gather → research → scoping → approved | halted).
+    const driverGen = runLoopDriver(ctx);
+    let driverResult;
+    try {
+        while (true) {
+            const { value, done } = await driverGen.next();
+            if (done) {
+                driverResult = value;
+                break;
+            }
+            yield value;
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        // Persist the halt/crash so forensics can surface it via `usage forensics`.
+        // Circuit-breaker rejections (CB-1 cost-projection in sprint-runner) are
+        // the common case — they previously vanished into the TUI scrollback only.
+        try {
+            const sid = opts.sessionId ?? runId;
+            const isCB = msg.startsWith("Halted by circuit breaker");
+            logInteraction(sid, "council", {
+                eventSubtype: isCB ? "sprint_halt" : "loop_error",
+                data: {
+                    runId,
+                    stage: "driver",
+                    reason: msg.slice(0, 2000),
+                    isCircuitBreaker: isCB,
+                },
+            });
+        }
+        catch {
+            /* best-effort */
+        }
+        yield { type: "error", error: true, content: msg };
+        return { runId, stage: "error", success: false, reason: msg };
+    }
+    if (!driverResult?.success || driverResult.stage !== "approved") {
+        return { ...driverResult, runId };
+    }
+    // Phase 2: sprint loop until done or halted.
+    const productSpec = await loadProductSpec(flowDir, runId, idea, opts.flags.stack);
+    const roleAssignments = opts.roleAssignments ?? (await resolveRoleAssignments(opts.sessionModelId));
+    try {
+        const _ar = globalThis.__muonroiAgentRuntime;
+        const sprintCount = flags.maxSprints;
+        const sprintIds = Array.from({ length: sprintCount }, (_, i) => `sprint-${i + 1}`);
+        _ar?.emitEvent({
+            t: "event",
+            kind: "sprint-plan-committed",
+            runId,
+            projectDir: opts.cwd ?? null,
+            sprintCount,
+            sprintIds,
+            source: "council",
+            ts: Date.now(),
+        });
+    }
+    catch {
+        /* best-effort */
+    }
+    // Subsystem E: phase-orchestrated path (default ON; set MUONROI_PHASE_MODE=0 for legacy).
+    if (process.env.MUONROI_PHASE_MODE !== "0") {
+        const phaseResult = yield* runPhasesPath({ ctx, productSpec, roleAssignments });
+        if (phaseResult !== null)
+            return phaseResult;
+        // phaseResult === null means runPhases prerequisites were unavailable; fall through to legacy.
+    }
+    return yield* drainSprints({
+        ctx,
+        productSpec,
+        roleAssignments,
+        history: [],
+        flags,
+    });
+}
+/** Drive sprint-runner repeatedly, honoring max-sprints and continue-feedback routing. */
+async function* drainSprints(args) {
+    const { ctx, productSpec, roleAssignments, flags } = args;
+    const history = args.history.slice();
+    let carryOver;
+    let sprintsRun = 0;
+    for (let sprintN = history.length + 1; sprintN <= flags.maxSprints; sprintN++) {
+        let iter;
+        try {
+            const sprintGen = runSprint({
+                sprintN,
+                ctx,
+                productSpec,
+                roleAssignments,
+                history,
+                carryOver,
+            });
+            let result;
+            while (true) {
+                const step = await sprintGen.next();
+                if (step.done) {
+                    result = step.value;
+                    break;
+                }
+                // Site 2 — forward halt chunk to UI, mark stage halted, stop iteration.
+                if (step.value && step.value.type === "halt") {
+                    yield step.value;
+                    const haltReason = step.value.haltChunk?.reason ?? "no_recipe";
+                    const manifest = await readManifest(ctx.flowDir, ctx.runId);
+                    if (manifest) {
+                        await writeManifest(ctx.flowDir, ctx.runId, {
+                            ...manifest,
+                            verdict: { pass: false, score: 0, reason: haltReason, failedCondition: undefined },
+                        });
+                    }
+                    return {
+                        runId: ctx.runId,
+                        stage: "halted",
+                        success: false,
+                        reason: haltReason,
+                        sprintsRun,
+                    };
+                }
+                yield step.value;
+            }
+            iter = result;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            yield { type: "content", content: `\n> Sprint ${sprintN} halted: ${msg}\n` };
+            // Persist the sprint halt so forensics replay surfaces it. CB-1 cost
+            // projection breaches (`Halted by circuit breaker: …`) are by far the
+            // common case and they previously vanished into TUI scrollback only.
+            try {
+                const sid = ctx.sessionId ?? ctx.runId;
+                const isCB = msg.startsWith("Halted by circuit breaker");
+                logInteraction(sid, "council", {
+                    eventSubtype: "sprint_halt",
+                    data: {
+                        runId: ctx.runId,
+                        sprintN,
+                        stage: "sprint",
+                        reason: msg.slice(0, 2000),
+                        isCircuitBreaker: isCB,
+                        sprintsRun,
+                    },
+                });
+            }
+            catch {
+                /* best-effort */
+            }
+            // Mark manifest as halted (not aborted) so resume can pick up.
+            const manifest = await readManifest(ctx.flowDir, ctx.runId);
+            if (manifest) {
+                await writeManifest(ctx.flowDir, ctx.runId, {
+                    ...manifest,
+                    verdict: { pass: false, score: 0, reason: msg, failedCondition: undefined },
+                });
+            }
+            return {
+                runId: ctx.runId,
+                stage: "halted",
+                success: false,
+                reason: msg,
+                sprintsRun,
+            };
+        }
+        history.push(iter);
+        sprintsRun++;
+        if (iter.stage === "shipped") {
+            // Final manifest update + EE pass outcome
+            const manifest = await readManifest(ctx.flowDir, ctx.runId);
+            if (manifest) {
+                await writeManifest(ctx.flowDir, ctx.runId, {
+                    ...manifest,
+                    doneAt: new Date(),
+                    verdict: {
+                        pass: true,
+                        score: iter.scoreAfter,
+                        failedCondition: undefined,
+                        reason: "all_conditions_met",
+                    },
+                });
+            }
+            // Ship-time delivery polish: scaffold README, fill package.json
+            // metadata, write delivery-notes. Idempotent + non-destructive.
+            if (ctx.cwd) {
+                try {
+                    const polish = await polishDelivery({
+                        cwd: ctx.cwd,
+                        runDir: path.join(ctx.flowDir, "runs", ctx.runId),
+                        productSpec,
+                        runId: ctx.runId,
+                    });
+                    if (polish.notes.length > 0) {
+                        yield {
+                            type: "content",
+                            content: `\n**Delivery polish:**\n${polish.notes.map((n) => `- ${n}`).join("\n")}\n`,
+                        };
+                    }
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    yield { type: "content", content: `\n_Delivery polish skipped: ${msg}_\n` };
+                }
+            }
+            // P1.3: extract run artifacts to EE for cross-run memory. Non-fatal —
+            // EE client absorbs failures into the offline queue.
+            // P1.6: log telemetry for the extract outcome.
+            if (ctx.cwd) {
+                const eeResult = await extractRunToEE(ctx.flowDir, ctx.runId, ctx.cwd);
+                try {
+                    logInteraction(ctx.sessionId ?? ctx.runId, "ee_injection", {
+                        eventSubtype: "extract",
+                        durationMs: Math.round(eeResult.durationMs),
+                        data: {
+                            ok: eeResult.ok,
+                            mistakes: eeResult.mistakes ?? null,
+                            stored: eeResult.stored ?? null,
+                        },
+                    });
+                }
+                catch {
+                    // DB errors must not break /ideal
+                }
+            }
+            return {
+                runId: ctx.runId,
+                stage: "approved",
+                success: true,
+                reason: "shipped",
+                sprintsRun,
+                shipped: true,
+            };
+        }
+        // Build continue-feedback for next iteration. The DoneVerdict is not
+        // surfaced from sprint-runner directly, but the iteration state encodes
+        // enough — derive a synthetic verdict from criteria counts.
+        carryOver = {
+            focus: iter.lastVerifyResult === "PASS"
+                ? `improve criteria coverage: met=${iter.criteriaMet}, partial=${iter.criteriaPartial}, unmet=${iter.criteriaUnmet}`
+                : `fix verify failures (last result: ${iter.lastVerifyResult})`,
+        };
+    }
+    yield {
+        type: "content",
+        content: `\n> Reached max-sprints (${flags.maxSprints}) without satisfying Definition-of-Done.\n`,
+    };
+    return {
+        runId: ctx.runId,
+        stage: "halted",
+        success: false,
+        reason: "max_sprints_reached",
+        sprintsRun,
+    };
+}
+function chatEnvConfig() {
+    // Lazy load to avoid circular imports
+    const { readChatProvider } = require("../chat/factory.js");
+    const client = readChatProvider();
+    return client ? { client } : null;
+}
+/**
+ * Phase-orchestrated sprint path (Subsystem E).
+ *
+ * Returns a ProductLoopResult when it ran to completion (pass or abort),
+ * or null when prerequisites were unavailable (no projectContext) so the
+ * caller can fall through to the legacy drainSprints path.
+ *
+ * Gated behind MUONROI_PHASE_MODE !== "0" by both callers (runStart / runResume).
+ */
+async function* runPhasesPath(args) {
+    const { ctx, productSpec, roleAssignments } = args;
+    // Load prerequisites: projectContext and manifest.
+    const { readProjectContext } = await import("./discovery-persistence.js");
+    const { getProductSpentUsd } = await import("../usage/product-ledger.js");
+    const { runPhases } = await import("./phase-runner.js");
+    const projectContext = await readProjectContext(ctx.flowDir, ctx.runId);
+    const manifest = await readManifest(ctx.flowDir, ctx.runId);
+    if (!projectContext || !manifest) {
+        // Prerequisites unavailable — signal fall-through to legacy path.
+        yield {
+            type: "content",
+            content: "\n> [phase-mode] projectContext or manifest unavailable — falling back to legacy sprint loop.\n",
+        };
+        return null;
+    }
+    // Build a ClarifiedSpec from the stored projectContext.
+    const { clarifiedSpecFromContext } = await import("./gather.js");
+    const clarifiedSpec = clarifiedSpecFromContext(projectContext);
+    // Resolve leader model id and build a LeaderLike adapter over ctx.llm.
+    const leaderModelId = resolveLeaderModel(ctx.sessionModelId);
+    const leader = {
+        generate: (leaderArgs) => ctx.llm.generate(leaderModelId, leaderArgs.system, leaderArgs.prompt).then((text) => ({
+            content: text,
+            costUsd: 0,
+        })),
+    };
+    // Build the sprintRunner adapter: runPhases passes { sprintN, phaseId, conversationContext, phaseScope }
+    // while runSprint expects the full RunSprintArgs shape.
+    // History is accumulated per-phase so circuit-breaker CB-2 (oscillation detection)
+    // and carry-over between sprints within a phase work correctly.
+    let currentPhaseId = null;
+    let sprintHistory = [];
+    const sprintRunner = async function* (sprintCtx) {
+        const sc = sprintCtx;
+        // Reset history when a new phase begins.
+        if ((sc.phaseId ?? null) !== currentPhaseId) {
+            currentPhaseId = sc.phaseId ?? null;
+            sprintHistory = [];
+        }
+        const inner = runSprint({
+            sprintN: sc.sprintN,
+            ctx,
+            productSpec,
+            roleAssignments,
+            history: [...sprintHistory],
+            phaseScope: sc.phaseScope,
+        });
+        let result;
+        while (true) {
+            const n = await inner.next();
+            if (n.done) {
+                result = n.value;
+                break;
+            }
+            // Site 3 — no try/catch here; without explicit halt handling the generator
+            // returns normally and the phase orchestrator treats it as a completed sprint.
+            // Forward the halt chunk upstream so runPhases can surface it to the user.
+            if (n.value && n.value.type === "halt") {
+                yield n.value;
+                // Return a sentinel IterationState so the phase runner records a halted stage.
+                return {
+                    sprintN: sc.sprintN,
+                    stage: "halted",
+                    scoreBefore: 0,
+                    scoreAfter: 0,
+                    criteriaMet: 0,
+                    criteriaPartial: 0,
+                    criteriaUnmet: 0,
+                    costUsd: 0,
+                    lastVerifyResult: n.value.reason ?? "no_recipe",
+                };
+            }
+            yield n.value;
+        }
+        // Accumulate completed sprint into history for subsequent sprints in this phase.
+        if (result && typeof result === "object" && "criteriaMet" in result) {
+            sprintHistory.push(result);
+        }
+        return result;
+    };
+    // Chat setup (opt-in via env vars; no-op when unset).
+    const chatCfg = chatEnvConfig();
+    let chatClient = null;
+    let slug = null;
+    if (chatCfg) {
+        chatClient = chatCfg.client;
+        const { productSlug } = await import("./product-identity.js");
+        slug = productSlug(manifest.idea);
+    }
+    // Terminal fallback: use respondToQuestion (the existing user-prompt API).
+    // QuestionResponder takes a questionId string; the UI layer resolves the prompt text.
+    const terminalFallback = async () => {
+        const ans = await ctx.respondToQuestion("customer-review-verdict");
+        const lower = (ans ?? "").trim().toLowerCase();
+        if (lower.startsWith("x"))
+            return { verdict: "abort" };
+        if (lower.startsWith("r")) {
+            const fb = await ctx.respondToQuestion("customer-review-feedback");
+            return { verdict: "reject", feedback: fb ?? "" };
+        }
+        return { verdict: "accept" };
+    };
+    const awaitCustomerVerdict = async (verdictArgs) => {
+        if (!chatClient || !slug)
+            return terminalFallback();
+        const { ensureChannel } = await import("../chat/channel-manager.js");
+        const { discordAwaitVerdict } = await import("../chat/verdict-resolver.js");
+        const ch = await ensureChannel({
+            client: chatClient,
+            guildId: process.env.MUONROI_DISCORD_GUILD_ID ?? "unknown",
+            slug,
+            displayName: manifest.idea,
+        });
+        if (!ch)
+            return terminalFallback();
+        return discordAwaitVerdict({
+            flowDir: verdictArgs.flowDir,
+            runId: verdictArgs.runId,
+            phaseId: verdictArgs.phaseId,
+            sprintN: verdictArgs.sprintN,
+            productSlug: slug,
+            channelId: ch.channelId,
+            client: chatClient,
+            leader,
+            capUsd: manifest.capUsd,
+            remainingUsd: async () => {
+                const { getProductSpentUsd } = await import("../usage/product-ledger.js");
+                const spent = await getProductSpentUsd(verdictArgs.runId);
+                return Math.max(0, manifest.capUsd - spent);
+            },
+            reviewSummary: verdictArgs.reviewSummary,
+            fallback: terminalFallback,
+        });
+    };
+    const phaseGen = runPhases({
+        flowDir: ctx.flowDir,
+        runId: ctx.runId,
+        manifest,
+        clarifiedSpec,
+        projectContext,
+        leader: leader,
+        leaderModelId,
+        capUsd: manifest.capUsd,
+        remainingUsd: async () => Math.max(0, manifest.capUsd - (await getProductSpentUsd(ctx.runId))),
+        awaitCustomerVerdict,
+        sprintRunner,
+    });
+    let phaseOutcome = { pass: false };
+    while (true) {
+        const step = await phaseGen.next();
+        if (step.done) {
+            phaseOutcome = step.value;
+            break;
+        }
+        const chunk = step.value;
+        if (chunk.type === "push_notification" && chatClient && slug) {
+            try {
+                const { ensureChannel } = await import("../chat/channel-manager.js");
+                const { publish } = await import("../chat/broadcast-bus.js");
+                const ch = await ensureChannel({
+                    client: chatClient,
+                    guildId: process.env.MUONROI_DISCORD_GUILD_ID ?? "unknown",
+                    slug,
+                    displayName: manifest.idea,
+                });
+                if (ch) {
+                    await publish({
+                        client: chatClient,
+                        channelId: ch.channelId,
+                        type: "phase-event",
+                        content: chunk.content ?? "",
+                    });
+                }
+            }
+            catch (e) {
+                console.warn("muonroi: chat broadcast failed", e);
+            }
+        }
+        yield chunk;
+    }
+    if (!phaseOutcome.pass) {
+        return {
+            runId: ctx.runId,
+            stage: "halted",
+            success: false,
+            reason: phaseOutcome.reason ?? "phase-orchestrator-halt",
+        };
+    }
+    // All phases done — write final manifest.
+    const finalManifest = await readManifest(ctx.flowDir, ctx.runId);
+    if (finalManifest) {
+        await writeManifest(ctx.flowDir, ctx.runId, {
+            ...finalManifest,
+            doneAt: new Date(),
+            verdict: { pass: true, score: 1, failedCondition: undefined, reason: "phases_complete" },
+        });
+    }
+    // P1.3: extract run artifacts to EE for cross-run memory. Non-fatal —
+    // EE client absorbs failures into the offline queue.
+    // P1.6: log telemetry for the extract outcome.
+    if (ctx.cwd) {
+        const eeResult = await extractRunToEE(ctx.flowDir, ctx.runId, ctx.cwd);
+        try {
+            logInteraction(ctx.sessionId ?? ctx.runId, "ee_injection", {
+                eventSubtype: "extract",
+                durationMs: Math.round(eeResult.durationMs),
+                data: {
+                    ok: eeResult.ok,
+                    mistakes: eeResult.mistakes ?? null,
+                    stored: eeResult.stored ?? null,
+                },
+            });
+        }
+        catch {
+            // DB errors must not break /ideal
+        }
+    }
+    return {
+        runId: ctx.runId,
+        stage: "approved",
+        success: true,
+        reason: "phases_complete",
+        shipped: true,
+    };
+}
+async function loadProductSpec(flowDir, runId, idea, stack) {
+    const runDir = path.join(flowDir, "runs", runId);
+    const roadmap = await readArtifact(runDir, "roadmap.md");
+    const raw = roadmap?.sections.get("Product Specification") ?? "";
+    const match = raw.match(/\{[\s\S]*\}/);
+    if (match) {
+        try {
+            const parsed = JSON.parse(match[0]);
+            return {
+                idea: parsed.idea ?? idea,
+                persona: parsed.persona ?? "users",
+                mvp: parsed.mvp ?? [],
+                phase2: parsed.phase2 ?? [],
+                architecture: parsed.architecture ?? "",
+                ioContract: parsed.ioContract ?? "",
+                folderStructure: parsed.folderStructure ?? "",
+                sprintEstimate: parsed.sprintEstimate ?? 1,
+                costEstimate: parsed.costEstimate ?? 1,
+                stack: parsed.stack ?? stack,
+                createdAt: parsed.createdAt ? new Date(parsed.createdAt) : new Date(),
+            };
+        }
+        catch {
+            /* fall through */
+        }
+    }
+    return {
+        idea,
+        persona: "users",
+        mvp: [],
+        phase2: [],
+        architecture: "",
+        ioContract: "",
+        folderStructure: "",
+        sprintEstimate: 1,
+        costEstimate: 1,
+        stack,
+        createdAt: new Date(),
+    };
+}
+// ── Subcommands: status / resume / abort / ship ─────────────────────────────
+async function* runStatus(opts) {
+    const runsRoot = path.join(opts.flowDir, "runs");
+    let entries = [];
+    try {
+        entries = await fs.readdir(runsRoot);
+    }
+    catch {
+        yield { type: "content", content: "No runs found.\n" };
+        return { runId: "", stage: "approved", success: true };
+    }
+    if (opts.runId) {
+        const m = await readManifest(opts.flowDir, opts.runId);
+        if (!m) {
+            yield { type: "content", content: `Run not found: ${opts.runId}\n` };
+            return { runId: opts.runId, stage: "error", success: false, reason: "not_found" };
+        }
+        const iters = await readIterations(opts.flowDir, opts.runId);
+        yield {
+            type: "content",
+            content: `Run ${opts.runId}: ${m.idea}\n` +
+                `Cap: $${m.capUsd}  MaxSprints: ${m.maxSprints}  DoneThreshold: ${m.doneThreshold}\n` +
+                `Iterations: ${iters.length}  Aborted: ${m.aborted ?? false}  DoneAt: ${m.doneAt?.toISOString() ?? "—"}\n`,
+        };
+        return { runId: opts.runId, stage: "approved", success: true };
+    }
+    const lines = [`Active runs (${entries.length}):`];
+    for (const id of entries) {
+        const m = await readManifest(opts.flowDir, id).catch(() => null);
+        const iters = await readIterations(opts.flowDir, id).catch(() => []);
+        if (!m)
+            continue;
+        lines.push(`  ${id}  ${m.idea.slice(0, 60)}  sprints=${iters.length}  aborted=${m.aborted ?? false}`);
+    }
+    yield { type: "content", content: `${lines.join("\n")}\n` };
+    return { runId: "", stage: "approved", success: true };
+}
+async function* runAbort(opts) {
+    if (!opts.runId) {
+        yield { type: "content", content: "error: abort requires a runId\n" };
+        return { runId: "", stage: "error", success: false, reason: "missing_runId" };
+    }
+    const m = await readManifest(opts.flowDir, opts.runId);
+    if (!m) {
+        yield { type: "content", content: `Run not found: ${opts.runId}\n` };
+        return { runId: opts.runId, stage: "error", success: false, reason: "not_found" };
+    }
+    await writeManifest(opts.flowDir, opts.runId, { ...m, aborted: true, doneAt: new Date() });
+    // Fire-and-forget EE phase-outcome=aborted (extension landed in 13-05).
+    try {
+        fireAndForgetPhaseOutcome({
+            sessionId: opts.runId,
+            phaseName: "product-loop",
+            outcome: "aborted",
+        });
+    }
+    catch {
+        /* non-fatal */
+    }
+    // P1.3: extract run artifacts to EE even on abort — we still want to learn
+    // from partial runs. runAbort does not have a full DriverContext so cwd is
+    // not available here; fall back to process.cwd() as the project path.
+    // EE client is non-fatal (offline queue absorbs transport failures).
+    // P1.6: log telemetry for the extract outcome.
+    {
+        const eeResult = await extractRunToEE(opts.flowDir, opts.runId, opts.cwd ?? process.cwd());
+        try {
+            logInteraction(opts.sessionId ?? opts.runId ?? "abort", "ee_injection", {
+                eventSubtype: "extract",
+                durationMs: Math.round(eeResult.durationMs),
+                data: {
+                    ok: eeResult.ok,
+                    mistakes: eeResult.mistakes ?? null,
+                    stored: eeResult.stored ?? null,
+                },
+            });
+        }
+        catch {
+            // DB errors must not break /ideal
+        }
+    }
+    yield { type: "content", content: `Aborted run ${opts.runId}.\n` };
+    return { runId: opts.runId, stage: "halted", success: false, reason: "aborted" };
+}
+async function* runResume(opts) {
+    if (!opts.runId) {
+        yield { type: "content", content: "error: resume requires a runId\n" };
+        return { runId: "", stage: "error", success: false, reason: "missing_runId" };
+    }
+    const run = await loadRun(opts.flowDir, opts.runId);
+    if (!run) {
+        yield { type: "content", content: `Run not found: ${opts.runId}\n` };
+        return { runId: opts.runId, stage: "error", success: false, reason: "not_found" };
+    }
+    const manifest = await readManifest(opts.flowDir, opts.runId);
+    if (!manifest) {
+        yield { type: "content", content: `Manifest missing for ${opts.runId}\n` };
+        return { runId: opts.runId, stage: "error", success: false, reason: "manifest_missing" };
+    }
+    if (manifest.aborted) {
+        yield { type: "content", content: `Run ${opts.runId} was aborted; cannot resume.\n` };
+        return { runId: opts.runId, stage: "halted", success: false, reason: "aborted" };
+    }
+    // Detect crashed in-flight sprint: an iterations.md entry without a closing
+    // Verify line is treated as crashed. Our schema always writes the Verify line
+    // before returning, so an iteration is "in-flight" iff the file has a Sprint
+    // heading but no matching Verify field. readIterations skips malformed
+    // entries — so we mark the highest sprint number as crashed regardless.
+    const iters = await readIterations(opts.flowDir, opts.runId);
+    let nextSprint = iters.length + 1;
+    if (iters.length > 0) {
+        const last = iters[iters.length - 1];
+        if (!last.lastVerifyResult || last.lastVerifyResult === "UNKNOWN") {
+            await markIterationCrashed(opts.flowDir, opts.runId, last.sprintN);
+            nextSprint = last.sprintN; // retry with retryOf metadata
+            yield {
+                type: "content",
+                content: `Detected crashed sprint ${last.sprintN}; restarting fresh.\n`,
+            };
+        }
+    }
+    // Fire EE phase-outcome=resumed (extension landed in 13-05).
+    try {
+        fireAndForgetPhaseOutcome({
+            sessionId: opts.runId,
+            phaseName: `sprint-${Math.max(1, nextSprint - 1)}`,
+            outcome: "resumed",
+        });
+    }
+    catch {
+        /* non-fatal */
+    }
+    // Resume into sprint loop with reconstructed history + manifest flags.
+    const productSpec = await loadProductSpec(opts.flowDir, opts.runId, manifest.idea, manifest.stack);
+    const ctx = {
+        runId: opts.runId,
+        flowDir: opts.flowDir,
+        idea: manifest.idea,
+        sessionModelId: opts.sessionModelId,
+        llm: opts.llm,
+        flags: opts.flags,
+        respondToQuestion: opts.respondToQuestion,
+        respondToPreflight: opts.respondToPreflight,
+        cwd: opts.cwd,
+        sessionId: opts.sessionId,
+        processMessageFn: opts.processMessageFn,
+        detectVerifyRecipe: opts.detectVerifyRecipe,
+    };
+    const roleAssignments = opts.roleAssignments ?? (await resolveRoleAssignments(opts.sessionModelId));
+    // Subsystem E: phase-orchestrated path (default ON; set MUONROI_PHASE_MODE=0 for legacy).
+    if (process.env.MUONROI_PHASE_MODE !== "0") {
+        const phaseResult = yield* runPhasesPath({ ctx, productSpec, roleAssignments });
+        if (phaseResult !== null)
+            return phaseResult;
+        // phaseResult === null means runPhases prerequisites were unavailable; fall through to legacy.
+    }
+    return yield* drainSprints({
+        ctx,
+        productSpec,
+        roleAssignments,
+        history: iters.filter((i) => !i.crashed),
+        flags: opts.flags,
+    });
+}
+/**
+ * Build the inventory of models reachable in this session (= every provider
+ * that has a key on the keychain) and let role-registry assign one model per
+ * RoleSlot. The resulting Map is consumed by sprint-runner → done-gate Cond #4
+ * (PO ↔ Customer cross-model debate). Without this, the Map is empty and the
+ * gate immediately returns "missing_roles".
+ *
+ * On refusal (no keys, single-provider with too few models, or PO/Customer
+ * collision) we return an empty Map; done-gate's R5 short-circuit (skip Cond
+ * #4 when score < 0.85) keeps early sprints unblocked, and the user-approval
+ * gate (Cond #5) still runs so the loop can ship via /ship.
+ */
+async function resolveRoleAssignments(sessionModelId) {
+    const out = new Map();
+    // Role-assignment inventory scan: intentionally excludes xai for legacy
+    // resolveRoles ranking. Derived from ALL_PROVIDER_IDS so future additions
+    // are picked up automatically.
+    const order = ALL_PROVIDER_IDS.filter((p) => p !== "xai");
+    const inventory = [];
+    for (const p of order) {
+        try {
+            await loadKeyForProvider(p);
+        }
+        catch {
+            continue;
+        }
+        inventory.push(...getModelsForProvider(p));
+    }
+    if (inventory.length === 0)
+        return out;
+    // EE-driven override: ask the experience brain for the best (model,tier)
+    // per role, given accumulated past-performance signals. routeModel returns
+    // null when no EE core is installed, in which case role-registry falls
+    // back to its tier-preference cold-start logic.
+    const eeRouteOverride = async (slot) => {
+        const task = describeRoleTask(slot);
+        try {
+            return await eeRouteModel(task, { role: slot, sessionModel: sessionModelId, source: "product-loop" }, "muonroi-cli");
+        }
+        catch {
+            return null;
+        }
+    };
+    const result = await resolveRoles({ inventory, eeRouteOverride });
+    if (result.kind !== "ok")
+        return out;
+    for (const [slot, a] of Object.entries(result.roles)) {
+        out.set(slot, { modelId: a.model, provider: a.provider, tier: a.tier });
+    }
+    return out;
+}
+/**
+ * Slot → human-readable task description fed to EE's routeModel. The brain
+ * uses this string as the primary classification key, so phrasing matters:
+ * keep it specific to the role's actual deliverable.
+ */
+function describeRoleTask(slot) {
+    switch (slot) {
+        case "PO":
+            return "product owner: clarify product spec and acceptance criteria";
+        case "Architect":
+            return "software architect: design module boundaries and data flow";
+        case "Implementer":
+            return "implementer: write production code from a spec";
+        case "Tester":
+            return "tester: design and write unit/integration tests";
+        case "Reviewer":
+            return "code reviewer: critique code for bugs, perf, and clarity";
+        case "Customer":
+            return "customer proxy: validate that built feature meets user need";
+        default:
+            return `role ${String(slot)}`;
+    }
+}
+async function* runShip(opts) {
+    if (!opts.runId) {
+        yield { type: "content", content: "error: ship requires a runId\n" };
+        return { runId: "", stage: "error", success: false, reason: "missing_runId" };
+    }
+    const m = await readManifest(opts.flowDir, opts.runId);
+    if (!m) {
+        yield { type: "content", content: `Run not found: ${opts.runId}\n` };
+        return { runId: opts.runId, stage: "error", success: false, reason: "not_found" };
+    }
+    const iters = await readIterations(opts.flowDir, opts.runId);
+    if (iters.length === 0) {
+        yield { type: "content", content: `not ready to ship: no iterations recorded\n` };
+        return { runId: opts.runId, stage: "halted", success: false, reason: "not_ready" };
+    }
+    const last = iters[iters.length - 1];
+    if (last.lastVerifyResult !== "PASS") {
+        yield {
+            type: "content",
+            content: `not ready to ship: last verify=${last.lastVerifyResult}\n`,
+        };
+        return { runId: opts.runId, stage: "halted", success: false, reason: "not_ready" };
+    }
+    // Force final user-approval gate (Cond #5). Reuse runPreflight via the
+    // respondToPreflight responder: caller handles approve/reject prompt.
+    const approved = await opts.respondToPreflight("ship-final");
+    if (!approved) {
+        yield { type: "content", content: `Ship rejected by user.\n` };
+        // Build feedback so caller can pipe back into a continue cycle.
+        buildContinueFeedback({ pass: false, failedCondition: "user_approval", score: last.scoreAfter, reason: "user_rejected" }, null, []);
+        return { runId: opts.runId, stage: "halted", success: false, reason: "user_rejected" };
+    }
+    await writeManifest(opts.flowDir, opts.runId, {
+        ...m,
+        doneAt: new Date(),
+        verdict: { pass: true, score: last.scoreAfter, failedCondition: undefined, reason: "force_shipped" },
+    });
+    yield { type: "content", content: `Shipped run ${opts.runId}.\n` };
+    return { runId: opts.runId, stage: "approved", success: true, reason: "shipped", shipped: true };
+}
+//# sourceMappingURL=index.js.map