muonroi-cli 1.3.4 → 1.4.1

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

@@ -125,7 +125,7 @@ function buildGatherCompleteCard(fieldCount, unresolvedCount) {
 }
 function buildResearchSummaryCard(summaryText, findings) {
     const sections = [{ heading: "Summary", body: summaryText }];
-    if (findings && findings.trim()) {
+    if (findings?.trim()) {
         sections.push({ heading: "Findings", body: findings.trim() });
     }
     return { title: "Research Summary", sections };
@@ -234,7 +234,7 @@ export async function* runLoopDriver(ctx) {
                     marker: phaseMarker_discover,
                 });
                 if (discoverWarn) {
-                    yield { type: "content", content: "\n> [budget] " + discoverWarn + "\n" };
+                    yield { type: "content", content: `\n> [budget] ${discoverWarn}\n` };
                 }
                 // Emit an initial product_status_card so the UI shows the status panel
                 // immediately after discovery completes — before gather/research blocks
@@ -366,7 +366,7 @@ export async function* runLoopDriver(ctx) {
                         marker: phaseMarker_gather,
                     });
                     if (gatherWarn) {
-                        yield { type: "content", content: "\n> [budget] " + gatherWarn + "\n" };
+                        yield { type: "content", content: `\n> [budget] ${gatherWarn}\n` };
                     }
                     state = "research";
                 }
@@ -407,7 +407,7 @@ export async function* runLoopDriver(ctx) {
                 // inside research phase, before building councilTopic:
                 const projectCtx = await readProjectContext(ctx.flowDir, ctx.runId);
                 if (projectCtx) {
-                    conversationContext += "\n\nProject Context:\n" + formatProjectContextForPrompt(projectCtx);
+                    conversationContext += `\n\nProject Context:\n${formatProjectContextForPrompt(projectCtx)}`;
                 }
                 // Build stances. When ecosystem bias is enabled (default), augment the
                 // Researcher/Architect/Skeptic lenses so the debate prioritizes
@@ -420,8 +420,8 @@ export async function* runLoopDriver(ctx) {
                     { name: "Architect", lens: "Focus on high-level structure, scalability, and long-term maintainability" },
                 ];
                 try {
-                    const { isEcosystemBiasEnabled, buildEcosystemResearchSeed } = await import("./discovery-ecosystem.js");
-                    if (isEcosystemBiasEnabled()) {
+                    const { shouldApplyEcosystemBias, buildEcosystemResearchSeed } = await import("./discovery-ecosystem.js");
+                    if (shouldApplyEcosystemBias({ cwd: process.cwd() })) {
                         const seed = buildEcosystemResearchSeed();
                         stances = stances.map((s) => {
                             if (s.name === "Researcher")
@@ -592,8 +592,7 @@ export async function* runLoopDriver(ctx) {
                         durationMs: Date.now() - researchPhaseStartMs,
                     });
                 }
-                const summaryText = (debateState?.runningSummary && debateState.runningSummary.trim()) ||
-                    "(debate produced no summary — using empty research findings)";
+                const summaryText = debateState?.runningSummary?.trim() || "(debate produced no summary — using empty research findings)";
                 yield {
                     type: "council_info_card",
                     councilInfoCard: buildResearchSummaryCard(summaryText, debateState?.researchFindings),
@@ -642,7 +641,7 @@ export async function* runLoopDriver(ctx) {
                     marker: phaseMarker_research,
                 });
                 if (researchWarn) {
-                    yield { type: "content", content: "\n> [budget] " + researchWarn + "\n" };
+                    yield { type: "content", content: `\n> [budget] ${researchWarn}\n` };
                 }
                 state = "scoping";
                 break;
@@ -685,24 +684,24 @@ export async function* runLoopDriver(ctx) {
                     },
                 };
                 // Synthesize ProductSpec
-                const synthesisPrompt = `Synthesize a ProductSpec JSON based on the following:
-Idea: ${ctx.idea}
-Clarified Spec: ${JSON.stringify(clarifiedSpec)}
-Debate Summary: ${debateState.runningSummary}
-Research Findings: ${debateState.researchFindings ?? "N/A"}
-
-Output ONLY a JSON object matching this interface:
-interface ProductSpec {
-  idea: string;
-  persona: string;
-  mvp: string[];
-  phase2: string[];
-  architecture: string;
-  ioContract: string;
-  folderStructure: string;
-  sprintEstimate: number;
-  costEstimate: number;
-}
+                const synthesisPrompt = `Synthesize a ProductSpec JSON based on the following:
+Idea: ${ctx.idea}
+Clarified Spec: ${JSON.stringify(clarifiedSpec)}
+Debate Summary: ${debateState.runningSummary}
+Research Findings: ${debateState.researchFindings ?? "N/A"}
+
+Output ONLY a JSON object matching this interface:
+interface ProductSpec {
+  idea: string;
+  persona: string;
+  mvp: string[];
+  phase2: string[];
+  architecture: string;
+  ioContract: string;
+  folderStructure: string;
+  sprintEstimate: number;
+  costEstimate: number;
+}
 `;
                 // The scoping phase's only LLM call. Wrapped so a provider hang/
                 // timeout leaves a council_error audit row instead of swallowing the
@@ -793,7 +792,7 @@ interface ProductSpec {
                     marker: phaseMarker_scoping,
                 });
                 if (scopingWarn) {
-                    yield { type: "content", content: "\n> [budget] " + scopingWarn + "\n" };
+                    yield { type: "content", content: `\n> [budget] ${scopingWarn}\n` };
                 }
                 if (approved) {
                     state = "approved";

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

@@ -103,10 +103,10 @@ export async function renderBudgetSummary(flowDir, runId) {
     if (!state || state.records.length === 0)
         return "_(no phase budget data)_";
     const lines = [];
-    lines.push("Cap: $" + state.capUsd.toFixed(2));
+    lines.push(`Cap: $${state.capUsd.toFixed(2)}`);
     for (const r of state.records) {
         const flag = r.warnedOverBudget ? "  [OVER]" : "";
-        lines.push("- " + r.phase + ": $" + r.spentUsd.toFixed(3) + " (hint $" + r.hintUsd.toFixed(3) + ")" + flag);
+        lines.push(`- ${r.phase}: $${r.spentUsd.toFixed(3)} (hint $${r.hintUsd.toFixed(3)})${flag}`);
     }
     return lines.join("\n");
 }

package/dist/src/product-loop/progress-snapshot.d.ts

@@ -0,0 +1,25 @@
+/**
+ * src/product-loop/progress-snapshot.ts
+ *
+ * Pure projection: reads Backlog + SprintPlan + interaction_logs and returns
+ * a ProgressSnapshot. No LLM, no external writes.
+ *
+ * Both /status and the P8 reporter consume this module.
+ * renderSnapshotMarkdown() is a pure string function — no I/O — so tests and
+ * the reporter can call it without a live sprint-runner.
+ */
+import type { ProgressSnapshot } from "./types.js";
+export interface ComputeSnapshotInput {
+    flowDir: string;
+    runId: string;
+    productSlug: string;
+}
+/**
+ * Compute a ProgressSnapshot from disk + DB. Pure I/O — no LLM.
+ */
+export declare function computeProgressSnapshot(input: ComputeSnapshotInput): Promise<ProgressSnapshot>;
+/**
+ * Render a ProgressSnapshot as a markdown progress card.
+ * Pure function — no I/O. Both /status and sprint-runner use this.
+ */
+export declare function renderSnapshotMarkdown(snapshot: ProgressSnapshot): string;

package/dist/src/product-loop/progress-snapshot.js

@@ -0,0 +1,180 @@
+/**
+ * src/product-loop/progress-snapshot.ts
+ *
+ * Pure projection: reads Backlog + SprintPlan + interaction_logs and returns
+ * a ProgressSnapshot. No LLM, no external writes.
+ *
+ * Both /status and the P8 reporter consume this module.
+ * renderSnapshotMarkdown() is a pure string function — no I/O — so tests and
+ * the reporter can call it without a live sprint-runner.
+ */
+import { getDatabase } from "../storage/db.js";
+import { readBacklog } from "./backlog-store.js";
+import { readSprintPlan } from "./sprint-store.js";
+/**
+ * Read the latest sprint_stage interaction log row for a runId.
+ * Queries via the DB directly (no read helper exists in storage/ for this query).
+ * Returns null on any error or if no row exists.
+ */
+function readLatestSprintStage(runId) {
+    try {
+        const db = getDatabase();
+        const row = db
+            .prepare(`SELECT metadata_json, created_at
+         FROM interaction_logs
+         WHERE session_id = ? AND event_type = 'ui_interaction' AND event_subtype = 'sprint_stage'
+         ORDER BY id DESC
+         LIMIT 1`)
+            .get(runId);
+        if (!row)
+            return null;
+        const meta = row.metadata_json ? JSON.parse(row.metadata_json) : null;
+        if (!meta)
+            return null;
+        const sprintIndex = typeof meta.sprintIndex === "number" ? meta.sprintIndex : null;
+        const stage = typeof meta.stage === "string" ? meta.stage : null;
+        if (sprintIndex === null || !stage)
+            return null;
+        return { sprintIndex, stage, createdAt: row.created_at };
+    }
+    catch {
+        return null;
+    }
+}
+function capitalize(s) {
+    if (!s)
+        return s;
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+// ─── Main export ──────────────────────────────────────────────────────────────
+/**
+ * Compute a ProgressSnapshot from disk + DB. Pure I/O — no LLM.
+ */
+export async function computeProgressSnapshot(input) {
+    const { flowDir, runId, productSlug } = input;
+    // 1. Read Backlog
+    const backlog = await readBacklog(flowDir, runId);
+    // 2. Read SprintPlan
+    const sprintPlan = await readSprintPlan(flowDir, runId);
+    // 3. Read latest sprint stage from interaction_logs
+    const stageRow = readLatestSprintStage(runId);
+    const workerCurrentStage = stageRow ? `Sprint ${stageRow.sprintIndex} — ${capitalize(stageRow.stage)}` : null;
+    const workerLastEventUtc = stageRow ? stageRow.createdAt : null;
+    // 4. Clarify status — P5 persists clarified-spec.json; best-effort read.
+    // TODO: read clarified-spec.json from flowDir/runs/runId/ when P5 persists it to disk.
+    //       For now, assume ready=true with no gaps if backlog exists (backlog can only
+    //       be built after clarification is complete).
+    const clarifyReady = backlog !== null;
+    const clarifyGaps = [];
+    // 5. Backlog metrics
+    const backlogTotal = backlog?.items.length ?? 0;
+    const backlogV1Count = backlog?.items.filter((i) => i.mvp_priority === "v1").length ?? 0;
+    const backlogDeferredCount = backlog?.items.filter((i) => i.mvp_priority === "v2" || i.mvp_priority === "later").length ?? 0;
+    // 6. Sprint metrics
+    const sprintTotal = sprintPlan?.sprints.length ?? 0;
+    const activeSprint = sprintPlan?.sprints.find((s) => s.id === sprintPlan.activeSprintId) ?? null;
+    const activeSprintNumber = activeSprint?.number ?? null;
+    const activeSprintGoal = activeSprint?.goal ?? null;
+    // 7. Active sprint items
+    const activeSprintItems = [];
+    if (activeSprint && backlog) {
+        for (const itemId of activeSprint.itemIds) {
+            const item = backlog.items.find((i) => i.id === itemId);
+            if (!item)
+                continue;
+            activeSprintItems.push({
+                id: item.id,
+                title: item.title,
+                status: item.status,
+                // v1 heuristic: count done items as fully met; others as 0%.
+                // Per-criterion tracking is P8+ work.
+                criteriaMet: item.status === "done" ? item.acceptance_criteria.length : 0,
+                criteriaTotal: item.acceptance_criteria.length,
+            });
+        }
+    }
+    // 8. Percent done — count completed items / total in sprint × 100
+    const totalItems = activeSprintItems.length;
+    const doneItems = activeSprintItems.filter((i) => i.status === "done").length;
+    const activeSprintPercentDone = totalItems > 0 ? Math.round((doneItems / totalItems) * 1000) / 10 : 0;
+    // 9. Blockers: backlog items with status="blocked" in the active sprint
+    const blockers = [];
+    if (activeSprint && backlog) {
+        for (const itemId of activeSprint.itemIds) {
+            const item = backlog.items.find((i) => i.id === itemId);
+            if (!item || item.status !== "blocked")
+                continue;
+            const reason = item.blockers && item.blockers.length > 0 ? `blocked by ${item.blockers[0]}` : "blocked";
+            blockers.push({ itemId: item.id, title: item.title, reason });
+        }
+    }
+    return {
+        runId,
+        productSlug,
+        capturedAtUtc: new Date().toISOString(),
+        clarifyReady,
+        clarifyGaps,
+        backlogTotal,
+        backlogV1Count,
+        backlogDeferredCount,
+        sprintTotal,
+        activeSprintNumber,
+        activeSprintGoal,
+        activeSprintPercentDone,
+        activeSprintItems,
+        blockers,
+        workerLastEventUtc,
+        workerCurrentStage,
+    };
+}
+// ─── Markdown renderer ────────────────────────────────────────────────────────
+function statusIcon(status) {
+    if (status === "done")
+        return "[x]";
+    if (status === "in_progress")
+        return "[~]";
+    return "[ ]";
+}
+/**
+ * Render a ProgressSnapshot as a markdown progress card.
+ * Pure function — no I/O. Both /status and sprint-runner use this.
+ */
+export function renderSnapshotMarkdown(snapshot) {
+    const lines = [];
+    lines.push(`## Progress — ${snapshot.productSlug}`);
+    lines.push("");
+    lines.push(`**Backlog:** ${snapshot.backlogTotal} total · ${snapshot.backlogV1Count} v1 · ${snapshot.backlogDeferredCount} deferred`);
+    const activeLabel = snapshot.activeSprintNumber !== null ? `Sprint ${snapshot.activeSprintNumber}` : "none";
+    lines.push(`**Sprints:** ${snapshot.sprintTotal} planned · active: ${activeLabel}`);
+    lines.push("");
+    if (snapshot.activeSprintNumber === null) {
+        lines.push("No active sprint.");
+    }
+    else {
+        const totalItems = snapshot.activeSprintItems.length;
+        const doneItems = snapshot.activeSprintItems.filter((i) => i.status === "done").length;
+        lines.push(`### Sprint ${snapshot.activeSprintNumber} — ${snapshot.activeSprintGoal ?? ""}`);
+        lines.push(`Progress: ${snapshot.activeSprintPercentDone}% (${doneItems}/${totalItems} items done)`);
+        lines.push("");
+        for (const item of snapshot.activeSprintItems) {
+            const icon = statusIcon(item.status);
+            lines.push(`- ${icon} ${item.title} — ${item.status} · ${item.criteriaMet}/${item.criteriaTotal}`);
+        }
+    }
+    lines.push("");
+    lines.push("### Blockers");
+    if (snapshot.blockers.length === 0) {
+        lines.push("_None_");
+    }
+    else {
+        for (const b of snapshot.blockers) {
+            lines.push(`- ${b.title}: ${b.reason}`);
+        }
+    }
+    lines.push("");
+    lines.push("### Worker");
+    lines.push(`Stage: ${snapshot.workerCurrentStage ?? "(idle)"}`);
+    lines.push(`Last event: ${snapshot.workerLastEventUtc ?? "(none)"}`);
+    return lines.join("\n");
+}
+//# sourceMappingURL=progress-snapshot.js.map

package/dist/src/product-loop/repo-brief.d.ts

@@ -0,0 +1,40 @@
+/**
+ * src/product-loop/repo-brief.ts
+ *
+ * Build a compact "what is this repo" brief that the discovery leader and
+ * council can cite when recommending changes inside an EXISTING project.
+ *
+ * The vendor-default preamble (`buildEcosystemPreamble`) belongs to greenfield
+ * scaffolding flows only. For existing repos we replace it with this brief —
+ * grounded in the actual filesystem — so the leader's rationale can name real
+ * files, packages, and scripts instead of inventing generic stack defaults.
+ *
+ * Output budget: ~1200 chars hard cap. Anything longer competes with the
+ * prompt-specificity context + question + constraint + answers-so-far, and
+ * the leader has limited maxTokens.
+ *
+ * The brief is intentionally markdown so the LLM can pattern-match section
+ * headers; it is NEVER user-facing.
+ */
+import type { ExistingProjectSignals } from "./types.js";
+/** Citable tokens extracted from the brief (file/dir names, package names,
+ *  script names). Used by `discovery-recommender` to validate that the leader
+ *  actually grounded its rationale in something concrete. */
+export interface RepoBrief {
+    markdown: string;
+    citableTokens: string[];
+}
+/**
+ * Build a markdown brief of the repo at `cwd`, grounded in `detection` plus
+ * a shallow filesystem walk. Returns markdown + the list of citable tokens
+ * so the caller can validate that leader rationales reference at least one.
+ *
+ * Never throws — partial brief is fine when individual probes fail.
+ */
+export declare function buildRepoBrief(cwd: string, detection: ExistingProjectSignals): Promise<RepoBrief>;
+/**
+ * Test whether `rationale` cites at least one citable token from `brief`.
+ * Case-insensitive substring match. Empty/missing brief tokens → returns true
+ * (no expectations to check against).
+ */
+export declare function rationaleCitesBrief(rationale: string, brief: RepoBrief | undefined): boolean;

package/dist/src/product-loop/repo-brief.js

@@ -0,0 +1,212 @@
+/**
+ * src/product-loop/repo-brief.ts
+ *
+ * Build a compact "what is this repo" brief that the discovery leader and
+ * council can cite when recommending changes inside an EXISTING project.
+ *
+ * The vendor-default preamble (`buildEcosystemPreamble`) belongs to greenfield
+ * scaffolding flows only. For existing repos we replace it with this brief —
+ * grounded in the actual filesystem — so the leader's rationale can name real
+ * files, packages, and scripts instead of inventing generic stack defaults.
+ *
+ * Output budget: ~1200 chars hard cap. Anything longer competes with the
+ * prompt-specificity context + question + constraint + answers-so-far, and
+ * the leader has limited maxTokens.
+ *
+ * The brief is intentionally markdown so the LLM can pattern-match section
+ * headers; it is NEVER user-facing.
+ */
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+const HARD_CAP_CHARS = 1200;
+const README_HEAD_CHARS = 480;
+const MAX_TOP_LEVEL_DIRS = 12;
+const MAX_NESTED_DIRS_PER_TOP = 6;
+const MAX_DEPS_LISTED = 18;
+const MAX_SCRIPTS_LISTED = 8;
+const IGNORED_DIRS = new Set([
+    "node_modules",
+    ".git",
+    ".next",
+    "dist",
+    "build",
+    "target",
+    "out",
+    ".turbo",
+    ".cache",
+    "coverage",
+    "venv",
+    ".venv",
+    "__pycache__",
+    ".idea",
+    ".vscode",
+]);
+async function safeReaddir(dir) {
+    try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        return entries.map((e) => ({ name: e.name, isDir: e.isDirectory() }));
+    }
+    catch {
+        return [];
+    }
+}
+async function readTopLevelDirs(cwd) {
+    const top = await safeReaddir(cwd);
+    const dirs = top
+        .filter((e) => e.isDir && !IGNORED_DIRS.has(e.name) && !e.name.startsWith("."))
+        .slice(0, MAX_TOP_LEVEL_DIRS)
+        .map((e) => e.name);
+    const out = [];
+    for (const d of dirs) {
+        const sub = await safeReaddir(path.join(cwd, d));
+        const children = sub
+            .filter((e) => e.isDir && !IGNORED_DIRS.has(e.name) && !e.name.startsWith("."))
+            .slice(0, MAX_NESTED_DIRS_PER_TOP)
+            .map((e) => e.name);
+        out.push({ name: d, children });
+    }
+    return out;
+}
+async function readReadmeHead(cwd) {
+    for (const name of ["README.md", "README.MD", "readme.md", "Readme.md"]) {
+        try {
+            const raw = await fs.readFile(path.join(cwd, name), "utf8");
+            const trimmed = raw.trim();
+            if (trimmed.length === 0)
+                continue;
+            return trimmed.length > README_HEAD_CHARS ? `${trimmed.slice(0, README_HEAD_CHARS)}…` : trimmed;
+        }
+        catch {
+            /* try next */
+        }
+    }
+    return null;
+}
+async function readPackageJsonSummary(cwd) {
+    let raw;
+    try {
+        raw = await fs.readFile(path.join(cwd, "package.json"), "utf8");
+    }
+    catch {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    const scripts = Object.keys(parsed.scripts ?? {}).slice(0, MAX_SCRIPTS_LISTED);
+    const deps = [
+        ...Object.keys(parsed.dependencies ?? {}),
+        ...Object.keys(parsed.devDependencies ?? {}),
+    ].slice(0, MAX_DEPS_LISTED);
+    return {
+        name: typeof parsed.name === "string" ? parsed.name : undefined,
+        description: typeof parsed.description === "string" ? parsed.description : undefined,
+        scripts,
+        deps,
+    };
+}
+function capMarkdown(s) {
+    if (s.length <= HARD_CAP_CHARS)
+        return s;
+    return `${s.slice(0, HARD_CAP_CHARS - 1)}…`;
+}
+/**
+ * Build a markdown brief of the repo at `cwd`, grounded in `detection` plus
+ * a shallow filesystem walk. Returns markdown + the list of citable tokens
+ * so the caller can validate that leader rationales reference at least one.
+ *
+ * Never throws — partial brief is fine when individual probes fail.
+ */
+export async function buildRepoBrief(cwd, detection) {
+    const tokens = new Set();
+    const lines = [];
+    lines.push("## Repo brief (existing project — recommendations MUST cite these)");
+    lines.push("");
+    // 1) Identity from package.json or manifest list
+    const pkg = await readPackageJsonSummary(cwd);
+    if (pkg?.name) {
+        lines.push(`Package name: \`${pkg.name}\``);
+        tokens.add(pkg.name);
+    }
+    if (pkg?.description) {
+        lines.push(`Description: ${pkg.description}`);
+    }
+    // 2) Detected stack signals — already cheap, reuse
+    if (detection.languages.length > 0) {
+        lines.push(`Languages: ${detection.languages.join(", ")}`);
+        for (const l of detection.languages)
+            tokens.add(l);
+    }
+    if (detection.frameworks.length > 0) {
+        lines.push(`Frameworks: ${detection.frameworks.join(", ")}`);
+        for (const f of detection.frameworks)
+            tokens.add(f);
+    }
+    if (detection.manifests.length > 0) {
+        const manifestNames = detection.manifests.map((m) => path.basename(m.file));
+        lines.push(`Manifests: ${manifestNames.join(", ")}`);
+        for (const m of manifestNames)
+            tokens.add(m);
+    }
+    lines.push("");
+    // 3) Top-level directory layout depth 2
+    const dirs = await readTopLevelDirs(cwd);
+    if (dirs.length > 0) {
+        lines.push("Top-level layout:");
+        for (const d of dirs) {
+            tokens.add(d.name);
+            if (d.children.length === 0) {
+                lines.push(`- \`${d.name}/\``);
+            }
+            else {
+                for (const c of d.children)
+                    tokens.add(`${d.name}/${c}`);
+                lines.push(`- \`${d.name}/\` — ${d.children.map((c) => `\`${c}/\``).join(", ")}`);
+            }
+        }
+        lines.push("");
+    }
+    // 4) Scripts + deps when package.json present
+    if (pkg) {
+        if (pkg.scripts.length > 0) {
+            lines.push(`Scripts: ${pkg.scripts.map((s) => `\`${s}\``).join(", ")}`);
+            for (const s of pkg.scripts)
+                tokens.add(s);
+        }
+        if (pkg.deps.length > 0) {
+            lines.push(`Key deps: ${pkg.deps.map((d) => `\`${d}\``).join(", ")}`);
+            for (const d of pkg.deps)
+                tokens.add(d);
+        }
+        if (pkg.scripts.length > 0 || pkg.deps.length > 0)
+            lines.push("");
+    }
+    // 5) README head — usually the highest-signal section
+    const readme = await readReadmeHead(cwd);
+    if (readme) {
+        lines.push("README head:");
+        lines.push(readme);
+        lines.push("");
+    }
+    lines.push("Rationales for ANY recommendation MUST cite at least ONE of these tokens (file path, dir, dep, script, or manifest). Generic rationales without a citation are invalid for this project.");
+    const markdown = capMarkdown(lines.join("\n"));
+    // Filter tokens to citable-quality (length >= 2, alphanumeric/path chars).
+    const citableTokens = Array.from(tokens).filter((t) => t.length >= 2 && /^[\w./@-]+$/.test(t));
+    return { markdown, citableTokens };
+}
+/**
+ * Test whether `rationale` cites at least one citable token from `brief`.
+ * Case-insensitive substring match. Empty/missing brief tokens → returns true
+ * (no expectations to check against).
+ */
+export function rationaleCitesBrief(rationale, brief) {
+    if (!brief || brief.citableTokens.length === 0)
+        return true;
+    const lower = rationale.toLowerCase();
+    return brief.citableTokens.some((t) => lower.includes(t.toLowerCase()));
+}
+//# sourceMappingURL=repo-brief.js.map

package/dist/src/product-loop/role-registry.js

@@ -116,7 +116,7 @@ export async function resolveRoles(opts) {
                 // Only apply if it's in inventory AND doesn't cause PO/Customer collision if slot is PO/Customer
                 const inInventory = inventory.find((m) => m.id === override.model);
                 if (inInventory) {
-                    const currentAssignment = assignments[slot];
+                    const _currentAssignment = assignments[slot];
                     // If we are overriding PO or Customer, we MUST ensure they remain different
                     if (slot === "PO") {
                         if (override.model === assignments.Customer.model)

package/dist/src/product-loop/sprint-planner.d.ts

@@ -0,0 +1,39 @@
+/**
+ * src/product-loop/sprint-planner.ts
+ *
+ * Converts a Backlog (P6 output) into a SprintPlan by:
+ *  1. Filtering to v1 items only.
+ *  2. Topo-sorting by blockers[] (items with no blockers first).
+ *  3. Greedy bin-packing items into sprints with target effort ≈ 8 pts.
+ *  4. Batch LLM call for sprint goal strings.
+ *  5. Updating each packed BacklogItem with status="in_sprint" + assigned_sprint.
+ *
+ * Model discipline: sprint goal generation uses
+ *   pickCouncilTaskModel("sprint_goal", leaderModelId, costAware=true)
+ * — NO hardcoded model id or provider in this file.
+ */
+import type { CouncilLLM } from "../council/types.js";
+import type { Backlog, SprintPlan } from "./types.js";
+export interface PlanSprintsInput {
+    runId: string;
+    backlog: Backlog;
+    llm: CouncilLLM;
+    leaderModelId: string;
+    costAware: boolean;
+    /** Default 8 effort points per sprint. */
+    targetEffortPerSprint?: number;
+}
+/**
+ * Build a SprintPlan from a Backlog.
+ * Also updates each picked BacklogItem in backlog.json with
+ * status="in_sprint" and assigned_sprint=sprint.id.
+ */
+export declare function planSprints(input: PlanSprintsInput): Promise<SprintPlan>;
+/**
+ * After planSprints(), call this to patch each BacklogItem in backlog.json
+ * with status="in_sprint" and assigned_sprint=sprint.id.
+ *
+ * Separated from planSprints() so that callers who persist the plan to disk
+ * can also trigger item updates without needing to re-read the plan.
+ */
+export declare function applySprintAssignments(flowDir: string, runId: string, plan: SprintPlan): Promise<void>;