muonroi-cli 1.8.3 → 1.8.5

package/dist/src/council/debate-checkpoint.d.ts

@@ -0,0 +1,129 @@
+/**
+ * src/council/debate-checkpoint.ts
+ *
+ * C (mid-debate checkpoint) — persist the CB-1 council debate's per-round state
+ * so a break mid-debate (provider 5xx on round 5, host crash, cap breach) can
+ * resume from the last completed round instead of re-running the whole debate.
+ *
+ * The debate accumulates all state in RAM (`exchangeLogs`, `active`,
+ * `runningSummary`, `archive`, convergence trackers). Without a checkpoint a
+ * break loses every round — a 5-round multi-provider debate must restart from
+ * round 1. This module owns the on-disk snapshot: `runDebate` writes it after
+ * each completed round and deletes it on normal completion; the resume path
+ * reads it and seeds `runDebate` so it skips research + openings + completed
+ * rounds.
+ *
+ * File: `<checkpointDir>/debate-checkpoint.json` (checkpointDir = the run dir,
+ * `.muonroi-flow/runs/<runId>`). Written atomically (tmp + rename) so a crash
+ * mid-write can never leave a half-JSON file.
+ */
+import type { ClarifiedSpec, CouncilParticipant, DebateArchiveEntry } from "./types.js";
+/** Bump when the checkpoint shape changes incompatibly so stale files are ignored. */
+export declare const DEBATE_CHECKPOINT_VERSION: 1;
+export declare const DEBATE_CHECKPOINT_FILE = "debate-checkpoint.json";
+/**
+ * Serializable snapshot of an in-flight debate, written after each completed
+ * discussion round. `exchangeLogs` (a `Map`) is stored as entry tuples since
+ * JSON has no Map; everything else in the payload is already JSON-native.
+ */
+export interface DebateCheckpoint {
+    version: typeof DEBATE_CHECKPOINT_VERSION;
+    /**
+     * Identity guard — the checkpoint is only restored when it matches the debate
+     * about to run. `problemStatement` pins the spec; `participantModels` pins the
+     * panel. A mismatch (spec changed, panel re-resolved differently) => ignore
+     * the stale checkpoint and run the debate fresh rather than splice wrong state.
+     */
+    problemStatement: string;
+    participantModels: string[];
+    /** Rounds fully completed (transcript + summary persisted). Resume starts at roundCount+1. */
+    roundCount: number;
+    /** Current round budget after any leader/user extensions. */
+    maxRounds: number;
+    /** Accumulated per-pair transcript (Map<pairKey, turns[]> serialized as entries). */
+    exchangeLogs: Array<[string, string[]]>;
+    /** Latest inter-round summary. */
+    runningSummary: string;
+    /** Research findings (so the research phase is not re-run on resume). */
+    researchFindings?: string;
+    /** Surviving participants with their latest position + stance (so openings are not re-run). */
+    active: CouncilParticipant[];
+    /** Citation archive accumulated so far. */
+    archive: DebateArchiveEntry[];
+    /** Convergence continuity: last round's per-criterion met flags. */
+    lastCriteriaMet: boolean[];
+    /** B4 auto-remedy high-water mark of pinned criteria met. */
+    bestCriteriaMetCount: number;
+    /** B4 consecutive evaluated rounds with no new met criterion. */
+    roundsSinceProgress: number;
+    /** Topic carried into the next round from the prior leader nextRoundFocus. */
+    nextTopic?: string;
+    /** Wall-clock the checkpoint was written (ISO). Diagnostics only. */
+    savedAt: string;
+}
+/** Input to {@link buildDebateCheckpoint} — the live round-loop locals. */
+export interface DebateCheckpointInput {
+    problemStatement: string;
+    roundCount: number;
+    maxRounds: number;
+    exchangeLogs: Map<string, string[]>;
+    runningSummary: string;
+    researchFindings?: string;
+    active: CouncilParticipant[];
+    archive: DebateArchiveEntry[];
+    lastCriteriaMet: boolean[];
+    bestCriteriaMetCount: number;
+    roundsSinceProgress: number;
+    nextTopic?: string;
+    /** ISO timestamp; the caller supplies it (Date.now is unavailable in some sandboxes). */
+    savedAt: string;
+}
+/** Build the serializable checkpoint payload from live debate state. */
+export declare function buildDebateCheckpoint(input: DebateCheckpointInput): DebateCheckpoint;
+/** Rehydrate `exchangeLogs` from the serialized entry tuples. */
+export declare function restoreExchangeLogs(cp: DebateCheckpoint): Map<string, string[]>;
+/**
+ * Whether `cp` describes the debate that is about to run. Guards against
+ * splicing a stale checkpoint (different question, re-resolved panel) into a
+ * fresh debate. Participant order is not significant; the model SET must match.
+ */
+export declare function checkpointMatches(cp: DebateCheckpoint, problemStatement: string, participantModels: string[]): boolean;
+/**
+ * Atomically write the checkpoint to `<dir>/debate-checkpoint.json`.
+ * Non-fatal: a checkpoint write failure must never break the live debate — it
+ * only forfeits resumability for that round. Logs with context (No-Silent-Catch).
+ */
+export declare function writeDebateCheckpoint(dir: string, cp: DebateCheckpoint): Promise<void>;
+/**
+ * Read + parse the checkpoint. Returns null when absent or unparseable (a
+ * corrupt checkpoint must not crash resume — the debate just runs fresh).
+ */
+export declare function readDebateCheckpoint(dir: string): Promise<DebateCheckpoint | null>;
+/**
+ * Delete the checkpoint (debate completed normally, or the run was aborted).
+ * Non-fatal — a leftover checkpoint is only re-validated (and discarded on
+ * mismatch) on the next resume, never silently mis-applied.
+ */
+export declare function deleteDebateCheckpoint(dir: string): Promise<void>;
+export declare const DEBATE_INPUTS_FILE = "debate-inputs.json";
+/**
+ * C-v2 — the minimal gather-stage outputs needed to re-enter the council debate
+ * on a fresh session (cross-process resume) WITHOUT re-running the interactive
+ * discovery + interview. Persisted once at debate start; the loop-driver resume
+ * entry restores `clarifiedSpec` + `conversationContext` and jumps straight to
+ * the research/debate stage (participants + leader are re-resolved from the
+ * session model deterministically, then matched against the checkpoint panel).
+ */
+export interface DebateInputs {
+    version: typeof DEBATE_CHECKPOINT_VERSION;
+    problemStatement: string;
+    clarifiedSpec: ClarifiedSpec;
+    conversationContext: string;
+    savedAt: string;
+}
+/** Atomically persist the debate inputs. Non-fatal on failure (forfeits cross-session resume only). */
+export declare function writeDebateInputs(dir: string, inputs: DebateInputs): Promise<void>;
+/** Read the debate inputs. Returns null when absent/unparseable/version-mismatched. */
+export declare function readDebateInputs(dir: string): Promise<DebateInputs | null>;
+/** Delete the debate inputs (debate + scoping finished, or run aborted). Non-fatal. */
+export declare function deleteDebateInputs(dir: string): Promise<void>;

package/dist/src/council/debate-checkpoint.js

@@ -0,0 +1,176 @@
+/**
+ * src/council/debate-checkpoint.ts
+ *
+ * C (mid-debate checkpoint) — persist the CB-1 council debate's per-round state
+ * so a break mid-debate (provider 5xx on round 5, host crash, cap breach) can
+ * resume from the last completed round instead of re-running the whole debate.
+ *
+ * The debate accumulates all state in RAM (`exchangeLogs`, `active`,
+ * `runningSummary`, `archive`, convergence trackers). Without a checkpoint a
+ * break loses every round — a 5-round multi-provider debate must restart from
+ * round 1. This module owns the on-disk snapshot: `runDebate` writes it after
+ * each completed round and deletes it on normal completion; the resume path
+ * reads it and seeds `runDebate` so it skips research + openings + completed
+ * rounds.
+ *
+ * File: `<checkpointDir>/debate-checkpoint.json` (checkpointDir = the run dir,
+ * `.muonroi-flow/runs/<runId>`). Written atomically (tmp + rename) so a crash
+ * mid-write can never leave a half-JSON file.
+ */
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+/** Bump when the checkpoint shape changes incompatibly so stale files are ignored. */
+export const DEBATE_CHECKPOINT_VERSION = 1;
+export const DEBATE_CHECKPOINT_FILE = "debate-checkpoint.json";
+/** Build the serializable checkpoint payload from live debate state. */
+export function buildDebateCheckpoint(input) {
+    return {
+        version: DEBATE_CHECKPOINT_VERSION,
+        problemStatement: input.problemStatement,
+        participantModels: input.active.map((p) => p.model),
+        roundCount: input.roundCount,
+        maxRounds: input.maxRounds,
+        exchangeLogs: [...input.exchangeLogs.entries()].map(([k, v]) => [k, [...v]]),
+        runningSummary: input.runningSummary,
+        researchFindings: input.researchFindings,
+        active: input.active,
+        archive: input.archive,
+        lastCriteriaMet: [...input.lastCriteriaMet],
+        bestCriteriaMetCount: input.bestCriteriaMetCount,
+        roundsSinceProgress: input.roundsSinceProgress,
+        nextTopic: input.nextTopic,
+        savedAt: input.savedAt,
+    };
+}
+/** Rehydrate `exchangeLogs` from the serialized entry tuples. */
+export function restoreExchangeLogs(cp) {
+    return new Map(cp.exchangeLogs.map(([k, v]) => [k, [...v]]));
+}
+/**
+ * Whether `cp` describes the debate that is about to run. Guards against
+ * splicing a stale checkpoint (different question, re-resolved panel) into a
+ * fresh debate. Participant order is not significant; the model SET must match.
+ */
+export function checkpointMatches(cp, problemStatement, participantModels) {
+    if (cp.version !== DEBATE_CHECKPOINT_VERSION)
+        return false;
+    if (cp.roundCount < 1)
+        return false; // nothing useful to resume from
+    if (cp.problemStatement !== problemStatement)
+        return false;
+    const a = [...cp.participantModels].sort();
+    const b = [...participantModels].sort();
+    if (a.length !== b.length)
+        return false;
+    return a.every((m, i) => m === b[i]);
+}
+/**
+ * Atomically write the checkpoint to `<dir>/debate-checkpoint.json`.
+ * Non-fatal: a checkpoint write failure must never break the live debate — it
+ * only forfeits resumability for that round. Logs with context (No-Silent-Catch).
+ */
+export async function writeDebateCheckpoint(dir, cp) {
+    const finalPath = path.join(dir, DEBATE_CHECKPOINT_FILE);
+    const tmpPath = `${finalPath}.${process.pid}.tmp`;
+    try {
+        await fs.mkdir(dir, { recursive: true });
+        await fs.writeFile(tmpPath, JSON.stringify(cp), "utf8");
+        await fs.rename(tmpPath, finalPath);
+    }
+    catch (err) {
+        console.error(`[debate-checkpoint] write failed (dir=${dir}, round=${cp.roundCount}): ${err?.message}`);
+        // Best-effort cleanup of the temp file; ignore if it never got created.
+        await fs.rm(tmpPath, { force: true }).catch(() => { });
+    }
+}
+/**
+ * Read + parse the checkpoint. Returns null when absent or unparseable (a
+ * corrupt checkpoint must not crash resume — the debate just runs fresh).
+ */
+export async function readDebateCheckpoint(dir) {
+    const finalPath = path.join(dir, DEBATE_CHECKPOINT_FILE);
+    let raw;
+    try {
+        raw = await fs.readFile(finalPath, "utf8");
+    }
+    catch (err) {
+        if (err?.code !== "ENOENT") {
+            console.error(`[debate-checkpoint] read failed (dir=${dir}): ${err?.message}`);
+        }
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed?.version !== DEBATE_CHECKPOINT_VERSION)
+            return null;
+        return parsed;
+    }
+    catch (err) {
+        console.error(`[debate-checkpoint] parse failed (dir=${dir}): ${err?.message}`);
+        return null;
+    }
+}
+/**
+ * Delete the checkpoint (debate completed normally, or the run was aborted).
+ * Non-fatal — a leftover checkpoint is only re-validated (and discarded on
+ * mismatch) on the next resume, never silently mis-applied.
+ */
+export async function deleteDebateCheckpoint(dir) {
+    const finalPath = path.join(dir, DEBATE_CHECKPOINT_FILE);
+    try {
+        await fs.rm(finalPath, { force: true });
+    }
+    catch (err) {
+        console.error(`[debate-checkpoint] delete failed (dir=${dir}): ${err?.message}`);
+    }
+}
+// ── Debate inputs (C-v2 cross-session resume) ────────────────────────────────
+export const DEBATE_INPUTS_FILE = "debate-inputs.json";
+/** Atomically persist the debate inputs. Non-fatal on failure (forfeits cross-session resume only). */
+export async function writeDebateInputs(dir, inputs) {
+    const finalPath = path.join(dir, DEBATE_INPUTS_FILE);
+    const tmpPath = `${finalPath}.${process.pid}.tmp`;
+    try {
+        await fs.mkdir(dir, { recursive: true });
+        await fs.writeFile(tmpPath, JSON.stringify(inputs), "utf8");
+        await fs.rename(tmpPath, finalPath);
+    }
+    catch (err) {
+        console.error(`[debate-checkpoint] inputs write failed (dir=${dir}): ${err?.message}`);
+        await fs.rm(tmpPath, { force: true }).catch(() => { });
+    }
+}
+/** Read the debate inputs. Returns null when absent/unparseable/version-mismatched. */
+export async function readDebateInputs(dir) {
+    const finalPath = path.join(dir, DEBATE_INPUTS_FILE);
+    let raw;
+    try {
+        raw = await fs.readFile(finalPath, "utf8");
+    }
+    catch (err) {
+        if (err?.code !== "ENOENT") {
+            console.error(`[debate-checkpoint] inputs read failed (dir=${dir}): ${err?.message}`);
+        }
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed?.version !== DEBATE_CHECKPOINT_VERSION)
+            return null;
+        return parsed;
+    }
+    catch (err) {
+        console.error(`[debate-checkpoint] inputs parse failed (dir=${dir}): ${err?.message}`);
+        return null;
+    }
+}
+/** Delete the debate inputs (debate + scoping finished, or run aborted). Non-fatal. */
+export async function deleteDebateInputs(dir) {
+    try {
+        await fs.rm(path.join(dir, DEBATE_INPUTS_FILE), { force: true });
+    }
+    catch (err) {
+        console.error(`[debate-checkpoint] inputs delete failed (dir=${dir}): ${err?.message}`);
+    }
+}
+//# sourceMappingURL=debate-checkpoint.js.map

package/dist/src/council/debate-planner.js

@@ -3,6 +3,7 @@ import { z } from "zod";
 import { loadKeyForProvider } from "../providers/keychain.js";
 import { createProviderFactory, detectProviderForModel, resolveModelRuntime } from "../providers/runtime.js";
 import { withDeadlineRace, withTimeoutSignal } from "../utils/llm-deadline.js";
+import { logger } from "../utils/logger.js";
 import { getProviderStallTimeoutMs } from "../utils/settings.js";
 import { tracedGenerate } from "./llm.js";
 import { buildDebatePlanPrompt } from "./prompts.js";
@@ -94,6 +95,37 @@ function injectAuditorStance(plan, eeWarnings, experienceMode) {
     }
     return { ...plan, stances };
 }
+/**
+ * PIL task types whose deliverable is understanding/evaluation of something that
+ * already exists — never a build. The user asked to assess, not to implement.
+ */
+const ANALYSIS_TASK_TYPES = new Set(["analyze"]);
+function isAnalysisTaskType(taskType) {
+    return !!taskType && ANALYSIS_TASK_TYPES.has(taskType);
+}
+/**
+ * Deterministic backstop for post-debate drift (session c4f78752a316).
+ *
+ * PIL is the authoritative intent classifier. When it says the request is
+ * analysis/evaluation, the leader LLM must not be allowed to silently reshape the
+ * debate into an `implementation_plan` — that shape makes the post-debate AskCard
+ * default to "generate_plan" (build a plan) via pickPostDebateRecommendation,
+ * which is the wrong next step for a request that only wanted an assessment.
+ *
+ * The prompt already asks the leader to honor the intent (soft), but LLMs drift;
+ * this coerces a drifted shape back to "evaluation" so the synthesis stays the
+ * deliverable and the default action becomes save_exit. Non-implementation shapes
+ * are left untouched.
+ */
+function enforceAnalysisIntentShape(plan, taskType) {
+    if (!isAnalysisTaskType(taskType))
+        return plan;
+    if (plan.outputShape.kind !== "implementation_plan")
+        return plan;
+    logger.info("orchestrator", `[debate-planner] PIL taskType=${taskType} (analysis) but leader chose implementation_plan; ` +
+        "coercing outputShape.kind→evaluation to honor analysis intent");
+    return { ...plan, outputShape: { ...plan.outputShape, kind: "evaluation" } };
+}
 export async function* planDebate(spec, leaderModelId, llm, eeWarnings, // CQ-13: experience snippets to seed prompt
 experienceMode, // CQ-14: controls Experience Auditor injection
 taskType, // CQ-11: task type from PIL (e.g. "architecture", "bugfix")
@@ -101,6 +133,10 @@ complexityTier, // CQ-11: complexity tier from PIL (e.g. "heavy", "medium", "lig
 signal) {
     const eeSnippets = eeWarnings?.map((w) => w.text).filter(Boolean) ?? [];
     const { system: baseSystem, prompt } = buildDebatePlanPrompt(spec);
+    // Every return path funnels through here: auditor + product-stance injection,
+    // plus the deterministic analysis-intent backstop (applied first so a coerced
+    // shape doesn't get a spurious product stance injected for it).
+    const finalizePlan = (plan) => ensureProductStance(injectAuditorStance(enforceAnalysisIntentShape(plan, taskType), eeWarnings, experienceMode));
     // Build calibration context from PIL metadata
     const pilCalibration = [];
     if (taskType)
@@ -111,6 +147,18 @@ signal) {
     if (pilCalibration.length > 0) {
         system += `\n\n## Task Context (from PIL)\n${pilCalibration.join("\n")}`;
     }
+    // Hard intent lock (steers stances AND shape). PIL already classified this as
+    // analysis; the deterministic backstop in finalizePlan enforces it regardless,
+    // but steering the leader here keeps the whole roster/synthesis on-intent.
+    if (isAnalysisTaskType(taskType)) {
+        system +=
+            `\n\n## INTENT LOCK (authoritative)\n` +
+                `PIL classified this request as ANALYSIS/EVALUATION (taskType=${taskType}). The user wants to ` +
+                `understand and assess what ALREADY exists — not to build anything. ` +
+                `outputShape.kind MUST be "evaluation" or "investigation" — NEVER "implementation_plan". ` +
+                `Do NOT propose building, implementing, scaffolding, or "I'll spec that in vN". ` +
+                `Stances must be analyst/critic/investigator voices, not implementers.`;
+    }
     if (eeSnippets.length > 0) {
         system += `\n\n## Experience Warnings (from brain)\nNote these past mistakes when designing debate stances:\n${eeSnippets.map((s) => `- ${s}`).join("\n")}`;
     }
@@ -158,7 +206,7 @@ signal) {
                 outputShape,
                 plannedRounds,
             };
-            return ensureProductStance(injectAuditorStance(plan, eeWarnings, experienceMode));
+            return finalizePlan(plan);
         }
         // Invalid even with schema — fall through to retry with a sanitize-failure message
         throw new Error("Sanitize check failed: stances.length < 2 or outputShape is null");
@@ -180,7 +228,7 @@ signal) {
             });
             const retryParsed = parsePlan(retryRaw);
             if (retryParsed)
-                return ensureProductStance(injectAuditorStance(retryParsed, eeWarnings, experienceMode));
+                return finalizePlan(retryParsed);
         }
         catch (retryErr) {
             yield {
@@ -190,7 +238,7 @@ signal) {
         }
     }
     // All attempts exhausted — return fallback
-    return ensureProductStance(injectAuditorStance(FALLBACK_PLAN, eeWarnings, experienceMode));
+    return finalizePlan(FALLBACK_PLAN);
 }
 function parsePlan(raw) {
     try {

package/dist/src/council/debate-summary.d.ts

@@ -0,0 +1,25 @@
+/**
+ * src/council/debate-summary.ts
+ *
+ * Fallback debate-summary synthesis.
+ *
+ * The /ideal research phase persists the debate into `research.md` +
+ * `delegations.md` from `DebateState.runningSummary`. But a debate that returns
+ * after opening statements (e.g. the leader routes straight to the preflight
+ * gate without evaluation rounds) leaves `runningSummary` empty — and the whole
+ * debate (opening positions, design/impl reasoning) was silently dropped from
+ * the canonical artifacts, surviving only in TUI scrollback.
+ *
+ * This builds a faithful fallback from the participants' latest positions
+ * (`active[]`), falling back to per-round archive excerpts, so the research
+ * artifact ALWAYS captures the debate. Pure + synchronous → unit-testable.
+ */
+import type { DebateState } from "./types.js";
+/**
+ * Return a markdown summary of the debate suitable for `research.md` /
+ * `delegations.md`. Prefers `state.runningSummary` when present; otherwise
+ * synthesizes one from `active[]` positions, then `archive[]` excerpts. Returns
+ * "" only when there is genuinely nothing to show (no summary, no positions, no
+ * archive) — callers keep their existing "(no summary produced)" placeholder.
+ */
+export declare function resolveDebateSummary(state: Pick<DebateState, "runningSummary" | "active" | "archive">): string;

package/dist/src/council/debate-summary.js

@@ -0,0 +1,85 @@
+/**
+ * src/council/debate-summary.ts
+ *
+ * Fallback debate-summary synthesis.
+ *
+ * The /ideal research phase persists the debate into `research.md` +
+ * `delegations.md` from `DebateState.runningSummary`. But a debate that returns
+ * after opening statements (e.g. the leader routes straight to the preflight
+ * gate without evaluation rounds) leaves `runningSummary` empty — and the whole
+ * debate (opening positions, design/impl reasoning) was silently dropped from
+ * the canonical artifacts, surviving only in TUI scrollback.
+ *
+ * This builds a faithful fallback from the participants' latest positions
+ * (`active[]`), falling back to per-round archive excerpts, so the research
+ * artifact ALWAYS captures the debate. Pure + synchronous → unit-testable.
+ */
+/** Cap so the fallback can't balloon the artifact; per-position + overall. */
+const PER_POSITION_CHARS = 4000;
+const TOTAL_CHARS = 16000;
+/**
+ * Return a markdown summary of the debate suitable for `research.md` /
+ * `delegations.md`. Prefers `state.runningSummary` when present; otherwise
+ * synthesizes one from `active[]` positions, then `archive[]` excerpts. Returns
+ * "" only when there is genuinely nothing to show (no summary, no positions, no
+ * archive) — callers keep their existing "(no summary produced)" placeholder.
+ */
+export function resolveDebateSummary(state) {
+    const running = state.runningSummary?.trim();
+    if (running)
+        return running;
+    const fromPositions = summarizeFromActive(state.active);
+    if (fromPositions)
+        return fromPositions;
+    return summarizeFromArchive(state.archive);
+}
+function speakerLabel(role, stanceName) {
+    return stanceName?.trim() ? `${stanceName} (${role})` : role;
+}
+function summarizeFromActive(active) {
+    if (!Array.isArray(active) || active.length === 0)
+        return "";
+    const parts = [
+        "_(Synthesized from participants' final positions — the debate produced no running summary.)_",
+        "",
+    ];
+    let total = 0;
+    for (const p of active) {
+        const position = (p.position ?? "").trim();
+        if (!position)
+            continue;
+        const clipped = position.length > PER_POSITION_CHARS ? `${position.slice(0, PER_POSITION_CHARS)}…` : position;
+        const block = `### ${speakerLabel(p.role, p.stance?.name)}\n\n${clipped}`;
+        if (total + block.length > TOTAL_CHARS) {
+            parts.push("_(remaining positions truncated)_");
+            break;
+        }
+        parts.push(block, "");
+        total += block.length;
+    }
+    // Only the header + no real positions → nothing worth persisting.
+    return parts.length > 2 ? parts.join("\n").trimEnd() : "";
+}
+function summarizeFromArchive(archive) {
+    if (!Array.isArray(archive) || archive.length === 0)
+        return "";
+    const parts = [
+        "_(Synthesized from per-round debate excerpts — the debate produced no running summary.)_",
+        "",
+    ];
+    let total = 0;
+    for (const e of archive) {
+        const excerpt = (e.excerpt ?? "").trim();
+        if (!excerpt)
+            continue;
+        const block = `### Round ${e.round} — ${speakerLabel(e.role, e.stanceName)}\n\n${excerpt}`;
+        if (total + block.length > TOTAL_CHARS) {
+            parts.push("_(remaining excerpts truncated)_");
+            break;
+        }
+        parts.push(block, "");
+        total += block.length;
+    }
+    return parts.length > 2 ? parts.join("\n").trimEnd() : "";
+}
+//# sourceMappingURL=debate-summary.js.map