muonroi-cli 1.3.4 → 1.4.1

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

@@ -8,15 +8,21 @@ 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 { defaultResolveChannelId, maybeAutoFire } from "../reporter/auto-fire.js";
 import { logInteraction, logUIInteraction } from "../storage/index.js";
+import { activeRunStore } from "../ui/state/active-run.js";
 import { markIterationCrashed, readIterations, readManifest, writeManifest } from "./artifact-io.js";
+import { buildBacklog } from "./backlog-builder.js";
+import { readBacklog, writeBacklog } from "./backlog-store.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 { applySprintAssignments, planSprints } from "./sprint-planner.js";
 import { runSprint } from "./sprint-runner.js";
+import { readSprintPlan, setActiveSprint, writeSprintPlan } from "./sprint-store.js";
 /**
  * Entry point for the Product Ideal Loop.
  *
@@ -39,19 +45,53 @@ export async function* runProductLoop(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.
+            // Mode C dispatch — see .planning/MAINTAIN-MODE.md "Trigger mechanism".
+            //   1. Explicit --maintain   → Mode C
+            //   2. Explicit --new        → Mode A (current behavior, skip detection)
+            //   3. Auto-detect: verify recipe present in cwd → Mode C
+            //   4. Otherwise             → Mode A
+            if (opts.mode === "maintain") {
+                return yield* runMaintain(opts);
+            }
+            if (opts.mode !== "new" && opts.detectVerifyRecipe) {
+                try {
+                    const recipe = await opts.detectVerifyRecipe();
+                    if (recipe) {
+                        return yield* runMaintain(opts);
+                    }
+                }
+                catch {
+                    // Detection failure is non-fatal — fall through to Mode A.
+                }
+            }
+            // C1 — Existing-repo bypass. The sufficiency gate below was tuned for
+            // greenfield: a vague "todo app" prompt with no folder MUST go to
+            // Council so AskCard can pin productType / audience / stack before
+            // any scaffolding. But when /ideal runs inside a non-empty folder,
+            // those answers are derivable from the source (manifests, dirs, deps)
+            // — forcing the user through 6 AskCards is the regression session
+            // e2660a052918 demonstrated. Skip the sufficiency gate (and prefer
+            // hot-path over full Council for medium complexity) when the cwd is
+            // an existing project AND the caller hasn't explicitly forced council.
+            //
+            // forceCouncil=true still wins — user can opt back into the full
+            // Council pipeline when they actually want it (e.g. architectural
+            // change to an existing repo).
+            const existingRepoBypass = await detectExistingRepoBypass(opts);
             const hasGaps = !!(opts.sufficiencyMissing && opts.sufficiencyMissing.length > 0);
-            if (hasGaps) {
+            if (hasGaps && !existingRepoBypass) {
                 const forcedOpts = {
                     ...opts,
                     flags: { ...opts.flags, forceCouncil: true },
                 };
                 return yield* runStart(forcedOpts);
             }
+            // Existing repo + complexity≠high → hot-path. The leader can grep
+            // the source instead of interviewing the user. Only architectural
+            // changes (complexity=high) still warrant the full Council debate.
+            if (existingRepoBypass && opts.complexity !== "high" && !opts.flags.forceCouncil) {
+                return yield* runHotPath(opts);
+            }
             if (opts.complexity === "low" && !opts.flags.forceCouncil) {
                 return yield* runHotPath(opts);
             }
@@ -59,6 +99,33 @@ export async function* runProductLoop(opts) {
         }
     }
 }
+/**
+ * C1 — Decide whether the existing-repo bypass should fire for THIS run.
+ *
+ * Returns true when `cwd` contains source code or a manifest (any of:
+ * package.json, Cargo.toml, go.mod, pyproject.toml, *.csproj, *.sln,
+ * Directory.Build.props, or a top-level source file). False when the
+ * folder is empty / probe fails — in which case the original gating
+ * (Council for vague greenfield prompts) takes over.
+ *
+ * Sync probe, no I/O retry. `forceCouncil` overrides this gate at the
+ * call site — when the user explicitly asks for Council we honor it
+ * even on an existing repo (e.g. "rearchitect this codebase").
+ */
+async function detectExistingRepoBypass(opts) {
+    if (opts.flags?.forceCouncil)
+        return false;
+    const cwd = opts.cwd ?? process.cwd();
+    try {
+        const { detectExistingProject } = await import("./discovery-detection.js");
+        const det = await detectExistingProject(cwd);
+        return det.classification !== "greenfield";
+    }
+    catch {
+        // Detection failure is non-fatal — fall back to the original gating.
+        return false;
+    }
+}
 /**
  * P2.5 — Hot-path for complexity=low ideas.
  *
@@ -130,6 +197,16 @@ async function* runHotPath(opts) {
     catch {
         /* best-effort */
     }
+    // B1: update active-run store; B2: auto-fire plan committed.
+    try {
+        const { productSlug: deriveSlug } = await import("./product-identity.js");
+        const slug = deriveSlug(idea);
+        activeRunStore.setActiveRun(runId, flowDir, slug);
+        fireAutoReport("sprint-plan-committed", { runId, flowDir, productSlug: slug, sprintCount: 1 });
+    }
+    catch {
+        /* best-effort */
+    }
     // Build a minimal ProductSpec inline (no LLM calls needed for the hot-path).
     const productSpec = {
         idea,
@@ -271,10 +348,201 @@ async function* runHotPath(opts) {
     }
     return { runId, stage: "approved", success: true, reason: "shipped", sprintsRun: 1, shipped: true };
 }
+/**
+ * Heuristic kind detection from the user's idea text. Avoids hardcoding "bug"
+ * for everything — keyword-anchored, falls back to "feature" because most
+ * "/ideal foo" prompts are additive, not bug fixes.
+ */
+export function detectMaintenanceKind(idea) {
+    const lower = idea.toLowerCase();
+    if (/\b(fix|bug|broken|crash|error|fail|regression|hotfix|patch)\b/.test(lower))
+        return "bug";
+    if (/\b(refactor|cleanup|reorganize|rename|split|extract|consolidat)/.test(lower))
+        return "refactor";
+    if (/\b(docs?|documentation|readme|comment|jsdoc|tsdoc)\b/.test(lower))
+        return "docs";
+    if (/\b(chore|cleanup|upgrade|bump|deps?|dependency|dependencies|lint|format)\b/.test(lower))
+        return "chore";
+    return "feature";
+}
+/**
+ * Build default acceptance criteria for Mode C tasks. Lifts heuristics from the
+ * idea so the judge has something to evaluate against beyond "verify passes".
+ */
+export function buildDefaultAcceptanceCriteria(idea) {
+    const criteria = ["Existing verify recipe passes after edits"];
+    const lower = idea.toLowerCase();
+    if (/\b(test|spec|coverage)\b/.test(lower)) {
+        criteria.push("New behavior is covered by at least one test");
+    }
+    if (/\b(no regression|don'?t break|without break|breaking|preserve|backward)/.test(lower)) {
+        criteria.push("No regression in existing test suite");
+    }
+    if (/\b(error|exception|null|undefined|crash)\b/.test(lower)) {
+        criteria.push("Error path is handled explicitly (no silent swallowing)");
+    }
+    return criteria;
+}
+/**
+ * Mode C — single-task maintenance flow.
+ *
+ * Skeleton wiring per .planning/MAINTAIN-MODE.md. Builds a basic
+ * MaintenanceTask from the user's idea (no clarify questions yet — P17
+ * follow-up), gathers codebase intel, runs the 5-stage task cycle,
+ * builds a PR, optionally invokes `gh pr create`.
+ */
+async function* runMaintain(opts) {
+    const { idea, flowDir, llm, flags, cwd, processMessageFn, detectVerifyRecipe, respondToPreflight, sessionModelId } = opts;
+    if (!idea?.trim()) {
+        yield { type: "content", content: "error: /ideal maintain requires a task description" };
+        return { runId: "", stage: "error", success: false, reason: "missing_idea" };
+    }
+    if (!cwd || !processMessageFn || !detectVerifyRecipe) {
+        yield {
+            type: "content",
+            content: "error: Mode C requires cwd, processMessageFn, and detectVerifyRecipe bridges",
+        };
+        return { runId: "", stage: "error", success: false, reason: "missing_bridges" };
+    }
+    const { gatherCodebaseIntel, runMaintenanceTask, buildPr, ghCreatePr } = await import("../maintain/index.js");
+    const { randomUUID } = await import("node:crypto");
+    const { promises: fsp } = await import("node:fs");
+    const pathMod = await import("node:path");
+    const runState = await createRun(flowDir);
+    const runId = runState.id;
+    await writeManifest(flowDir, runId, {
+        idea,
+        capUsd: flags.maxCost,
+        maxSprints: 1,
+        doneThreshold: flags.doneThreshold,
+        stack: flags.stack,
+        createdAt: new Date(),
+    });
+    yield { type: "content", content: "\n> Mode C: single-task maintenance flow\n" };
+    try {
+        const _ar = globalThis.__muonroiAgentRuntime;
+        _ar?.emitEvent({
+            t: "event",
+            kind: "route-decision",
+            path: "maintain",
+            complexity: opts.complexity ?? "unknown",
+            forceCouncil: false,
+            runId,
+        });
+    }
+    catch {
+        /* best-effort */
+    }
+    try {
+        logInteraction(opts.sessionId ?? runId, "routing", {
+            eventSubtype: "ideal_maintain",
+            data: { mode: "maintain", explicit: opts.mode === "maintain" },
+        });
+    }
+    catch {
+        /* DB errors must not break /ideal */
+    }
+    logUIInteraction(opts.sessionId, {
+        subtype: "route_decision",
+        data: { path: "maintain", complexity: opts.complexity ?? "unknown", forceCouncil: false, runId },
+    });
+    const taskId = randomUUID();
+    const nowIso = new Date().toISOString();
+    const task = {
+        id: taskId,
+        kind: detectMaintenanceKind(idea),
+        title: idea.split("\n")[0].slice(0, 120),
+        description: idea,
+        acceptance_criteria: buildDefaultAcceptanceCriteria(idea),
+        candidateFiles: [],
+        impactRadius: [],
+        regressionTestFiles: [],
+        status: "queued",
+        createdAtUtc: nowIso,
+        updatedAtUtc: nowIso,
+    };
+    yield { type: "content", content: "\n> Gathering codebase intel...\n" };
+    const intel = await gatherCodebaseIntel({ cwd, task });
+    // Populate task with intel-derived fields so the runner + PR body have them.
+    task.candidateFiles = intel.candidateFiles.map((c) => c.path);
+    task.impactRadius = intel.impactRadius;
+    task.regressionTestFiles = intel.regressionTests;
+    const ctx = {
+        runId,
+        sessionId: opts.sessionId,
+        cwd,
+        llm: {
+            generate: (modelId, system, prompt, maxTokens) => llm.generate(modelId, system, prompt, maxTokens),
+        },
+        processMessageFn,
+        detectVerifyRecipe,
+        respondToPreflight,
+    };
+    const taskResult = yield* runMaintenanceTask({
+        task,
+        codebaseIntel: intel,
+        ctx,
+        leaderModelId: sessionModelId,
+        costAware: true,
+    });
+    if (taskResult.status !== "done") {
+        yield {
+            type: "content",
+            content: `\n> Mode C halted at status=${taskResult.status}: ${taskResult.failureReason ?? "unknown"}\n`,
+        };
+        return { runId, stage: "halted", success: false, reason: taskResult.failureReason ?? taskResult.status };
+    }
+    yield { type: "content", content: "\n> Building PR artifact...\n" };
+    let pr;
+    try {
+        pr = await buildPr({
+            task,
+            codebaseIntel: intel,
+            result: taskResult,
+            cwd,
+            leaderModelId: sessionModelId,
+            costAware: true,
+            llm: { generate: ctx.llm.generate },
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        yield { type: "content", content: `\n> PR build failed: ${msg}\n` };
+        return { runId, stage: "halted", success: false, reason: `pr_build_failed: ${msg}` };
+    }
+    // Always persist PR artifact for the user to review.
+    const prMdPath = pathMod.join(flowDir, "runs", runId, "pr.md");
+    try {
+        await fsp.mkdir(pathMod.dirname(prMdPath), { recursive: true });
+        const persistBody = `# ${pr.title}\n\nBranch: \`${pr.branch}\`\n\n${pr.body}\n\n---\n\n\`\`\`diff\n${pr.diff}\n\`\`\`\n`;
+        await fsp.writeFile(prMdPath, persistBody, "utf8");
+    }
+    catch {
+        /* non-fatal */
+    }
+    yield {
+        type: "content",
+        content: `\n## PR ready: ${pr.title}\nBranch: \`${pr.branch}\`\nFiles changed: ${pr.changedFiles.length}${pr.filesOutsideRadius.length > 0 ? ` (${pr.filesOutsideRadius.length} outside declared radius)` : ""}\nArtifact: \`${prMdPath}\`\n\n${pr.body}\n`,
+    };
+    if (opts.ghPr) {
+        yield { type: "content", content: "\n> Creating PR via gh CLI...\n" };
+        const ghResult = await ghCreatePr({ branch: pr.branch, title: pr.title, body: pr.body, cwd });
+        if (ghResult.ok && ghResult.url) {
+            yield { type: "content", content: `\n> PR created: ${ghResult.url}\n` };
+        }
+        else {
+            yield {
+                type: "content",
+                content: `\n> gh pr create skipped/failed: ${ghResult.reason ?? "unknown"}\n`,
+            };
+        }
+    }
+    return { runId, stage: "approved", success: true, reason: "pr_ready", 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()) {
+    if (!idea?.trim()) {
         yield { type: "content", content: "error: /ideal start requires an idea" };
         return { runId: "", stage: "error", success: false, reason: "missing_idea" };
     }
@@ -383,10 +651,24 @@ async function* runStart(opts) {
     // 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));
+    // A2: Build Backlog + Sprint Plan before entering the sprint loop.
+    // Idempotent — skips if backlog.json / sprint-plan.json already exist (resume safety).
+    const { sprintCount, sprintIds } = await buildBacklogAndSprintPlan({
+        flowDir,
+        runId,
+        productSpec,
+        ctx,
+        sessionModelId: opts.sessionModelId,
+        maxSprints: flags.maxSprints,
+        onChunk: (chunk) => void chunk, // chunks yielded below via the emit event
+    });
+    // Yield a brief confirmation chunk so the user sees the committed plan.
+    yield {
+        type: "content",
+        content: `\n> Committed: ${sprintCount} sprint${sprintCount === 1 ? "" : "s"} planned. Sprint 1 active.\n`,
+    };
     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",
@@ -401,6 +683,17 @@ async function* runStart(opts) {
     catch {
         /* best-effort */
     }
+    // B1: update active-run store so StatusBar shows sprint progress.
+    // B2: auto-fire "run started" to Discord when configured.
+    try {
+        const { productSlug: deriveSlug } = await import("./product-identity.js");
+        const slug = deriveSlug(idea);
+        activeRunStore.setActiveRun(runId, flowDir, slug);
+        fireAutoReport("sprint-plan-committed", { runId, flowDir, productSlug: slug, sprintCount });
+    }
+    catch {
+        /* best-effort — never break /ideal over status bar or reporter */
+    }
     // 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 });
@@ -416,6 +709,120 @@ async function* runStart(opts) {
         flags,
     });
 }
+/**
+ * A2 — Build Backlog + Sprint Plan after the council debate has produced a ProductSpec.
+ *
+ * Idempotent: skips if backlog.json / sprint-plan.json already exist on disk
+ * (safe for resume flows that re-enter runStart after a crash).
+ *
+ * Returns the sprintCount + sprintIds that were committed (new or pre-existing),
+ * for use in the sprint-plan-committed harness event.
+ *
+ * Model selection: delegates to backlog-builder.ts + sprint-planner.ts which both
+ * use pickCouncilTaskModel — NO hardcoded model ids here.
+ */
+async function buildBacklogAndSprintPlan(args) {
+    const { flowDir, runId, productSpec, ctx, sessionModelId, maxSprints } = args;
+    // ── Check idempotency ──────────────────────────────────────────────────────
+    const existingBacklog = await readBacklog(flowDir, runId).catch(() => null);
+    const existingPlan = await readSprintPlan(flowDir, runId).catch(() => null);
+    if (existingBacklog && existingPlan) {
+        // Already built — return existing sprint ids for the harness event.
+        const ids = existingPlan.sprints.map((s) => s.id);
+        return { sprintCount: ids.length, sprintIds: ids };
+    }
+    // ── Derive ImplementationPlanArtifact from ProductSpec ────────────────────
+    // ProductSpec.mvp is a string[] of feature titles. Map each to a mvp_definition
+    // entry. This avoids an extra LLM call — the council debate has already produced
+    // the plan text; we just need to structure it for the backlog builder.
+    const implementationPlan = {
+        mvp_definition: productSpec.mvp.map((feature) => ({
+            feature,
+            included_in_v1: "yes",
+        })),
+        acceptance_criteria: [], // council debate artifacts are in delegations.md; keep empty here
+        entities: [],
+        endpoints: [],
+    };
+    const leaderModelId = resolveLeaderModel(sessionModelId);
+    // ── Build Backlog ──────────────────────────────────────────────────────────
+    let backlog = existingBacklog;
+    if (!backlog) {
+        try {
+            // Build ClarifiedSpec from persisted project context (written by loop-driver).
+            const { readProjectContext } = await import("./discovery-persistence.js");
+            const { clarifiedSpecFromContext } = await import("./gather.js");
+            const projectContext = await readProjectContext(flowDir, runId);
+            const clarifiedSpec = projectContext
+                ? clarifiedSpecFromContext(projectContext)
+                : {
+                    problemStatement: productSpec.idea,
+                    constraints: [],
+                    successCriteria: productSpec.mvp,
+                    scope: productSpec.idea,
+                    rawQA: [],
+                    resolved: {},
+                };
+            backlog = await buildBacklog({
+                runId,
+                productSlug: productSpec.idea.slice(0, 40).replace(/\s+/g, "-").toLowerCase(),
+                spec: clarifiedSpec,
+                implementationPlan,
+                llm: ctx.llm,
+                leaderModelId,
+                costAware: true,
+            });
+            await writeBacklog(flowDir, runId, backlog);
+        }
+        catch (err) {
+            // Non-fatal: sprint-runner has a backlog fallback (backlogAnchor="" when null).
+            const msg = err instanceof Error ? err.message : String(err);
+            args.onChunk({ type: "content", content: `\n> [backlog] Build skipped: ${msg}\n` });
+            // Return a synthetic single-sprint plan so the harness event fires correctly.
+            const sprintIds = Array.from({ length: maxSprints }, (_, i) => `sprint-${i + 1}`);
+            return { sprintCount: maxSprints, sprintIds };
+        }
+    }
+    // ── Plan Sprints ───────────────────────────────────────────────────────────
+    let plan = existingPlan;
+    if (!plan) {
+        try {
+            plan = await planSprints({
+                runId,
+                backlog,
+                llm: ctx.llm,
+                leaderModelId,
+                costAware: true,
+                targetEffortPerSprint: 8,
+            });
+            await writeSprintPlan(flowDir, runId, plan);
+            // Update each BacklogItem with status="in_sprint" + assigned_sprint.
+            await applySprintAssignments(flowDir, runId, plan);
+        }
+        catch (err) {
+            // Non-fatal: build a synthetic plan from maxSprints.
+            const msg = err instanceof Error ? err.message : String(err);
+            args.onChunk({ type: "content", content: `\n> [sprint-plan] Build skipped: ${msg}\n` });
+            const sprintIds = Array.from({ length: maxSprints }, (_, i) => `sprint-${i + 1}`);
+            return { sprintCount: maxSprints, sprintIds };
+        }
+    }
+    // ── Set Sprint 1 Active ────────────────────────────────────────────────────
+    if (plan.sprints.length > 0 && !plan.activeSprintId) {
+        try {
+            const firstSprintId = plan.sprints[0].id;
+            await setActiveSprint(flowDir, runId, firstSprintId);
+        }
+        catch {
+            /* non-fatal */
+        }
+    }
+    const ids = plan.sprints.map((s) => s.id);
+    return {
+        sprintCount: ids.length || maxSprints,
+        sprintIds: ids.length > 0 ? ids : Array.from({ length: maxSprints }, (_, i) => `sprint-${i + 1}`),
+    };
+}
 /** Drive sprint-runner repeatedly, honoring max-sprints and continue-feedback routing. */
 async function* drainSprints(args) {
     const { ctx, productSpec, roleAssignments, flags } = args;
@@ -424,6 +831,23 @@ async function* drainSprints(args) {
     let sprintsRun = 0;
     for (let sprintN = history.length + 1; sprintN <= flags.maxSprints; sprintN++) {
         let iter;
+        // Check token budget
+        if (flags.budgetTokens) {
+            const { getProductTotalTokens } = await import("../usage/product-ledger.js");
+            const totalTokens = await getProductTotalTokens(ctx.runId);
+            if (totalTokens > flags.budgetTokens) {
+                yield {
+                    type: "halt",
+                    haltChunk: {
+                        type: "halt",
+                        reason: "budget_exhausted",
+                        detail: `Token budget exceeded: used ${totalTokens} > limit ${flags.budgetTokens}`,
+                        recovery_options: [],
+                    },
+                };
+                return { runId: ctx.runId, stage: "halted", success: false, reason: "budget exhausted" };
+            }
+        }
         try {
             const sprintGen = runSprint({
                 sprintN,
@@ -451,6 +875,16 @@ async function* drainSprints(args) {
                             verdict: { pass: false, score: 0, reason: haltReason, failedCondition: undefined },
                         });
                     }
+                    // B2: auto-fire halt notification; B1: clear active-run.
+                    try {
+                        const { productSlug: deriveSlug } = await import("./product-identity.js");
+                        const slug = deriveSlug(productSpec.idea);
+                        fireAutoReport("sprint-halt", { runId: ctx.runId, flowDir: ctx.flowDir, productSlug: slug, haltReason });
+                        activeRunStore.clearActiveRun();
+                    }
+                    catch {
+                        /* best-effort */
+                    }
                     return {
                         runId: ctx.runId,
                         stage: "halted",
@@ -495,6 +929,16 @@ async function* drainSprints(args) {
                     verdict: { pass: false, score: 0, reason: msg, failedCondition: undefined },
                 });
             }
+            // B2: auto-fire halt notification; B1: clear active-run.
+            try {
+                const { productSlug: deriveSlug } = await import("./product-identity.js");
+                const slug = deriveSlug(productSpec.idea);
+                fireAutoReport("sprint-halt", { runId: ctx.runId, flowDir: ctx.flowDir, productSlug: slug, haltReason: msg });
+                activeRunStore.clearActiveRun();
+            }
+            catch {
+                /* best-effort */
+            }
             return {
                 runId: ctx.runId,
                 stage: "halted",
@@ -505,6 +949,27 @@ async function* drainSprints(args) {
         }
         history.push(iter);
         sprintsRun++;
+        // B2: auto-fire sprint-done when judgment stage completes.
+        // Compute overall pct from current iteration state.
+        try {
+            const { productSlug: deriveSlug } = await import("./product-identity.js");
+            const slug = deriveSlug(productSpec.idea);
+            // Compute overall completion pct across all sprints (rough estimate from criteria).
+            const totalCriteria = (iter.criteriaMet ?? 0) + (iter.criteriaPartial ?? 0) + (iter.criteriaUnmet ?? 0);
+            const overallPct = totalCriteria > 0 ? Math.round(((iter.criteriaMet ?? 0) / totalCriteria) * 1000) / 10 : 0;
+            const verdict = iter.lastVerifyResult === "PASS" ? "pass" : "fail";
+            fireAutoReport("sprint-done", {
+                runId: ctx.runId,
+                flowDir: ctx.flowDir,
+                productSlug: slug,
+                sprintN,
+                pct: overallPct,
+                verdict,
+            });
+        }
+        catch {
+            /* best-effort */
+        }
         if (iter.stage === "shipped") {
             // Final manifest update + EE pass outcome
             const manifest = await readManifest(ctx.flowDir, ctx.runId);
@@ -562,6 +1027,8 @@ async function* drainSprints(args) {
                     // DB errors must not break /ideal
                 }
             }
+            // B1: clear active-run on successful ship.
+            activeRunStore.clearActiveRun();
             return {
                 runId: ctx.runId,
                 stage: "approved",
@@ -584,6 +1051,8 @@ async function* drainSprints(args) {
         type: "content",
         content: `\n> Reached max-sprints (${flags.maxSprints}) without satisfying Definition-of-Done.\n`,
     };
+    // B1: clear active-run when max-sprints reached.
+    activeRunStore.clearActiveRun();
     return {
         runId: ctx.runId,
         stage: "halted",
@@ -598,6 +1067,30 @@ function chatEnvConfig() {
     const client = readChatProvider();
     return client ? { client } : null;
 }
+/**
+ * Best-effort auto-fire helper (B2).
+ * Fires-and-forgets a reporter event; never throws.
+ * Only does I/O when a Discord client is configured AND reporter.autoFire=true.
+ */
+function fireAutoReport(kind, opts) {
+    const chatCfg = chatEnvConfig();
+    if (!chatCfg)
+        return;
+    void maybeAutoFire({
+        kind,
+        runId: opts.runId,
+        flowDir: opts.flowDir,
+        productSlug: opts.productSlug,
+        sprintN: opts.sprintN,
+        pct: opts.pct,
+        verdict: opts.verdict,
+        haltReason: opts.haltReason,
+        sprintCount: opts.sprintCount,
+    }, {
+        chat: chatCfg.client,
+        resolveChannelId: defaultResolveChannelId,
+    });
+}
 /**
  * Phase-orchestrated sprint path (Subsystem E).
  *