codecartographer-pi 0.25.0 → 0.26.0

package/dist/core/broadside/models.js

@@ -0,0 +1,321 @@
+// The model catalog, pricing, benchmarks, and the per-repository batch-endpoint memory.
+//
+// Split out of core/broadside.ts (#339); the barrel there re-exports every
+// name, so `core/index.ts` and the tests see one module as before.
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { atomicWriteFile, pathExists } from "../utils.js";
+import { BROADSIDE_BENCHMARKS_URL, BROADSIDE_CATALOG_CACHE_FILE, BROADSIDE_CATALOG_CACHE_TTL_MS, BROADSIDE_ENDPOINTS_FILE, BROADSIDE_INPUT_PRICE_PER_M, BROADSIDE_MODEL, BROADSIDE_MODELS_URL, BROADSIDE_OUTPUT_PRICE_PER_M } from "./constants.js";
+import { BroadsideAuthError } from "./types.js";
+import { NO_BATCH_ENDPOINT_RE, describeBatchError } from "./client.js";
+// ---------- model catalog, pricing, benchmarks ----------
+/** The catalog cache schema this build writes; a file from another is not read. */
+export const BROADSIDE_CATALOG_CACHE_SCHEMA = 3;
+async function readCatalogCache(broadsideDir) {
+    const cachePath = join(broadsideDir, BROADSIDE_CATALOG_CACHE_FILE);
+    if (!(await pathExists(cachePath)))
+        return null;
+    try {
+        const parsed = JSON.parse(await readFile(cachePath, "utf8"));
+        if (!parsed || typeof parsed !== "object" || !parsed.models || typeof parsed.models !== "object")
+            return null;
+        if (parsed.schema_version !== BROADSIDE_CATALOG_CACHE_SCHEMA && parsed.schema_version !== 2)
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+/** When a cached entry was fetched: its own stamp, or the file's for a schema-2 cache. */
+function catalogEntryFetchedAt(cache, model) {
+    const stamp = cache.models[model]?.fetched_at ?? cache.fetched_at;
+    return new Date(stamp).getTime();
+}
+async function writeCatalogCache(broadsideDir, cache) {
+    await mkdir(broadsideDir, { recursive: true });
+    await writeFile(join(broadsideDir, BROADSIDE_CATALOG_CACHE_FILE), `${JSON.stringify(cache, null, "\t")}\n`, "utf8");
+}
+const BROADSIDE_ENDPOINTS_SCHEMA = 1;
+export async function readBatchEndpoints(broadsideDir) {
+    const path = join(broadsideDir, BROADSIDE_ENDPOINTS_FILE);
+    if (!(await pathExists(path)))
+        return {};
+    try {
+        const parsed = JSON.parse(await readFile(path, "utf8"));
+        if (!parsed || typeof parsed !== "object" || parsed.schema_version !== BROADSIDE_ENDPOINTS_SCHEMA)
+            return {};
+        if (!parsed.models || typeof parsed.models !== "object")
+            return {};
+        const out = {};
+        for (const [model, record] of Object.entries(parsed.models)) {
+            if (!record || typeof record !== "object")
+                continue;
+            if (record.status !== "accepted" && record.status !== "rejected")
+                continue;
+            if (typeof record.at !== "string")
+                continue;
+            out[model] = { status: record.status, at: record.at, ...(typeof record.error === "string" && { error: record.error }) };
+        }
+        return out;
+    }
+    catch {
+        // An unreadable memory is an empty one: it only annotates a listing.
+        return {};
+    }
+}
+/**
+ * The refusal OpenRouter returns for a catalog id that has no batch endpoint
+ * behind it. Matched loosely: the message is the only signal there is.
+ */
+/**
+ * Remember what a submit learned about each model it posted to. An accepted
+ * job proves the endpoint exists; a "does not have a :batch endpoint"
+ * refusal proves it does not. Any other rejection (quota, malformed request,
+ * auth) says nothing about the endpoint and leaves the record alone.
+ */
+export async function recordBatchEndpoints(broadsideDir, outcomes) {
+    const at = new Date().toISOString();
+    const updates = {};
+    for (const { model, batchId, error } of outcomes) {
+        if (batchId) {
+            updates[model] = { status: "accepted", at };
+            continue;
+        }
+        const message = describeBatchError(error);
+        if (message && NO_BATCH_ENDPOINT_RE.test(message)) {
+            updates[model] = { status: "rejected", at, error: message };
+        }
+    }
+    if (Object.keys(updates).length === 0)
+        return;
+    const models = { ...(await readBatchEndpoints(broadsideDir)), ...updates };
+    await mkdir(broadsideDir, { recursive: true });
+    const file = { schema_version: BROADSIDE_ENDPOINTS_SCHEMA, models };
+    await atomicWriteFile(join(broadsideDir, BROADSIDE_ENDPOINTS_FILE), `${JSON.stringify(file, null, "\t")}\n`);
+}
+function parseCatalogEntry(raw) {
+    const id = String(raw.id ?? "");
+    if (!id)
+        return null;
+    const p = (raw.pricing ?? {});
+    const input = typeof p.prompt === "string" ? Number(p.prompt) : NaN;
+    const output = typeof p.completion === "string" ? Number(p.completion) : NaN;
+    if (!Number.isFinite(input) || !Number.isFinite(output))
+        return null;
+    const cached = typeof p.cached_input === "string" ? Number(p.cached_input) : NaN;
+    const topProvider = (raw.top_provider ?? {});
+    const contextLength = typeof raw.context_length === "number" ? raw.context_length : undefined;
+    const maxCompletion = typeof topProvider.max_completion_tokens === "number" ? topProvider.max_completion_tokens : undefined;
+    return {
+        id,
+        name: String(raw.name ?? id),
+        inputPerM: input * 1_000_000,
+        outputPerM: output * 1_000_000,
+        cachedInputPerM: Number.isFinite(cached) ? cached * 1_000_000 : undefined,
+        contextLength,
+        maxCompletionTokens: maxCompletion,
+        supportedParameters: Array.isArray(raw.supported_parameters)
+            ? raw.supported_parameters.map((entry) => String(entry))
+            : [],
+        expirationDate: typeof raw.expiration_date === "string" ? raw.expiration_date : null,
+    };
+}
+export function builtInCatalogEntry(model) {
+    // The default model's rates are compile-time constants; its capabilities
+    // are asserted from the shipped configuration (1M context, 64K output,
+    // structured outputs used by every lens).
+    if (model !== BROADSIDE_MODEL)
+        return null;
+    return {
+        id: BROADSIDE_MODEL,
+        name: "Google: Gemini 3.7 Flash (batch)",
+        inputPerM: BROADSIDE_INPUT_PRICE_PER_M,
+        outputPerM: BROADSIDE_OUTPUT_PRICE_PER_M,
+        contextLength: 1_048_576,
+        maxCompletionTokens: 65_536,
+        supportedParameters: ["tools", "structured_outputs", "json_schema", "response_format"],
+        expirationDate: null,
+    };
+}
+export function builtInPricing(model) {
+    const entry = builtInCatalogEntry(model);
+    if (!entry)
+        return null;
+    return { inputPerM: entry.inputPerM, outputPerM: entry.outputPerM, source: "built-in" };
+}
+export async function resolveCatalogEntry(broadsideDir, config, model, apiKey, fetcher = fetch) {
+    // Manual overrides always win for pricing — the user is asserting a rate,
+    // and a config assertion is cheaper to respect than to second-guess.
+    // Capabilities stay unknown in that case: nothing is refused, nothing
+    // is clamped, and the submit text says the pricing came from config.
+    if (config.pricing) {
+        return {
+            model,
+            source: "config",
+            entry: {
+                id: model,
+                name: model,
+                inputPerM: config.pricing.inputPerM,
+                outputPerM: config.pricing.outputPerM,
+                supportedParameters: [],
+            },
+        };
+    }
+    // On-disk cache first, then the live catalog — for the default model too.
+    // Hardcoded rates used to short-circuit here, which meant a stale constant
+    // could never self-correct even though the catalog was already being
+    // fetched for every other model. The authoritative source wins; the
+    // constants below are what we fall back to when the network is unavailable.
+    const cache = await readCatalogCache(broadsideDir);
+    const cached = cache?.models[model];
+    if (cache && cached && Date.now() - catalogEntryFetchedAt(cache, model) < BROADSIDE_CATALOG_CACHE_TTL_MS) {
+        return { model, source: "cache", entry: cached };
+    }
+    // What went wrong when the live lookup produced nothing, for the error
+    // below: a 401 and a dead network used to read the same — "could not
+    // resolve per-token pricing" — or, for the default model, nothing at all.
+    let live = null;
+    let catalogFailure = null;
+    try {
+        const resp = await fetcher(BROADSIDE_MODELS_URL, {
+            method: "GET",
+            headers: { Authorization: `Bearer ${apiKey}` },
+            signal: AbortSignal.timeout(30_000),
+        });
+        if (resp.status === 401 || resp.status === 403) {
+            throw new BroadsideAuthError(resp.status, await responseDetail(resp));
+        }
+        if (resp.ok === false) {
+            catalogFailure = `the model catalog request failed (HTTP ${resp.status}${await responseDetail(resp).then((d) => (d ? `: ${d}` : ""))})`;
+        }
+        else {
+            const data = (await resp.json());
+            const hit = (data.data ?? []).find((m) => String(m.id) === model);
+            if (hit)
+                live = parseCatalogEntry(hit);
+            else
+                catalogFailure = `the model catalog has no entry for "${model}"`;
+        }
+    }
+    catch (error) {
+        if (error instanceof BroadsideAuthError)
+            throw error;
+        live = null;
+        catalogFailure = `the model catalog could not be fetched (${error instanceof Error ? error.message : String(error)})`;
+    }
+    if (live) {
+        const now = new Date().toISOString();
+        const updated = {
+            schema_version: BROADSIDE_CATALOG_CACHE_SCHEMA,
+            fetched_at: now,
+            // Other entries keep their own stamps (a schema-2 file's entries
+            // inherit the file's, once, on this upgrade); only this model is fresh.
+            models: Object.fromEntries(Object.entries(cache?.models ?? {}).map(([id, entry]) => [id, { ...entry, fetched_at: entry.fetched_at ?? cache.fetched_at }])),
+        };
+        updated.models[model] = { ...live, fetched_at: now };
+        await writeCatalogCache(broadsideDir, updated);
+        return { model, source: "live", entry: live };
+    }
+    // Offline fallback: the default model's rates and capabilities are known at
+    // compile time, so a network failure does not have to stop a run.
+    const builtIn = builtInCatalogEntry(model);
+    if (builtIn)
+        return { model, source: "built-in", entry: builtIn };
+    throw new Error(`Could not resolve per-token pricing for batch model "${model}": ${catalogFailure ?? "no catalog entry"}. ` +
+        "Set pricing.input_per_m and pricing.output_per_m in .codecarto/broadside/config.yaml " +
+        "(USD per million tokens), or check the model id against https://openrouter.ai/models?variant=batch.");
+}
+/** A short, safe excerpt of an error response body for a message. */
+async function responseDetail(resp) {
+    try {
+        if (typeof resp.text === "function") {
+            const text = (await resp.text()).trim();
+            try {
+                const parsed = JSON.parse(text);
+                const message = typeof parsed?.error === "string" ? parsed.error : parsed?.error?.message;
+                if (typeof message === "string" && message)
+                    return message.slice(0, 200);
+            }
+            catch {
+                // not JSON; fall through to the raw excerpt
+            }
+            return text.replace(/\s+/g, " ").slice(0, 200);
+        }
+        if (typeof resp.json === "function") {
+            const parsed = (await resp.json());
+            const message = typeof parsed?.error === "string" ? parsed.error : parsed?.error?.message;
+            return typeof message === "string" ? message.slice(0, 200) : "";
+        }
+    }
+    catch {
+        // an unreadable body adds nothing to the message
+    }
+    return "";
+}
+export async function resolveModelPricing(broadsideDir, config, model, apiKey, fetcher = fetch) {
+    const { source, entry } = await resolveCatalogEntry(broadsideDir, config, model, apiKey, fetcher);
+    if (!entry)
+        throw new Error(`No pricing resolved for ${model}.`);
+    return { inputPerM: entry.inputPerM, outputPerM: entry.outputPerM, source };
+}
+/** Base slug with the OpenRouter variant suffix (e.g. `:batch`) stripped. */
+export function baseSlug(modelId) {
+    const idx = modelId.indexOf(":");
+    return idx >= 0 ? modelId.slice(0, idx) : modelId;
+}
+export async function fetchCodingBenchmarks(apiKey, fetcher = fetch) {
+    try {
+        const resp = await fetcher(`${BROADSIDE_BENCHMARKS_URL}?source=artificial-analysis&task_type=coding`, {
+            method: "GET",
+            headers: { Authorization: `Bearer ${apiKey}` },
+            signal: AbortSignal.timeout(30_000),
+        });
+        const data = (await resp.json());
+        const byBaseSlug = {};
+        for (const row of data.data ?? []) {
+            const slug = baseSlug(String(row.model_permaslug ?? ""));
+            if (!slug)
+                continue;
+            const toIndex = (v) => (typeof v === "number" && Number.isFinite(v) ? v : undefined);
+            byBaseSlug[slug] = {
+                codingIndex: toIndex(row.coding_index),
+                intelligenceIndex: toIndex(row.intelligence_index),
+            };
+        }
+        return { byBaseSlug, meta: data.meta ?? {} };
+    }
+    catch {
+        return null;
+    }
+}
+export async function listBatchModels(broadsideDir, config, apiKey, opts = {}) {
+    const fetcher = opts.fetcher ?? fetch;
+    const resp = await fetcher(BROADSIDE_MODELS_URL, {
+        method: "GET",
+        headers: { Authorization: `Bearer ${apiKey}` },
+        signal: AbortSignal.timeout(30_000),
+    });
+    const data = (await resp.json());
+    const entries = [];
+    const seen = new Set();
+    for (const raw of data.data ?? []) {
+        const entry = parseCatalogEntry(raw);
+        if (!entry || seen.has(entry.id))
+            continue;
+        seen.add(entry.id);
+        if (!entry.id.endsWith(":batch"))
+            continue;
+        entries.push(entry);
+    }
+    entries.sort((a, b) => a.inputPerM + a.outputPerM - (b.inputPerM + b.outputPerM));
+    // Persist the catalog so the next submit's pricing resolution hits cache.
+    const fetchedAt = new Date().toISOString();
+    const cache = { schema_version: BROADSIDE_CATALOG_CACHE_SCHEMA, fetched_at: fetchedAt, models: {} };
+    for (const entry of entries)
+        cache.models[entry.id] = { ...entry, fetched_at: fetchedAt };
+    await writeCatalogCache(broadsideDir, cache);
+    const benchmarks = opts.includeBenchmarks ? await fetchCodingBenchmarks(apiKey, fetcher) : null;
+    const endpoints = await readBatchEndpoints(broadsideDir);
+    return { entries, source: "live", benchmarks, defaultModel: config.model, endpoints };
+}

package/dist/core/broadside/render.d.ts

@@ -0,0 +1,20 @@
+import { type BroadsideCollectResult, type BroadsideIncrementalOutcome, type BroadsideStateFile, type BroadsideSubmitResult, type CatalogEntry, type CodingBenchmarks } from "./types.ts";
+import { type LensDefinition } from "./lenses.ts";
+import { type BatchEndpointRecord } from "./models.ts";
+export declare function parseSynthesisTopFindings(content: string): BroadsideCollectResult["topFindings"];
+export declare function describeIncrementalFallback(reason: BroadsideIncrementalOutcome["reason"]): string;
+export declare function estimateSubmitText(result: BroadsideSubmitResult, lenses: LensDefinition[]): string;
+export declare function modelsText(entries: CatalogEntry[], opts: {
+    benchmarks: CodingBenchmarks | null;
+    defaultModel: string;
+    endpoints?: Record<string, BatchEndpointRecord>;
+}): string;
+export declare function collectResultText(result: BroadsideCollectResult): string;
+/**
+ * An `onStatus` callback that appends one line to `lines` per *change* of a
+ * lens's polled status. Every poll used to append a line, so a four-minute
+ * wait returned twenty-six identical "in_progress (0/1)" lines per lens
+ * before the result (0.22.0 live run).
+ */
+export declare function statusLineWriter(lines: string[]): (lensId: string, status: string, counts: Record<string, unknown>) => void;
+export declare function statusText(state: BroadsideStateFile): string;

package/dist/core/broadside/render.js

@@ -0,0 +1,285 @@
+// Markdown rendering of results and the text both surfaces print: estimates, collect reports, model listings, status.
+//
+// Split out of core/broadside.ts (#339); the barrel there re-exports every
+// name, so `core/index.ts` and the tests see one module as before.
+import { describeRedactions } from "../secrets.js";
+import { BROADSIDE_LENS_IDS } from "./constants.js";
+import { baseSlug } from "./models.js";
+import { explainBatchError } from "./client.js";
+import { parseLensJson } from "./results.js";
+// ---------- rendering ----------
+export function parseSynthesisTopFindings(content) {
+    try {
+        const parsed = (parseLensJson(content) ?? {});
+        const findings = Array.isArray(parsed.top_findings)
+            ? parsed.top_findings
+            : [];
+        return findings
+            .filter((f) => typeof f.title === "string")
+            .map((f) => ({
+            title: String(f.title),
+            severity: String(f.severity ?? "unknown"),
+            sourceLens: String(f.source_lens ?? "unknown"),
+            summary: String(f.summary ?? ""),
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+// ---------- formatting helpers for tool output ----------
+export function describeIncrementalFallback(reason) {
+    switch (reason) {
+        case "dirty-worktree":
+            return "the working tree has uncommitted changes, so there is no committed state to diff against";
+        case "no-baseline":
+            return "no earlier run recorded a commit to diff against";
+        case "diff-failed":
+            return "the diff against the previous run's commit could not be read";
+        default:
+            return "no baseline was available";
+    }
+}
+export function estimateSubmitText(result, lenses) {
+    // Count the lenses that actually got a batch, not every lens considered. A
+    // lens with nothing to scan is reported as `skipped (0 request(s))` two
+    // lines below, so counting it here made the header contradict its own body:
+    // a Rust CLI with no server surface reported "submitted 6 batch(es)" over a
+    // list showing four batches and two skips.
+    const entries = Object.values(result.batches ?? {});
+    const submittedCount = entries.filter((entry) => entry.batchId).length;
+    const withoutBatch = entries.length - submittedCount;
+    const lines = [
+        withoutBatch > 0
+            ? `Broad-Side submitted ${submittedCount} batch(es); ${withoutBatch} lens(es) produced none (see below).`
+            : `Broad-Side submitted ${submittedCount} batch(es).`,
+    ];
+    for (const lens of lenses) {
+        const entry = result.batches[lens.id];
+        if (!entry)
+            continue;
+        const status = entry.batchId ? `batch ${entry.batchId}` : entry.status;
+        const override = entry.model ? ` on ${entry.model}` : "";
+        // A rejected lens says why: the message is the only way to tell a
+        // catalog id with no batch endpoint from a full job quota, and both
+        // used to read as a bare "rejected". A skipped lens names the globs
+        // that matched nothing.
+        const reason = !entry.batchId && entry.error
+            ? ` — ${explainBatchError(entry.error)}`
+            : !entry.batchId && entry.reason
+                ? ` — ${entry.reason}`
+                : entry.fallback
+                    ? ` — ${entry.fallback}`
+                    : "";
+        lines.push(`  ${lens.name}: ${status} (${entry.requests} request(s), ~$${entry.estimatedCost.toFixed(4)})${override}${reason}`);
+    }
+    if (result.repo) {
+        const head = result.repo.sourceHead ? ` at ${result.repo.sourceHead.slice(0, 8)}${result.repo.sourceDirty ? " (dirty)" : ""}` : "";
+        const source = result.repo.snapshot === "working-tree" ? `working tree${head}` : "directory walk (not a git repository)";
+        lines.push(`Scanned as ${result.repo.language}: ${result.repo.sourceFiles} source file(s) from the ${source}.`);
+    }
+    if (result.redaction) {
+        const line = result.redaction.enabled
+            ? describeRedactions(result.redaction.values, result.redaction.files, result.redaction.skippedFiles)
+            : "Before upload: secret redaction is OFF (redact_secrets: false in config.yaml); files were sent as they are.";
+        if (line)
+            lines.push(line);
+    }
+    const incremental = result.incremental;
+    if (incremental?.requested) {
+        lines.push(incremental.applied
+            ? `Incremental: scanning only what changed since ${(incremental.baseHead ?? "").slice(0, 8)}.`
+            : `Incremental: requested but NOT applied — ${describeIncrementalFallback(incremental.reason)}. Every module was scanned, at full cost.`);
+    }
+    lines.push(`Estimated total: ~$${result.estimatedTotalCost.toFixed(4)}`, `Pricing: $${result.pricing.inputPerM.toFixed(4)}/M in, $${result.pricing.outputPerM.toFixed(4)}/M out (${result.pricing.source})`);
+    if (result.modelInfo.contextLength) {
+        lines.push(`Model: ${result.modelInfo.contextLength.toLocaleString()} context, ${result.modelInfo.maxCompletionTokens?.toLocaleString() ?? "?"} max output`);
+    }
+    if (result.modelInfo.supportsStructuredOutputs === false) {
+        lines.push("Warning: model does not advertise structured-output support; lens JSON may be unreliable.");
+    }
+    if (result.modelInfo.expirationDate) {
+        lines.push(`Warning: this model is deprecated (expires ${result.modelInfo.expirationDate}).`);
+    }
+    if (result.maxCost) {
+        lines.push(`Run limit: $${result.maxCost.toFixed(2)} (enforced on estimate; pass force to override)`);
+    }
+    lines.push(`Results will land in ${result.outputDir}/`, "Call codecarto_broadside with action 'collect' once batches finish, or pass wait_seconds on submit to block.", "Disclaimer: Broad-Side findings are unverified scouting signals from a batch model, not validated claims.");
+    return lines.join("\n");
+}
+export function modelsText(entries, opts) {
+    const endpoints = opts.endpoints ?? {};
+    const lines = [
+        `Batch models on OpenRouter (${entries.length}, cheapest first).`,
+        // The catalog over-reports: it returns a `:batch` id for models whose
+        // Batch API refuses the job, with nothing in the entry to tell them
+        // apart (#141). Say so before the table, not after it.
+        "Advisory: this is the catalog's list of :batch ids, not a list of working batch endpoints. Some ids are refused at submit " +
+            "(\"does not have a :batch endpoint\"), at no cost. Rows tagged [no batch endpoint …] or [batch OK …] carry what this " +
+            "repository's own submits found; an untagged row has not been tried here.",
+        "",
+        "id | $/M in | $/M out | ctx | max out | structured | coding idx",
+    ];
+    for (const entry of entries) {
+        const bench = opts.benchmarks?.byBaseSlug[baseSlug(entry.id)];
+        const structured = entry.supportedParameters.length === 0
+            ? "?"
+            : entry.supportedParameters.some((p) => ["structured_outputs", "json_schema", "response_format", "structuredoutputs"].includes(p.toLowerCase()))
+                ? "yes"
+                : "no";
+        const coding = bench?.codingIndex !== undefined ? bench.codingIndex.toFixed(1) : "-";
+        const ctx = entry.contextLength
+            ? entry.contextLength >= 1_000_000
+                ? `${(entry.contextLength / 1_000_000).toFixed(1)}M`
+                : `${(entry.contextLength / 1024).toFixed(0)}k`
+            : "?";
+        const out = entry.maxCompletionTokens ? `${(entry.maxCompletionTokens / 1024).toFixed(0)}k` : "?";
+        const tag = entry.id === opts.defaultModel ? "  (default)" : "";
+        const exp = entry.expirationDate ? "  [deprecated]" : "";
+        const record = endpoints[entry.id];
+        const seen = record
+            ? record.status === "rejected"
+                ? `  [no batch endpoint, refused ${record.at.slice(0, 10)}]`
+                : `  [batch OK ${record.at.slice(0, 10)}]`
+            : "";
+        lines.push(`${entry.id}${tag}${exp}${seen} | ${entry.inputPerM.toFixed(3)} | ${entry.outputPerM.toFixed(3)} | ${ctx} | ${out} | ${structured} | ${coding}`);
+    }
+    if (opts.benchmarks?.meta.as_of) {
+        lines.push("", `Benchmarks: Artificial Analysis coding index (as of ${String(opts.benchmarks.meta.as_of)}).`);
+    }
+    lines.push("", "Choose with the model parameter (--model= on Pi) for one run, lens_models (--lens-model=LENS:ID) per lens, or the model key in " +
+        ".codecarto/broadside/config.yaml for the repository. Higher coding index ≠ better scout: precision, context, structured-output " +
+        "support, and whether the model spends its output budget reasoning (see reasoning: in config.yaml) matter most here. " +
+        "A refused submit costs nothing, so probe an untried model on one lens first.");
+    return lines.join("\n");
+}
+export function collectResultText(result) {
+    const lines = [
+        `Broad-Side run ${result.runId}: ${result.status}`,
+        `  Results: ${result.resultCount} | Total cost: $${result.totalCost.toFixed(6)}`,
+    ];
+    for (const lensId of BROADSIDE_LENS_IDS) {
+        const outcome = result.lensOutcomes[lensId];
+        if (!outcome)
+            continue;
+        const truncation = outcome.truncated ? `, ${outcome.truncated} truncated` : "";
+        lines.push(`  ${lensId}: ${outcome.status}` +
+            (outcome.cost !== undefined ? `, $${outcome.cost.toFixed(6)}` : "") +
+            (outcome.resultCount !== undefined ? `, ${outcome.resultCount} result(s)` : "") +
+            truncation +
+            // The reason a lens did not complete, when the poll recorded one:
+            // an auth failure or a dead network used to read as a slow batch.
+            (outcome.error ? ` — ${outcome.error}` : ""));
+    }
+    if (result.retriedCount > 0) {
+        lines.push(`  ↻ ${result.retriedCount} truncated result(s) recovered by re-submission with a doubled output cap.`);
+    }
+    if (result.retryElsewhere) {
+        lines.push("  ↻ The truncation retry is in flight in another collect on this run; collect again for its result.");
+    }
+    if (result.retryError) {
+        lines.push(`  ↻ The truncation retry could not be submitted — ${result.retryError}. The truncated results stand as collected.`);
+    }
+    if (result.truncatedCount > 0) {
+        lines.push(`  ⚠ ${result.truncatedCount} result(s) still truncated after retry — their modules are unscouted, not clean.`);
+    }
+    // A pass still in flight or retired must appear: a run reported
+    // "completed" with no synthesis line read as "no synthesis was run",
+    // when the batch was running and a later collect would have claimed it
+    // (0.22.1 live run — the collect's wait ran out during the pass).
+    const passInFlight = (kind, entry) => {
+        if (entry.status === "submitted") {
+            lines.push(`  ${kind}: ${entry.batchId ? "still running" : "in flight in another collect"} — collect again for its result.`);
+        }
+        else if (entry.status === "failed") {
+            lines.push(`  ${kind}: failed${entry.error ? ` — ${explainBatchError(entry.error)}` : ""}`);
+        }
+    };
+    // Whether a pass was built from a verify pass's verdicts is part of what
+    // it is: a work order that ranked on batch severities alone is the one
+    // that put two dismissed casts above the confirmed finding (#338).
+    const builtFrom = (entry) => entry.verdicts ? ` (built from ${entry.verdicts} verdict${entry.verdicts === 1 ? "" : "s"})` : " (no verdicts)";
+    if (result.regenerated && result.regenerated.length > 0) {
+        lines.push(`  regenerated: ${result.regenerated.join(", ")}`);
+    }
+    if (result.synthesis.status === "completed") {
+        lines.push(`  synthesis: completed, $${(result.synthesis.cost ?? 0).toFixed(6)}${builtFrom(result.synthesis)}`);
+        if (result.topFindings.length > 0) {
+            lines.push("", result.synthesis.verdicts ? "Top findings (verdicts applied; unread ones are unverified leads):" : "Top findings (unverified leads):");
+            for (const f of result.topFindings.slice(0, 10)) {
+                lines.push(`  [${f.severity}] ${f.title}`);
+            }
+        }
+    }
+    else {
+        passInFlight("synthesis", result.synthesis);
+    }
+    if (result.triage.status === "completed") {
+        lines.push(`  triage: completed, $${(result.triage.cost ?? 0).toFixed(6)}${builtFrom(result.triage)}`);
+        if (result.topTriageItems.length > 0) {
+            lines.push("", result.triage.verdicts
+                ? "Triage — prioritized work order (confirmed findings first; re-verify the unread ones before acting):"
+                : "Triage — prioritized work order (re-verify before acting):");
+            for (const item of result.topTriageItems.slice(0, 10)) {
+                lines.push(`  ${item.priority} [${item.severity}/${item.module}] ${item.title}` +
+                    (item.effort_estimate ? ` (${item.effort_estimate})` : ""));
+            }
+        }
+    }
+    else {
+        passInFlight("triage", result.triage);
+    }
+    if (result.status === "completed" && !result.synthesis.verdicts && !result.triage.verdicts
+        && (result.synthesis.status === "completed" || result.triage.status === "completed")) {
+        lines.push("", "Run verify, then collect --regenerate, to rebuild the report and the work order from verdicts.");
+    }
+    lines.push("", "Disclaimer: Broad-Side findings are unverified scouting signals from a batch model, not validated claims.");
+    return lines.join("\n");
+}
+/**
+ * An `onStatus` callback that appends one line to `lines` per *change* of a
+ * lens's polled status. Every poll used to append a line, so a four-minute
+ * wait returned twenty-six identical "in_progress (0/1)" lines per lens
+ * before the result (0.22.0 live run).
+ */
+export function statusLineWriter(lines) {
+    const last = new Map();
+    return (lensId, status, counts) => {
+        const line = `  ${lensId}: ${status} (${counts.completed ?? 0}/${counts.total ?? "?"})`;
+        if (last.get(lensId) === line)
+            return;
+        last.set(lensId, line);
+        lines.push(line);
+    };
+}
+export function statusText(state) {
+    if (state.runs.length === 0) {
+        return "No Broad-Side runs recorded. Call codecarto_broadside with action 'submit' first.";
+    }
+    const lines = [];
+    for (const run of [...state.runs].reverse().slice(0, 3)) {
+        lines.push(`Run ${run.id} — ${run.status}`);
+        // Recorded since #248; a run from an older version has neither field.
+        if (run.language || run.snapshot) {
+            const head = run.sourceHead ? ` at ${run.sourceHead.slice(0, 8)}${run.sourceDirty ? " (dirty)" : ""}` : "";
+            const source = run.snapshot === "walk" ? "directory walk" : run.snapshot ? `working tree${head}` : "unknown source";
+            lines.push(`  scanned as ${run.language ?? "unknown"} from the ${source}`);
+        }
+        for (const lensId of BROADSIDE_LENS_IDS) {
+            const entry = run.batches[lensId];
+            if (!entry)
+                continue;
+            lines.push(`  ${lensId}: ${entry.status}${entry.batchId ? ` (${entry.batchId})` : ""}${entry.cost !== undefined ? `, $${entry.cost.toFixed(6)}` : ""}` +
+                (entry.status === "skipped" && entry.reason ? ` — ${entry.reason}` : entry.fallback ? ` — ${entry.fallback}` : ""));
+        }
+        const builtFrom = (entry) => entry?.status === "completed" ? (entry.verdicts ? ` (built from ${entry.verdicts} verdict${entry.verdicts === 1 ? "" : "s"})` : " (no verdicts)") : "";
+        lines.push(`  synthesis: ${run.synthesis.status}${builtFrom(run.synthesis)}`);
+        lines.push(`  triage: ${run.triage?.status ?? "pending"}${builtFrom(run.triage)}`);
+        if (run.verify) {
+            lines.push(`  verify: ${run.verify.status} — ${run.verify.confirmed} confirmed of ${run.verify.verified} read on ${run.verify.model}, $${run.verify.cost.toFixed(4)}`);
+        }
+        if (run.totalCost !== undefined)
+            lines.push(`  total cost: $${run.totalCost.toFixed(6)}`);
+    }
+    return lines.join("\n");
+}