codecartographer-pi 0.24.1 → 0.25.0

package/.codecarto/broadside/SKILL.md

@@ -35,6 +35,10 @@ not replace any phase; it tells phases where to look.
    it describes), **discarded** (the claim is wrong about the code, with the
    guard or line that shows it), or **unclear**. Start from the confirmed
    ones; treat a discarded one as answered unless the reasoning is thin.
+   Then make sure the work order was built from it: `status` shows
+   `triage: completed (built from N verdicts)`; if it says `(no verdicts)`,
+   run `collect --regenerate` (`regenerate_post_passes: true`) before
+   reading `triage.md`.
    Measured on this repository, the top twelve findings by severity were two
    real defects and ten that a look at the guard, the caller, or the tsconfig
    dismissed — the pass agreed with a reviewer on all twelve for about a cent
@@ -85,6 +89,7 @@ Broad-Side is an executable-surface feature. On the Pi extension:
 /codecarto-broadside status             # show recorded runs
 /codecarto-broadside models             # compare batch models
 /codecarto-broadside verify --top=10    # read the top findings against the source
+/codecarto-broadside collect --regenerate  # rebuild synthesis and triage from the verdicts
 ```
 
 On the MCP server:
@@ -95,6 +100,7 @@ codecarto_broadside {cwd, action: "collect"}                  # poll, save, synt
 codecarto_broadside {cwd, action: "status"}                   # show recorded runs
 codecarto_broadside {cwd, action: "models"}                   # compare batch models
 codecarto_broadside {cwd, action: "verify", top: 10}          # read the top findings against the source
+codecarto_broadside {cwd, action: "collect", regenerate_post_passes: true}   # rebuild synthesis and triage from the verdicts
 ```
 
 The `models` action lists every `:batch` variant on OpenRouter — pricing per
@@ -139,6 +145,16 @@ cap here, since a sync call's cost is known only when it returns: the pass
 stops before the next finding once the calls so far have reached it and
 reports `partial`. About a cent a finding on the default model.
 
+The post-passes read the verdicts when they exist: a synthesis or triage
+built after a `verify` ranks the confirmed findings first, drops the
+discarded ones, lists the not-a-defect ones apart in `omitted`, and says in
+its summary how many verdicts it was built from; `status` and the collect
+report show `(built from N verdicts)` or `(no verdicts)` on each pass. A run
+collected before it was verified has a work order built from batch
+severities alone — `collect --regenerate` (`regenerate_post_passes: true`)
+resets the settled passes and runs them again with the verdicts, for another
+post-pass pair's cost; a pass still in flight is left to finish.
+
 Two caveats apply to any model you pick. The `models` action lists every id
 OpenRouter advertises a `:batch` variant for, and many of those variants do not
 exist — submitting one returns `does not have a :batch endpoint`, with nothing in

package/.codecarto/workflow/scaffold-version.yaml

@@ -3,4 +3,4 @@
 # workspace's framework-owned files (GUIDE.md, templates/, workflow/ pipelines
 # and VALIDATE.md) predate the running release. Written at release time and
 # copied verbatim by init — never edit by hand.
-scaffold_version: 0.24.1
+scaffold_version: 0.25.0

package/README.md

@@ -395,15 +395,16 @@ codecarto_broadside {cwd, action: "submit", lenses: [...]}    # fire the batches
 codecarto_broadside {cwd, action: "status"}                   # what is in flight
 codecarto_broadside {cwd, action: "collect"}                  # poll, save, synthesize, triage
 codecarto_broadside {cwd, action: "verify", top: 10}          # read the top findings against the source
+codecarto_broadside {cwd, action: "collect", regenerate_post_passes: true}   # rebuild the report and work order from the verdicts
 ```
 
-A third action, `verify`, reads the top defect and security findings of a collected run against the real source — one sync-priced call each with read-only tools (`read_file`, `grep`, `list_dir`) confined to the repository — and writes `verified.md` with a verdict per finding: **confirmed** (a reachable failure, with the trigger), **not-a-defect**, **discarded**, or **unclear**. Measured on this repository, the top twelve findings by severity were two real defects and ten claims a look at the guard or the caller dismissed; the pass agreed with a reviewer on all twelve for a cent a finding. Read `verified.md` before `triage.md`.
+A third action, `verify`, reads the top defect and security findings of a collected run against the real source — one sync-priced call each with read-only tools (`read_file`, `grep`, `list_dir`) confined to the repository — and writes `verified.md` with a verdict per finding: **confirmed** (a reachable failure, with the trigger), **not-a-defect**, **discarded**, or **unclear**. Measured on this repository, the top twelve findings by severity were two real defects and ten claims a look at the guard or the caller dismissed; the pass agreed with a reviewer on all twelve for a cent a finding. Read `verified.md` before `triage.md` — and have `triage.md` built from it: the synthesis and triage passes rank on the verdicts when they exist (confirmed first, discarded dropped, not-a-defect listed apart), and `collect` with `regenerate_post_passes: true` (`--regenerate` on Pi) rebuilds both for a run that was collected before it was verified.
 
 Submit and collect are separate because batch jobs routinely take tens of minutes; collect is resumable and picks up whatever is still in flight (`wait_seconds: 0`, the default, polls once and returns), and two collects on one run — a retried tool call, a second session — never pay for the synthesis, triage, or truncation retry twice: each is claimed in the run's state before it is submitted, and a collect whose client has gone away stops polling and submits nothing further. Submit prices the run from the collected file sizes against the model's live per-token pricing (cached 24h) and refuses when the estimate exceeds `max_cost` — $1.00 unless the config or the call sets another value, `0` for no limit — unless `force: true` is passed — a pre-flight estimate, not a runtime stop. Actual spend lands in each run's `run-meta.json`.
 
 Repository defaults live in `.codecarto/broadside/config.yaml` (`model`, `api_key`, `default_lenses`, `max_cost`, `pricing` overrides, `lens_models`, `incremental`, `retry_truncated`, `include_synthesis`, `include_triage`, `wait_seconds`); an explicit tool parameter always wins. `lens_models` routes individual lenses to their own batch model — a stronger model changes security and defect findings far more than it changes an architecture map — and each override is priced, capability-checked, and clamped exactly like the default, with the estimate broken out per lens so a mixed-model run cannot be approved without seeing which lens costs what. CodeCartographer ships no stronger default: which model earns its price depends on your repository and budget, so compare candidates with the `models` action and choose — for one run with the `model` and `lens_models` parameters (Pi: `--model=ID`, `--lens-model=LENS:ID`), or for the repository in `config.yaml`. The `models` listing is advisory: OpenRouter's catalog returns a `:batch` id for some models its Batch API then refuses (`does not have a :batch endpoint`), at no cost, and nothing in the catalog tells them apart — so the listing tags the ids this repository's own submits have seen accepted or refused, and a refused lens says why in the submit report. `codecarto_skill {cwd, name: "broadside"}` returns the reading guide for a completed run, and unlike post-pipeline skills it is not gated on a finished pipeline.
 
-On the Pi extension the same run is `/codecarto-broadside [submit|collect|status|models|verify] [lenses…] [--model=ID] [--lens-model=LENS:ID] [--top=N]`, with tab-completion for actions, lens names, and flags and live per-lens progress while batches poll. The two surfaces differ in one deliberate place: MCP cannot ask a human, so it refuses a run over `max_cost` until you pass `force`; Pi shows the per-lens breakdown and asks, and your approval *is* the force flag. Neither surface takes an API key as a command argument — a key typed into a slash command lands in the session transcript.
+On the Pi extension the same run is `/codecarto-broadside [submit|collect|status|models|verify] [lenses…] [--model=ID] [--lens-model=LENS:ID] [--top=N] [--regenerate]`, with tab-completion for actions, lens names, and flags and live per-lens progress while batches poll. The two surfaces differ in one deliberate place: MCP cannot ask a human, so it refuses a run over `max_cost` until you pass `force`; Pi shows the per-lens breakdown and asks, and your approval *is* the force flag. Neither surface takes an API key as a command argument — a key typed into a slash command lands in the session transcript.
 
 Broad-Side needs runtime code, so firing a run is an executable-surface feature: Pi and MCP have it, the pure drop-in template does not (it carries only the reading guide).
 

package/agent-skill/codecartographer/references/broadside.md

@@ -99,7 +99,11 @@ Results land in `.codecarto/broadside/<run>/`. If `verified.md` is there, read
 it before anything else: `action: "verify"` has read the top defect and
 security findings against the source with read-only tools and given each a
 verdict (confirmed with its trigger, not-a-defect, discarded with the guard
-that shows it, unclear). Then, in this order:
+that shows it, unclear). The post-passes rank on those verdicts when they
+exist; a run collected before it was verified has a work order built from
+batch severities alone (`status` says `(no verdicts)`), and
+`action: "collect", regenerate_post_passes: true` rebuilds both passes from
+the verdicts for another post-pass pair's cost. Then, in this order:
 
 1. `synthesis.md` — executive summary, severity counts, top cross-lens
    findings, per-module risk.

package/dist/core/broadside.d.ts

@@ -226,6 +226,12 @@ export type BroadsideSynthesisEntry = {
     cost?: number;
     /** Why the pass was retired, when the batch reported one. */
     error?: string;
+    /**
+     * How many verification verdicts the pass was built from (#338): the
+     * `verified.json` a `verify` pass wrote before this pass was submitted.
+     * Absent when the pass was built from the lens findings alone.
+     */
+    verdicts?: number;
 };
 /** One triage item — a scouting lead turned into a work-order entry. */
 export type TriageItem = {
@@ -238,12 +244,8 @@ export type TriageItem = {
     effort_estimate: string;
     rationale: string;
 };
-export type BroadsideTriageEntry = {
-    batchId?: string;
-    status: "pending" | "submitted" | "completed" | "failed";
-    cost?: number;
-    error?: string;
-};
+/** The triage post-pass entry: the same shape as synthesis's. */
+export type BroadsideTriageEntry = BroadsideSynthesisEntry;
 /** Recorded on the run once a verification pass has run (#143); see core/broadside-verify.ts. */
 export type BroadsideVerifyEntry = {
     /** `completed`: every selected finding got a verdict; `partial`: the cost cap or an abort stopped it early. */
@@ -264,6 +266,8 @@ export type BroadsideRetryEntry = {
     }>;
     /** When the owning collect claimed the pass (#322). */
     claimedAt: string;
+    /** What the retry batches cost, once polled to completion. */
+    cost?: number;
 };
 /**
  * The parts of a run that cost money to submit and that exactly one collect
@@ -288,6 +292,11 @@ export type BroadsideRun = {
     retry?: BroadsideRetryEntry;
     /** The verification pass over the top findings, when one has run (#143). */
     verify?: BroadsideVerifyEntry;
+    /**
+     * What post-pass results that were later regenerated had cost (#338):
+     * money the run spent that no current entry accounts for.
+     */
+    retiredCost?: number;
     totalCost?: number;
     pricing?: ModelPricing;
     maxCost?: number;
@@ -505,6 +514,8 @@ export type BroadsideCollectResult = {
         summary: string;
     }[];
     topTriageItems: TriageItem[];
+    /** The post-passes this collect reset and re-ran on request (#338). */
+    regenerated?: Array<"synthesis" | "triage">;
 };
 type LensDefinition = {
     id: BroadsideLensId;
@@ -680,6 +691,17 @@ export declare function persistBroadsideRunMerging(broadsideDir: string, run: Br
  * flight elsewhere.
  */
 export declare function claimRunSlot(broadsideDir: string, run: BroadsideRun, slot: BroadsideRunSlot): Promise<boolean>;
+/**
+ * Put a run's settled post-passes back to `pending` on disk so the next
+ * claim re-runs them (#338). A pass another collect has in flight is left
+ * alone — its result is still coming. The replaced results' cost moves to
+ * `retiredCost`, so the run's total keeps counting money it spent. Returns
+ * the passes that were reset, in the order they will be re-run.
+ */
+export declare function resetRunPostPasses(broadsideDir: string, run: BroadsideRun, wanted: {
+    synthesis: boolean;
+    triage: boolean;
+}): Promise<Array<"synthesis" | "triage">>;
 export declare function loadBroadsideConfig(broadsideDir: string): Promise<BroadsideConfig>;
 /** The shipped defaults: what an absent config.yaml means. */
 export declare function defaultBroadsideConfig(): BroadsideConfig;
@@ -831,6 +853,39 @@ export declare function saveLensResults(runDir: string, lensId: BroadsideLensId,
  * "a resumed collect can finish whichever is still pending" true.
  */
 export declare function loadSavedLensResults(runDir: string, lenses: BroadsideLensId[]): Promise<StoredLensResult[]>;
+/**
+ * One verdict from a run's `verified.json` (written by the verify pass in
+ * `broadside-verify.ts`), reduced to what the post-passes are told.
+ */
+export type PostPassVerdict = {
+    lensId: string;
+    customId: string;
+    severity: string;
+    title: string;
+    location: string;
+    verdict: string;
+    confidence: string;
+    evidence: Array<{
+        file: string;
+        lines: string;
+        note: string;
+    }>;
+    reasoning: string;
+};
+/**
+ * The verdicts a verify pass left in the run directory, or null when none
+ * has run (#338). A file that does not parse is treated as absent: the
+ * post-passes then run from the findings alone, which is what they did
+ * before verdicts existed, and `status` shows the pass carried no verdicts.
+ */
+export declare function loadPostPassVerdicts(runDir: string): Promise<PostPassVerdict[] | null>;
+/**
+ * The verdicts as a section of the post-pass user message: one line per
+ * finding with the verdict, the evidence the verifier cited, and its
+ * reasoning, so the pass can rank on them rather than on the batch model's
+ * own severities (#338).
+ */
+export declare function renderPostPassVerdicts(verdicts: PostPassVerdict[]): string;
 export declare function runBroadsideCollect(cwd: string, apiKey: string, opts?: {
     waitMs?: number;
     includeSynthesis?: boolean;
@@ -853,6 +908,13 @@ export declare function runBroadsideCollect(cwd: string, apiKey: string, opts?:
     signal?: AbortSignal;
     /** Poll cadence override; tests drive the loop faster than 15 s. */
     pollIntervalMs?: number;
+    /**
+     * Reset the wanted post-passes of a collected run and run them again
+     * (#338) — after a `verify`, so the executive report and the work order
+     * are built from the verdicts. A pass still in flight is left to finish;
+     * a run whose lens batches are still running is refused.
+     */
+    regeneratePostPasses?: boolean;
 }): Promise<BroadsideCollectResult>;
 export declare function runBroadsideStatus(cwd: string): Promise<{
     state: BroadsideStateFile;

package/dist/core/broadside.js

@@ -1718,6 +1718,39 @@ export async function claimRunSlot(broadsideDir, run, slot) {
     });
     return owned;
 }
+/**
+ * Put a run's settled post-passes back to `pending` on disk so the next
+ * claim re-runs them (#338). A pass another collect has in flight is left
+ * alone — its result is still coming. The replaced results' cost moves to
+ * `retiredCost`, so the run's total keeps counting money it spent. Returns
+ * the passes that were reset, in the order they will be re-run.
+ */
+export async function resetRunPostPasses(broadsideDir, run, wanted) {
+    const reset = [];
+    await updateBroadsideStateAtomically(broadsideDir, (state) => {
+        const index = state.runs.findIndex((candidate) => candidate.id === run.id);
+        const onDisk = index === -1 ? run : state.runs[index];
+        for (const kind of ["synthesis", "triage"]) {
+            if (!wanted[kind])
+                continue;
+            const theirs = onDisk[kind] ?? { status: "pending" };
+            if (theirs.status !== "completed" && theirs.status !== "failed") {
+                // pending: nothing to reset; submitted: in flight elsewhere.
+                run[kind] = theirs;
+                continue;
+            }
+            if (theirs.cost)
+                onDisk.retiredCost = (onDisk.retiredCost ?? 0) + theirs.cost;
+            onDisk[kind] = { status: "pending" };
+            run[kind] = onDisk[kind];
+            run.retiredCost = onDisk.retiredCost;
+            reset.push(kind);
+        }
+        if (index === -1)
+            state.runs.push(run);
+    });
+    return reset;
+}
 /** Read a `reasoning:` block from config.yaml, ignoring anything malformed. */
 function parseReasoningConfig(raw) {
     if (raw === false)
@@ -2722,8 +2755,86 @@ async function loadStoredRequests(runDir) {
         return {};
     }
 }
-// ---------- post-lens passes: synthesis + triage ----------
-function buildSynthesisRequest(findingsText, truncatedNote, model) {
+/**
+ * The verdicts a verify pass left in the run directory, or null when none
+ * has run (#338). A file that does not parse is treated as absent: the
+ * post-passes then run from the findings alone, which is what they did
+ * before verdicts existed, and `status` shows the pass carried no verdicts.
+ */
+export async function loadPostPassVerdicts(runDir) {
+    const path = join(runDir, "verified.json");
+    if (!(await pathExists(path)))
+        return null;
+    try {
+        const parsed = JSON.parse(await readFile(path, "utf8"));
+        const findings = Array.isArray(parsed.findings) ? parsed.findings : [];
+        const verdicts = findings
+            .filter((f) => typeof f.title === "string" && typeof f.verdict === "string")
+            .map((f) => ({
+            lensId: String(f.lensId ?? ""),
+            customId: String(f.customId ?? ""),
+            severity: String(f.severity ?? ""),
+            title: String(f.title),
+            location: String(f.location ?? ""),
+            verdict: String(f.verdict),
+            confidence: String(f.confidence ?? ""),
+            evidence: Array.isArray(f.evidence)
+                ? f.evidence.map((e) => ({ file: String(e.file ?? ""), lines: String(e.lines ?? ""), note: String(e.note ?? "") }))
+                : [],
+            reasoning: String(f.reasoning ?? ""),
+        }));
+        return verdicts.length > 0 ? verdicts : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The verdicts as a section of the post-pass user message: one line per
+ * finding with the verdict, the evidence the verifier cited, and its
+ * reasoning, so the pass can rank on them rather than on the batch model's
+ * own severities (#338).
+ */
+export function renderPostPassVerdicts(verdicts) {
+    const counts = new Map();
+    for (const v of verdicts)
+        counts.set(v.verdict, (counts.get(v.verdict) ?? 0) + 1);
+    const tally = [...counts.entries()].map(([verdict, n]) => `${n} ${verdict}`).join(", ");
+    const lines = [
+        "",
+        `## Verification verdicts (${verdicts.length} finding(s) read against the source by a read-only-tools pass: ${tally})`,
+        "",
+        "A verdict outranks the batch severity of the finding it names. `confirmed` means the verifier found a reachable " +
+            "failure and named its trigger; `not-a-defect` means the claim is literally true of the code but nothing reaches the " +
+            "failure it describes; `discarded` means the claim is wrong about the code; `unclear` means the code alone could not " +
+            "settle it; `error` means the pass could not read it — treat that finding as unverified. Findings not listed here " +
+            "were not read and stay unverified leads.",
+        "",
+    ];
+    for (const v of verdicts) {
+        const evidence = v.evidence.map((e) => `${e.file}${e.lines ? `:${e.lines}` : ""}${e.note ? ` (${e.note})` : ""}`).join("; ");
+        lines.push(`- [${v.verdict}${v.confidence ? `, ${v.confidence} confidence` : ""}] ${v.lensId}/${v.customId} — [${v.severity}] ${v.title}` +
+            `${v.location ? ` @ ${v.location}` : ""}` +
+            `${v.reasoning ? `\n  Reasoning: ${v.reasoning.replace(/\s+/g, " ").trim()}` : ""}` +
+            `${evidence ? `\n  Evidence: ${evidence}` : ""}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+const SYNTHESIS_VERDICT_INSTRUCTIONS = " A verification pass has read some of the findings against the source; its verdicts follow the reports. " +
+    "Lead top_findings with the confirmed findings and begin each such summary with 'verified: confirmed — ' and the " +
+    "trigger the verifier named; keep an unclear one with 'verified: unclear — '. A discarded or not-a-defect finding " +
+    "does not appear in top_findings and is not counted in severity_summary. Say in the executive summary how many " +
+    "findings were verified and how the verdicts split; findings the pass did not read remain unverified, and the " +
+    "summary says so of them, not of the confirmed ones.";
+const TRIAGE_VERDICT_INSTRUCTIONS = " A verification pass has read some of the findings against the source; its verdicts follow the findings. " +
+    "A confirmed finding ranks above every unverified finding of the same or lower severity: put the confirmed " +
+    "findings at the top of the queue and begin each one's rationale with 'verified: confirmed — ' and the trigger " +
+    "the verifier named. Keep an unclear finding in the queue with 'verified: unclear — ' in its rationale. Do not " +
+    "queue a discarded or not-a-defect finding: list each in omitted, beginning with 'verified: discarded — ' or " +
+    "'verified: not a defect — ' and the reason the pass gave. Findings the pass did not read stay unverified leads, " +
+    "and the summary says how many verdicts the queue was built from.";
+function buildSynthesisRequest(findingsText, truncatedNote, model, verdicts = null) {
     return {
         custom_id: "synthesis",
         body: {
@@ -2739,13 +2850,15 @@ function buildSynthesisRequest(findingsText, truncatedNote, model) {
                         "synthesis_report schema. Prioritize the most actionable findings. " +
                         "Be honest about gaps — if a lens found nothing, say 'no issues found' rather than " +
                         "inventing problems. These are scouting signals from a batch model, not verified " +
-                        "claims; note that in the summary.",
+                        "claims; note that in the summary." +
+                        (verdicts ? SYNTHESIS_VERDICT_INSTRUCTIONS : ""),
                 },
                 {
                     role: "user",
                     content: "Synthesize these analysis reports into a single summary.\n\n" +
                         findingsText +
                         truncatedNote +
+                        (verdicts ? renderPostPassVerdicts(verdicts) : "") +
                         "\nReturn the synthesis_report JSON schema.",
                 },
             ],
@@ -2754,7 +2867,7 @@ function buildSynthesisRequest(findingsText, truncatedNote, model) {
         },
     };
 }
-function buildTriageRequest(findingsText, truncatedNote, model) {
+function buildTriageRequest(findingsText, truncatedNote, model, verdicts = null) {
     return {
         custom_id: "triage",
         body: {
@@ -2771,13 +2884,15 @@ function buildTriageRequest(findingsText, truncatedNote, model) {
                         "too vague to act on and record each drop in omitted with the reason. These findings " +
                         "are UNVERIFIED scouting signals from a cheap batch model: the queue is a starting " +
                         "point for re-verification, not a commitment — say so in the summary, and never " +
-                        "inflate a severity you cannot see evidence for.",
+                        "inflate a severity you cannot see evidence for." +
+                        (verdicts ? TRIAGE_VERDICT_INSTRUCTIONS : ""),
                 },
                 {
                     role: "user",
                     content: "Triage these scouting findings into a prioritized work order.\n\n" +
                         findingsText +
                         truncatedNote +
+                        (verdicts ? renderPostPassVerdicts(verdicts) : "") +
                         "\nReturn the triage_report JSON schema.",
                 },
             ],
@@ -3020,7 +3135,10 @@ export async function runBroadsideCollect(cwd, apiKey, opts = {}) {
                 continue;
             const group = byModel.get(model);
             const usage = (batch.usage ?? {});
-            totalCost += typeof usage.cost === "number" ? usage.cost : 0;
+            // Kept on the entry, not just added to this collect's running total:
+            // a later collect on the run used to report a total without it.
+            if (typeof usage.cost === "number")
+                run.retry = { ...run.retry, cost: (run.retry?.cost ?? 0) + usage.cost };
             const results = Array.isArray(batch.results) ? batch.results : [];
             for (const result of results) {
                 const stored = group.slices.get(String(result.custom_id ?? ""));
@@ -3058,6 +3176,23 @@ export async function runBroadsideCollect(cwd, apiKey, opts = {}) {
     let topTriageItems = [];
     const wantSynthesis = opts.includeSynthesis !== false;
     const wantTriage = opts.includeTriage !== false;
+    // A regenerate resets the wanted, settled passes to pending on disk first —
+    // the merging persist keeps whatever is further along on disk, so an
+    // in-memory reset alone would be undone by the next persist (#338).
+    let regenerated = [];
+    if (opts.regeneratePostPasses) {
+        if (!wantSynthesis && !wantTriage) {
+            throw new Error("Nothing to regenerate: both post-passes are disabled for this collect.");
+        }
+        const lensesSettled = run.lenses.every((lensId) => {
+            const entry = run.batches[lensId];
+            return entry && BROADSIDE_TERMINAL_ENTRY_STATUSES.includes(entry.status);
+        });
+        if (!lensesSettled) {
+            throw new Error(`Cannot regenerate the post-passes of run ${run.id}: its lens batches are still running — collect them first.`);
+        }
+        regenerated = await resetRunPostPasses(broadsideDir, run, { synthesis: wantSynthesis, triage: wantTriage });
+    }
     // A resumed collect polls nothing — every lens is already terminal — so the
     // findings the post-passes need have to come back off disk, or a run whose
     // first collect was interrupted could never produce its executive report
@@ -3080,6 +3215,9 @@ export async function runBroadsideCollect(cwd, apiKey, opts = {}) {
             const findingsText = allLensResults
                 .map((r) => `## ${r.lensId} — ${r.customId}\n\n${r.content}\n`)
                 .join("\n");
+            // A verify pass that ran before this point leaves its verdicts in the
+            // run directory; the post-passes rank on them when present (#338).
+            const verdicts = await loadPostPassVerdicts(runDir);
             const truncatedNote = truncatedCount > 0
                 ? `\n\nNOTE: ${truncatedCount} lens result(s) were truncated at the output token limit and are ` +
                     "not included above. Any gap they would have covered is unrepresented — do not treat " +
@@ -3101,12 +3239,17 @@ export async function runBroadsideCollect(cwd, apiKey, opts = {}) {
                 if (!(await claimRunSlot(broadsideDir, run, kind)))
                     continue;
                 owned.add(kind);
+                const entry = kind === "synthesis" ? run.synthesis : run.triage;
+                if (verdicts)
+                    entry.verdicts = verdicts.length;
+                else
+                    delete entry.verdicts;
                 passes.push({
                     kind,
                     request: kind === "synthesis"
-                        ? buildSynthesisRequest(findingsText, truncatedNote, run.model)
-                        : buildTriageRequest(findingsText, truncatedNote, run.model),
-                    entry: kind === "synthesis" ? run.synthesis : run.triage,
+                        ? buildSynthesisRequest(findingsText, truncatedNote, run.model, verdicts)
+                        : buildTriageRequest(findingsText, truncatedNote, run.model, verdicts),
+                    entry,
                 });
             }
             const submitted = new Map();
@@ -3164,7 +3307,6 @@ export async function runBroadsideCollect(cwd, apiKey, opts = {}) {
                     const cost = typeof usage.cost === "number" ? usage.cost : undefined;
                     pass.entry.status = "completed";
                     pass.entry.cost = cost;
-                    totalCost += cost ?? 0;
                     const results = Array.isArray(batch.results) ? batch.results : [];
                     const content = results.length > 0 ? extractContent(results[0]) : null;
                     if (content !== null) {
@@ -3200,6 +3342,11 @@ export async function runBroadsideCollect(cwd, apiKey, opts = {}) {
         return entry && BROADSIDE_TERMINAL_ENTRY_STATUSES.includes(entry.status);
     });
     run.status = terminal ? (resultCount > 0 ? "completed" : "failed") : "partial";
+    // The run's total is the sum of what its entries record, not of what this
+    // collect happened to poll: a repeat collect used to report — and persist
+    // — a total without the post-passes and the retry an earlier collect had
+    // settled, so the recorded cost of a run went down each time it was read.
+    totalCost += (run.retry?.cost ?? 0) + (run.synthesis.cost ?? 0) + (run.triage.cost ?? 0) + (run.retiredCost ?? 0);
     run.totalCost = totalCost;
     await persist();
     await writeFile(join(runDir, "run-meta.json"), `${JSON.stringify({
@@ -3239,6 +3386,7 @@ export async function runBroadsideCollect(cwd, apiKey, opts = {}) {
         triage: run.triage,
         topFindings,
         topTriageItems,
+        ...(regenerated.length > 0 && { regenerated }),
     };
 }
 export async function runBroadsideStatus(cwd) {
@@ -3521,10 +3669,17 @@ export function collectResultText(result) {
             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)}`);
+        lines.push(`  synthesis: completed, $${(result.synthesis.cost ?? 0).toFixed(6)}${builtFrom(result.synthesis)}`);
         if (result.topFindings.length > 0) {
-            lines.push("", "Top findings (unverified leads):");
+            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}`);
             }
@@ -3534,9 +3689,11 @@ export function collectResultText(result) {
         passInFlight("synthesis", result.synthesis);
     }
     if (result.triage.status === "completed") {
-        lines.push(`  triage: completed, $${(result.triage.cost ?? 0).toFixed(6)}`);
+        lines.push(`  triage: completed, $${(result.triage.cost ?? 0).toFixed(6)}${builtFrom(result.triage)}`);
         if (result.topTriageItems.length > 0) {
-            lines.push("", "Triage — prioritized work order (re-verify before acting):");
+            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})` : ""));
@@ -3546,6 +3703,10 @@ export function collectResultText(result) {
     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");
 }
@@ -3585,8 +3746,9 @@ export function statusText(state) {
             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}` : ""));
         }
-        lines.push(`  synthesis: ${run.synthesis.status}`);
-        lines.push(`  triage: ${run.triage?.status ?? "pending"}`);
+        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)}`);
         }

package/dist/extensions/codecarto/auto-runner.d.ts

@@ -97,4 +97,11 @@ export type AutoDecision = {
 };
 export declare function decideAfterPhase(phaseStatus: SinglePhaseResult["status"], phaseError: string | undefined, validation: ValidationResult | null, strict: boolean): AutoDecision;
 export declare function runAuto(ctx: ExtensionContext, pi: ExtensionAPI, initialState: WorkspaceState, options: AutoRunOptions): Promise<AutoRunResult>;
+/**
+ * The one-line notification for an auto run's end. A run that stopped short
+ * carries its reason: the auto-summary message and the widget carry it too,
+ * but under `pi -p` neither is rendered, and "stopped: 0/1 phases" alone
+ * sent a reader back to the code to find out why (#347).
+ */
+export declare function describeAutoOutcome(result: AutoRunResult): string;
 export declare function buildAutoSummary(result: AutoRunResult, availableSkills?: string[]): string;

package/dist/extensions/codecarto/auto-runner.js

@@ -305,6 +305,19 @@ export async function runAuto(ctx, pi, initialState, options) {
 // ----------------------------------------------------------------------------
 // buildAutoSummary — the codecarto-auto-summary message body
 // ----------------------------------------------------------------------------
+/**
+ * The one-line notification for an auto run's end. A run that stopped short
+ * carries its reason: the auto-summary message and the widget carry it too,
+ * but under `pi -p` neither is rendered, and "stopped: 0/1 phases" alone
+ * sent a reader back to the code to find out why (#347).
+ */
+export function describeAutoOutcome(result) {
+    const line = `Auto pipeline ${result.outcome}: ${result.phasesRun.length}/${result.totalPhases} phases.`;
+    if (result.outcome === "complete")
+        return line;
+    const reason = result.reason.trim();
+    return reason ? `${line.replace(/\.$/, "")} — ${reason}` : line;
+}
 export function buildAutoSummary(result, availableSkills = []) {
     const totalTokens = result.totalTokens.input + result.totalTokens.output;
     const wallTime = formatMillis(result.endedAt - result.startedAt);

package/dist/extensions/codecarto/broadside-flags.d.ts

@@ -24,11 +24,13 @@ export interface BroadsideFlags {
     lensModels?: Partial<Record<BroadsideLensId, string>>;
     /** For verify: how many findings to read (#143). */
     top?: number;
+    /** For collect: reset the settled post-passes and run them again (#338). */
+    regeneratePostPasses?: boolean;
     benchmarks: boolean;
     unknown: string[];
     /** Set on an invalid combination. The caller surfaces it as an error. */
     error?: string;
 }
 /** Every token the completer offers, in the order it offers them. */
-export declare const KNOWN_BROADSIDE_TOKENS: readonly ["submit", "collect", "status", "models", "verify", "architecture", "api", "security", "defect", "conventions", "porting", "--incremental", "--no-incremental", "--max-cost=", "--wait=", "--run=", "--model=", "--lens-model=", "--top=", "--no-synthesis", "--no-triage", "--no-retry-truncated", "--benchmarks"];
+export declare const KNOWN_BROADSIDE_TOKENS: readonly ["submit", "collect", "status", "models", "verify", "architecture", "api", "security", "defect", "conventions", "porting", "--incremental", "--no-incremental", "--max-cost=", "--wait=", "--run=", "--model=", "--lens-model=", "--top=", "--regenerate", "--no-synthesis", "--no-triage", "--no-retry-truncated", "--benchmarks"];
 export declare function parseBroadsideFlags(args: string): BroadsideFlags;

package/dist/extensions/codecarto/broadside-flags.js

@@ -7,6 +7,7 @@
 //   /codecarto-broadside status
 //   /codecarto-broadside models --benchmarks
 //   /codecarto-broadside verify --top=10       → read the top findings against the source
+//   /codecarto-broadside collect --regenerate  → rebuild synthesis and triage from the verdicts
 //
 // Flags mirror the codecarto_broadside tool parameters, with the negative
 // forms spelled out because a slash command has no place to pass `false`:
@@ -18,6 +19,7 @@
 //   --model=ID (submit: the run's batch model, as listed by models; verify: the sync model to read with)
 //   --lens-model=LENS:ID (submit only, repeatable: one lens on its own model)
 //   --top=N (verify only: how many findings to read, most severe first)
+//   --regenerate (collect only: reset the settled post-passes and run them again, verdicts included)
 //
 // A model id itself contains a colon (`vendor/name:batch`), so --lens-model
 // splits on the first colon only: `security:deepseek/deepseek-v4-pro:batch`.
@@ -47,6 +49,7 @@ export const KNOWN_BROADSIDE_TOKENS = [
     "--model=",
     "--lens-model=",
     "--top=",
+    "--regenerate",
     "--no-synthesis",
     "--no-triage",
     "--no-retry-truncated",
@@ -107,6 +110,10 @@ export function parseBroadsideFlags(args) {
             result.retryTruncated = false;
             continue;
         }
+        if (token === "--regenerate") {
+            result.regeneratePostPasses = true;
+            continue;
+        }
         if (token === "--benchmarks") {
             result.benchmarks = true;
             continue;
@@ -188,6 +195,12 @@ export function parseBroadsideFlags(args) {
     if (result.top !== undefined && result.action !== "verify") {
         result.error ??= `--top is only meaningful for verify (got action "${result.action}").`;
     }
+    if (result.regeneratePostPasses && result.action !== "collect") {
+        result.error ??= `--regenerate is only meaningful for collect (got action "${result.action}").`;
+    }
+    if (result.regeneratePostPasses && result.includeSynthesis === false && result.includeTriage === false) {
+        result.error ??= "--regenerate with both --no-synthesis and --no-triage leaves nothing to regenerate.";
+    }
     if (result.action === "verify" && result.waitSeconds !== undefined) {
         result.error ??= "--wait is only meaningful for submit and collect; verify runs to completion.";
     }

package/dist/extensions/codecarto/index.js

@@ -1,6 +1,6 @@
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { basename, dirname, join, resolve } from "node:path";
-import { autoCompletePhase, buildAutoSummary, isPhaseRunning, runAuto, runSinglePhase } from "./auto-runner.js";
+import { autoCompletePhase, buildAutoSummary, describeAutoOutcome, isPhaseRunning, runAuto, runSinglePhase } from "./auto-runner.js";
 import { disposeAgentsWidget } from "./agent-widget.js";
 import { parseDashboardFlags } from "./dashboard-flags.js";
 import { narrateDashboard } from "./dashboard-narrator.js";
@@ -638,7 +638,7 @@ export default function codeCartographerExtension(pi) {
                 });
                 lastFeedbackLines = [`Auto pipeline ${result.outcome}: ${result.reason}`];
                 await refreshWorkspaceUi(ctx, lastFeedbackLines);
-                notifyCtx(ctx, `Auto pipeline ${result.outcome}: ${result.phasesRun.length}/${result.totalPhases} phases.`, result.outcome === "complete" ? "info" : "warning");
+                notifyCtx(ctx, describeAutoOutcome(result), result.outcome === "complete" ? "info" : "warning");
                 return;
             }
             const outcome = resolvePipelineOutcome(state);
@@ -995,7 +995,7 @@ export default function codeCartographerExtension(pi) {
         },
     });
     pi.registerCommand("codecarto-broadside", {
-        description: "Batch reconnaissance (Broad-Side): /codecarto-broadside [submit|collect|status|models|verify] [lenses…] [--model=ID] [--lens-model=LENS:ID] [--top=N] [flags]",
+        description: "Batch reconnaissance (Broad-Side): /codecarto-broadside [submit|collect|status|models|verify] [lenses…] [--model=ID] [--lens-model=LENS:ID] [--top=N] [--regenerate] [flags]",
         // Completes the token under the cursor, so lens names and flags are
         // offered after the action too, and keeps everything typed before it.
         getArgumentCompletions: (prefix) => completeLastToken(prefix, KNOWN_BROADSIDE_TOKENS.map((value) => ({ value }))),
@@ -1220,6 +1220,7 @@ export default function codeCartographerExtension(pi) {
                     retryTruncated,
                     onStatus,
                     ...(flags.runId && { runId: flags.runId }),
+                    ...(flags.regeneratePostPasses && { regeneratePostPasses: true }),
                 });
                 const lines = collectResultText(collect).split("\n");
                 const done = collect.status === "completed";

package/dist/mcp-server/server.d.ts

@@ -248,6 +248,7 @@ export declare function handleBroadside(args: {
     model?: string;
     lens_models?: Record<string, string>;
     top?: number;
+    regenerate_post_passes?: boolean;
 }): Promise<{
     content: {
         type: "text";

package/dist/mcp-server/server.js

@@ -1212,6 +1212,12 @@ export async function handleBroadside(args) {
         });
     }
     // action === "collect"
+    if (args.regenerate_post_passes !== undefined && typeof args.regenerate_post_passes !== "boolean") {
+        throw new McpError(ErrorCode.InvalidParams, "regenerate_post_passes must be a boolean.");
+    }
+    if (args.regenerate_post_passes && !includeSynthesis && !includeTriage) {
+        throw new McpError(ErrorCode.InvalidParams, "regenerate_post_passes needs at least one of include_synthesis and include_triage.");
+    }
     const collect = await runBroadsideCollect(cwd, apiKey, {
         waitMs,
         includeSynthesis,
@@ -1219,6 +1225,7 @@ export async function handleBroadside(args) {
         retryTruncated,
         signal: serverLifetime?.signal,
         ...(runId && { runId }),
+        ...(args.regenerate_post_passes && { regeneratePostPasses: true }),
     }).catch((error) => {
         throw new McpError(ErrorCode.InvalidRequest, error instanceof Error ? error.message : String(error));
     });
@@ -1232,6 +1239,7 @@ export async function handleBroadside(args) {
         lensOutcomes: collect.lensOutcomes,
         synthesis: collect.synthesis,
         triage: collect.triage,
+        ...(collect.regenerated && { regenerated: collect.regenerated }),
         topFindings: collect.topFindings,
         topTriageItems: collect.topTriageItems,
     });
@@ -1540,7 +1548,7 @@ const TOOLS = [
                 action: {
                     type: "string",
                     enum: ["submit", "collect", "status", "models", "verify"],
-                    description: "submit fires all lens batches and returns batch ids; collect polls submitted batches, saves results, and optionally runs the synthesis pass; status shows recorded runs; models lists batch-capable models with pricing and capabilities; verify reads a collected run's top defect and security findings against the repository with read-only tools (one sync-priced call each, about a cent on the default model) and writes verified.md/verified.json beside triage.md with a verdict per finding: confirmed (a reachable failure, with the trigger), not-a-defect, discarded, or unclear.",
+                    description: "submit fires all lens batches and returns batch ids; collect polls submitted batches, saves results, and optionally runs the synthesis and triage passes — built from verified.json when a verify pass has already written it, so run verify first or collect again with regenerate_post_passes afterwards; status shows recorded runs; models lists batch-capable models with pricing and capabilities; verify reads a collected run's top defect and security findings against the repository with read-only tools (one sync-priced call each, about a cent on the default model) and writes verified.md/verified.json beside triage.md with a verdict per finding: confirmed (a reachable failure, with the trigger), not-a-defect, discarded, or unclear.",
                 },
                 lenses: {
                     type: "array",
@@ -1575,6 +1583,10 @@ const TOOLS = [
                     type: "boolean",
                     description: "Re-submit lens results that came back truncated at the output token limit, once, with a doubled output cap. Falls back to retry_truncated in .codecarto/broadside/config.yaml (default true).",
                 },
+                regenerate_post_passes: {
+                    type: "boolean",
+                    description: "collect only: reset the run's settled synthesis and triage passes and run them again, so a verify pass's verdicts (verified.json) are built into the executive report and the work order — confirmed findings first, discarded ones dropped, not-a-defect ones listed apart. Costs another post-pass pair (a few cents); a pass still in flight is left to finish; a run whose lens batches are still running is refused.",
+                },
                 max_cost: {
                     type: "number",
                     description: "Approximate run expense limit in USD. The submit action estimates the run cost from slice sizes and the configured model's per-token pricing (live OpenRouter lookup, cached 24h) and refuses to submit when the estimate exceeds the limit unless force is true. For verify it is a running cap: the pass stops before the next finding once the calls so far have reached it. Falls back to max_cost in .codecarto/broadside/config.yaml, whose default is $1.00; pass 0 for no limit.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codecartographer-pi",
-  "version": "0.24.1",
+  "version": "0.25.0",
   "mcpName": "io.github.HuginnIndustries/codecartographer",
   "description": "Turn an unfamiliar codebase into a validated reimplementation spec, then synthesize confirmed specs and a product vision into a traceable plan.",
   "type": "module",