@jitsusama/agentic-harness.core 0.1.0

package/dist/review/ask/agents.js

@@ -0,0 +1,296 @@
+/**
+ * Agents another harness already defined in the repo under review.
+ *
+ * A repo that has been worked in for a while has usually accumulated
+ * some: a reviewer, an architect, a debugger, each written by somebody
+ * who knew that codebase. They are lenses, which is what a persona is,
+ * and they are already there, which is more than can be said for any
+ * lens this tool ships. Offering them costs a directory read.
+ *
+ * Three rules make that safe, and the third is the one that matters.
+ *
+ * They are namespaced, because a roster naming a lens and silently
+ * getting the repo's version of it is the quiet substitution
+ * `bindPersonas` refuses: the findings still file under the name, and
+ * whoever reads them weighs them as the lens they asked for.
+ *
+ * Only the prose comes across. Measured across fifteen agent files on
+ * this machine, thirteen name tools and six name a model, in
+ * vocabulary that belongs to the harness that wrote them: `sonnet` is
+ * not a model pi resolves and `Bash, Read, Edit` are not tools it has.
+ *
+ * And the change under review may not be the thing that wrote them. A
+ * charter becomes the reviewer's `--system-prompt`, on a child holding
+ * bash and write, with its working directory inside the tree, and that
+ * tree is pinned to the commit under review. So without this rule the
+ * author of a change writes the standing instruction of the agent
+ * reviewing it, and the operator's consent is worth little, since the
+ * listing they chose from read a different tree. A lens the diff
+ * touches is refused. What remains is the repo's committed state,
+ * which is the same trust already extended to every other line in it.
+ *
+ * Reading the directory is somebody else's job, as it is for personas.
+ * This module is handed the files.
+ */
+import { parse as parseYaml } from "yaml";
+import { splitFrontmatter } from "./persona.js";
+/** The prefix that keeps these out of the persona namespace. */
+export const NAMESPACE = "repo:";
+/**
+ * How much charter a lens may carry.
+ *
+ * A charter becomes an argument on a child process, so unbounded is
+ * not a size, it is a limit somebody else picks. The longest agent
+ * file measured on this machine is 926 lines, which fits; a file that
+ * does not is refused rather than truncated, since half a charter is a
+ * lens nobody wrote.
+ */
+const MOST_CHARTER = 64_000;
+/** What text costs where the limit actually is, in bytes. */
+function weight(text) {
+    return new TextEncoder().encode(text).length;
+}
+/**
+ * Whether a path from a diff and a path from a directory walk name the
+ * same file.
+ *
+ * Exact equality was the first shape, and a diff does not promise the
+ * spelling a directory walk produces: git quotes a path with an
+ * unusual byte in it, and separators differ by platform. A comparison
+ * that is too strict fails open here, which is the wrong direction for
+ * the one rule that keeps the change under review out of the
+ * reviewer's prompt.
+ */
+function sameFile(fromDiff, found) {
+    return plain(fromDiff) === plain(found);
+}
+/** A path reduced to what two spellings of it agree on. */
+function plain(path) {
+    const unquoted = path.startsWith('"') && path.endsWith('"')
+        ? unquote(path.slice(1, -1))
+        : path;
+    return (unquoted
+        .replace(/\\/g, "/")
+        .replace(/^\.\//, "")
+        // The prefixes git writes on the two sides of a diff. A quoted
+        // path keeps them, and quoting is the default spelling for any
+        // path with a non-ascii byte in it, so leaving them on failed
+        // open exactly where the quoting was meant to be handled.
+        .replace(/^[ab]\//, "")
+        .normalize("NFC")
+        // Folded, because the filesystems this runs on mostly are, and a
+        // check treating two names one directory cannot tell apart as
+        // different names fails open.
+        .toLowerCase());
+}
+/**
+ * A path the way git quotes one, read back.
+ *
+ * Byte by byte rather than character by character, because git escapes
+ * the bytes: an accented letter arrives as two octal escapes that are
+ * one character, and decoding them separately produces a string that
+ * matches nothing on disk.
+ */
+function unquote(quoted) {
+    const bytes = [];
+    for (let at = 0; at < quoted.length; at += 1) {
+        if (quoted[at] !== "\\") {
+            bytes.push(...new TextEncoder().encode(quoted[at]));
+            continue;
+        }
+        const octal = quoted.slice(at + 1, at + 4);
+        if (/^[0-7]{3}$/.test(octal)) {
+            bytes.push(Number.parseInt(octal, 8));
+            at += 3;
+            continue;
+        }
+        const escaped = quoted[at + 1] ?? "";
+        const literal = { n: "\n", t: "\t", r: "\r" }[escaped] ?? escaped;
+        bytes.push(...new TextEncoder().encode(literal));
+        at += 1;
+    }
+    return new TextDecoder().decode(Uint8Array.from(bytes));
+}
+/**
+ * The frontmatter of an agent file, read as the YAML it is.
+ *
+ * The persona reader splits on the first colon of each line, which is
+ * enough for files this project's own contract governs. These files
+ * are not that: they are written for another harness, in real YAML,
+ * and the descriptions on this machine run to a paragraph with colons
+ * in them. A line splitter turns a quoted or folded value into
+ * something that parses and is wrong, which is worse than refusing.
+ *
+ * Only scalars are taken. A nested value is not a name or a
+ * description, and reporting it as one would put a `[object Object]`
+ * in a listing somebody chooses from.
+ */
+function frontmatterOf(text) {
+    const split = splitFrontmatter(text);
+    if (split === undefined)
+        return undefined;
+    let parsed;
+    try {
+        // The block the split itself found. Finding the fences a second
+        // way put whatever fell between the two rules into neither the
+        // fields nor the listing, and at the head of the charter.
+        parsed = parseYaml(split.block);
+    }
+    catch (error) {
+        return {
+            why: `Its frontmatter is not readable as YAML: ${error instanceof Error ? error.message.split("\n")[0] : String(error)}`,
+        };
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return { why: "Its frontmatter is not a block of fields." };
+    }
+    const fields = {};
+    const unreadable = [];
+    for (const [key, value] of Object.entries(parsed)) {
+        // Named before it is dropped. Dropping first left the report of
+        // what was not adopted silent about exactly the fields it promises
+        // to name, because it never saw them.
+        if (value === null || typeof value === "object") {
+            unreadable.push(key);
+            continue;
+        }
+        fields[key] = String(value).trim();
+    }
+    return { fields, unreadable, body: split.body };
+}
+/**
+ * The two fields identity is made of.
+ *
+ * Everything else in the frontmatter belongs to the harness the file
+ * was written for, and is reported rather than adopted: the file is
+ * not wrong, it is right for something else. An allowlist of the
+ * mechanism seen so far was the first shape of this, and it named the
+ * fields already known about while staying silent on whatever a
+ * harness adds next, which is the reverse of what a report is for.
+ */
+const IDENTITY = ["name", "description"];
+/**
+ * Read what a repo's agent files offer.
+ *
+ * Lenient where the persona reader is strict, and the difference is
+ * who asked. A persona is named in somebody's own config, so a
+ * malformed one is a mistake they want reported loudly. Nobody asked
+ * for these, so one malformed file in a repo this operator does not
+ * maintain must not refuse every round run against it.
+ */
+export function discoverAgents(files, 
+// Paths the change under review touches. A lens among them is
+// refused rather than dropped quietly, because somebody asking for
+// it by name has to learn that it was the diff that disqualified it
+// and not a typo.
+//
+// Required, and deliberately so. It defaulted to the empty set at
+// first, which meant the rule the whole design rests on was off
+// unless a caller remembered to switch it on, and a caller that
+// forgot got the unsafe behaviour silently. Pass an empty array to
+// say the change touches nothing.
+touched) {
+    const read = [];
+    const skipped = [];
+    const sourceOf = new Map();
+    for (const file of files) {
+        const split = frontmatterOf(file.text);
+        if (split === undefined) {
+            skipped.push({
+                path: file.path,
+                why: "It opens with no frontmatter block, so it names no lens.",
+            });
+            continue;
+        }
+        if ("why" in split) {
+            skipped.push({ path: file.path, why: split.why });
+            continue;
+        }
+        const name = split.fields.name;
+        if (name === undefined || name === "") {
+            skipped.push({
+                path: file.path,
+                why: "Its frontmatter gives no name, so there is nothing to call it.",
+            });
+            continue;
+        }
+        if (!/^[\w.-]+$/.test(name)) {
+            // A name is an id somebody types and a listing prints, so it is
+            // held to what an id may be. Unbounded, it is a line of the
+            // operator's listing that the repo gets to write, newline
+            // included.
+            skipped.push({
+                path: file.path,
+                why: "Its name is not a plain identifier, and a name is printed where somebody chooses a lens.",
+            });
+            continue;
+        }
+        const description = split.fields.description;
+        if (description === undefined || description === "") {
+            skipped.push({
+                path: file.path,
+                why: `The agent "${name}" gives no description, which is how somebody choosing a lens knows what it is for.`,
+            });
+            continue;
+        }
+        // Counted before anything can disqualify it. Skipping first let a
+        // change that edits one of two files claiming a name promote the
+        // other from contested to authoritative, handing the name to
+        // whichever file the change did not touch.
+        sourceOf.set(name, [...(sourceOf.get(name) ?? []), file.path]);
+        if (touched.some((path) => sameFile(path, file.path) ||
+            (file.reads !== undefined && sameFile(path, file.reads)))) {
+            skipped.push({
+                path: file.path,
+                why: `The change under review edits this file, so reading through "${name}" would let the author of the change write the reviewer's standing instruction.`,
+            });
+            continue;
+        }
+        const charter = split.body.trim();
+        if (weight(charter) > MOST_CHARTER) {
+            // Bytes, because the limit being guarded is a limit on one argv
+            // entry and that is counted in bytes. UTF-16 units let a charter
+            // written in a language that does not fit a byte a character run
+            // well past the line this claims to hold.
+            skipped.push({
+                path: file.path,
+                why: `The charter for "${name}" is ${weight(charter)} bytes, past the ${MOST_CHARTER} a lens may carry. A charter becomes an argument on the reviewer's process.`,
+            });
+            continue;
+        }
+        if (charter === "") {
+            skipped.push({
+                path: file.path,
+                why: `The agent "${name}" has an empty body, so it is a name for a lens that does not exist.`,
+            });
+            continue;
+        }
+        // Everything that is not identity, rather than a list of the two
+        // fields seen so far. An allowlist reports the fields already known
+        // about and stays silent on the ones a harness adds next, which is
+        // the reverse of what a report is for.
+        const notAdopted = [
+            ...Object.keys(split.fields).filter((field) => !IDENTITY.includes(field)),
+            ...split.unreadable,
+        ].sort();
+        read.push({
+            id: `${NAMESPACE}${name}`,
+            name,
+            description,
+            charter,
+            source: file.path,
+            ...(notAdopted.length === 0 ? {} : { notAdopted }),
+        });
+    }
+    // A name two files answer to identifies neither. Dropping both is
+    // the only answer that does not make which lens ran depend on the
+    // order a directory happened to list its entries.
+    const contested = (one) => (sourceOf.get(one.name) ?? []).length > 1;
+    for (const one of read.filter(contested)) {
+        skipped.push({
+            path: one.source,
+            why: `"${one.name}" is claimed by ${(sourceOf.get(one.name) ?? []).join(" and ")}, so the name identifies neither.`,
+        });
+    }
+    return { agents: read.filter((one) => !contested(one)), skipped };
+}

package/dist/review/ask/anchorable.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Where a finding may legitimately point.
+ *
+ * A reviewer told only "anchor to the diff" will name a line it read
+ * in the file and never noticed was outside a hunk, and the anchor
+ * then degrades to a body comment carrying a line number that means
+ * nothing. Telling it the ranges up front costs a few lines of
+ * prompt and removes the whole class of mistake.
+ *
+ * Context lines count. A reviewer may legitimately point at an
+ * unchanged line inside a hunk to say what the change around it
+ * breaks, and every backend accepts an anchor there.
+ */
+import type { DiffModel } from "../diff.js";
+/** A run of lines, inclusive at both ends. */
+export interface LineRange {
+    from: number;
+    to: number;
+}
+/** Where one file will accept an anchor, per side. */
+export interface FileRanges {
+    path: string;
+    new: LineRange[];
+    old: LineRange[];
+}
+/** Every file in a diff, with the ranges each side will accept. */
+export declare function anchorableRanges(diff: DiffModel): FileRanges[];
+/**
+ * One line per file, both sides named.
+ *
+ * A side with nothing is left out rather than printed as empty: a
+ * pure addition has no left side at all, and "old none" only invites
+ * a reviewer to wonder what it meant.
+ */
+export declare function describeRanges(ranges: FileRanges[]): string;

package/dist/review/ask/anchorable.js

@@ -0,0 +1,76 @@
+/**
+ * Where a finding may legitimately point.
+ *
+ * A reviewer told only "anchor to the diff" will name a line it read
+ * in the file and never noticed was outside a hunk, and the anchor
+ * then degrades to a body comment carrying a line number that means
+ * nothing. Telling it the ranges up front costs a few lines of
+ * prompt and removes the whole class of mistake.
+ *
+ * Context lines count. A reviewer may legitimately point at an
+ * unchanged line inside a hunk to say what the change around it
+ * breaks, and every backend accepts an anchor there.
+ */
+import { filePath } from "../diff.js";
+/** Every file in a diff, with the ranges each side will accept. */
+export function anchorableRanges(diff) {
+    return diff.files.map((file) => ({
+        path: filePath(file),
+        new: sideRanges(file, "new"),
+        old: sideRanges(file, "old"),
+    }));
+}
+/**
+ * One line per file, both sides named.
+ *
+ * A side with nothing is left out rather than printed as empty: a
+ * pure addition has no left side at all, and "old none" only invites
+ * a reviewer to wonder what it meant.
+ */
+export function describeRanges(ranges) {
+    if (ranges.length === 0) {
+        return "No line in this change can hold an anchor, so every finding has to be file-scoped or about the change as a whole.";
+    }
+    return ranges
+        .map((file) => {
+        const sides = [];
+        if (file.new.length > 0)
+            sides.push(`new ${list(file.new)}`);
+        if (file.old.length > 0)
+            sides.push(`old ${list(file.old)}`);
+        return `${file.path}: ${sides.join(" | ")}`;
+    })
+        .join("\n");
+}
+/**
+ * The ranges one side of one file will accept.
+ *
+ * Taken from the line numbers the hunks actually carry rather than
+ * from the hunk headers, since a header counts lines on its side
+ * while a range has to be bounded by lines that exist on it. One
+ * range per hunk: the gap between two hunks is not in the diff, so a
+ * range spanning it would invite an anchor nothing can hold.
+ */
+function sideRanges(file, side) {
+    const ranges = [];
+    for (const hunk of file.hunks) {
+        let from;
+        let to;
+        for (const line of hunk.lines) {
+            const at = side === "new" ? line.newLine : line.oldLine;
+            if (at === undefined)
+                continue;
+            if (from === undefined || at < from)
+                from = at;
+            if (to === undefined || at > to)
+                to = at;
+        }
+        if (from !== undefined && to !== undefined)
+            ranges.push({ from, to });
+    }
+    return ranges;
+}
+/** Several ranges on one side, as a reader would say them. */
+function list(ranges) {
+    return ranges.map((r) => `${r.from}-${r.to}`).join(", ");
+}

package/dist/review/ask/answer.d.ts

@@ -0,0 +1,54 @@
+/**
+ * What a round says when somebody reads it back.
+ *
+ * Composed here rather than where it is printed, because the order and
+ * the wording are the parts that go wrong and neither is visible from
+ * a test of the extension. A round's arithmetic had cases, its panel
+ * had cases, its store had cases, and the paragraph a reader actually
+ * sees was assembled in a private function nothing could reach.
+ *
+ * The view stays out. A line says what kind of thing it is and the
+ * side that draws it decides what that looks like, which keeps this
+ * module free of glyphs, colour and width while still owning what is
+ * said and in what order.
+ */
+import type { AskRun } from "./run.js";
+/** One line of an answer, and what kind of line it is. */
+export interface AnswerLine {
+    /**
+     * How to draw it: refused for something that changes how the round
+     * should be read, failed for a participant that did not answer.
+     * Absent for ordinary prose.
+     */
+    mark?: "refused" | "failed";
+    text: string;
+}
+/** Anything the caller knows that the round does not. */
+export interface AnswerContext {
+    /**
+     * Warnings gathered while the round ran.
+     *
+     * Taken as they are and put last. These arrive already painted by
+     * some callers, which is the one place the no-view rule leaks, and
+     * it leaks inward: this module still paints nothing.
+     */
+    warnings?: string[];
+    /** Something about the reading itself, such as which tree was cut. */
+    caveat?: string;
+    /**
+     * That somebody answered in this exchange, which disproves anything
+     * the round says about the session being unable to run reviewers.
+     *
+     * The sequence the advisory exists for ends here: pi dies mid-round,
+     * the reader restarts, the reader retries, and the retry works.
+     * Every outcome that failed still carries the diagnosis, because
+     * they did fail, but printing it over a reviewer that has just
+     * answered tells somebody to restart a session they have already
+     * restarted and that is demonstrably fine.
+     */
+    sessionAnswered?: boolean;
+}
+/** One round, in a line, with whatever its stopped reviewers left. */
+export declare function describeRun(run: AskRun): string;
+/** What a round's answer says, in order. */
+export declare function roundAnswer(run: AskRun, said?: AnswerContext): AnswerLine[];

package/dist/review/ask/answer.js

@@ -0,0 +1,209 @@
+/**
+ * What a round says when somebody reads it back.
+ *
+ * Composed here rather than where it is printed, because the order and
+ * the wording are the parts that go wrong and neither is visible from
+ * a test of the extension. A round's arithmetic had cases, its panel
+ * had cases, its store had cases, and the paragraph a reader actually
+ * sees was assembled in a private function nothing could reach.
+ *
+ * The view stays out. A line says what kind of thing it is and the
+ * side that draws it decides what that looks like, which keeps this
+ * module free of glyphs, colour and width while still owning what is
+ * said and in what order.
+ */
+import { count as group } from "../../result/counts.js";
+// The leaf, not the barrel. `lib/ui/index.ts` re-exports the panel,
+// which imports pi's TUI at module scope, and an ESM re-export
+// evaluates what it re-exports from: one convenient import here would
+// put pi's runtime in the module graph of a library that has never
+// needed it. Every other `count` consumer in `lib/` takes the leaf
+// for the same reason.
+import { count } from "../../ui/count.js";
+import { failureLines, runSummary, staleRuntimeAdvisory, stoppedNotes, } from "./run.js";
+/** One round, in a line, with whatever its stopped reviewers left. */
+export function describeRun(run) {
+    const summary = runSummary(run);
+    const failed = summary.failed > 0 ? `, ${summary.failed} failed` : "";
+    // Only a council carries this, and only while it is unsettled, so
+    // the sentence says what is actually known: it opened and nothing
+    // closed it. Whether that is a dead session or a round still
+    // running in another window is not ours to assert, and the useful
+    // half is the same either way, since the reviewers' answers are on
+    // disk under this id.
+    //
+    // Its arithmetic used to be a finished round's, and read as an
+    // accusation: a round that opened and has recorded nothing rendered
+    // as "0/7 answered, 7 failed", which says seven reviewers were
+    // asked and dropped. Nobody has asked them anything yet. The
+    // summary now separates the two, so this only has to say it.
+    const pending = summary.pending > 0 ? `, ${summary.pending} still to hear from` : "";
+    const abandoned = run.closed === true
+        ? ", closed unfinished"
+        : run.open === true
+            ? ", opened and never settled"
+            : "";
+    // Two words in the listing, not the whole sentence. This is the
+    // surface a reader browses sixty rounds through, and until now it
+    // was the one place that could not say a round had read the wrong
+    // tree: the sentence went into the answer of the session that
+    // started the round, and the listing showed findings and a bill
+    // beside a round whose findings were formed against something
+    // else. The sentence itself is on the run for whoever wants it.
+    const unpinned = run.unpinned === undefined ? "" : ", tree not pinned";
+    const head = `${run.id}: ${summary.answered}/${summary.asked} answered${failed}${pending}, ${count(summary.findings, "finding")}${spent(summary)}${unpinned}${conditions(run)}${abandoned}`;
+    // A stopped reviewer's answer was being recorded and never shown,
+    // which is most of the way to losing it: the path is only useful to
+    // somebody who knows to look for it.
+    return [head, ...stoppedNotes(run).map((note) => `  ${note}`)].join("\n");
+}
+/**
+ * What a round was run under, in as few words as it takes.
+ *
+ * A field nothing prints is a field nobody reads, and the guide told
+ * people to read this one off the run. So the listing says it, on the
+ * same terms as the tree caveat beside it: the exceptional states get
+ * words and the ordinary one gets silence.
+ *
+ * The exception here is what the reader would want stopped. A round
+ * whose reviewers ran with the operator's whole setup loaded is a
+ * round two people cannot reproduce between them, and a round whose
+ * conventions could not be quoted read a change against rules it was
+ * told about and never shown.
+ *
+ * A round that recorded nothing says nothing, because that is most of
+ * the ledger and a phrase on every historic round is a phrase nobody
+ * sees after the first screen.
+ */
+function conditions(run) {
+    const given = run.given;
+    if (given === undefined)
+        return "";
+    return [
+        given.isolated ? "" : ", reviewers not isolated",
+        given.quoted?.withheld === true ? ", conventions not quotable" : "",
+        given.quoted?.cut === true ? ", conventions cut" : "",
+    ].join("");
+}
+/**
+ * What the round burned, when anybody said.
+ *
+ * Held in the ledger since the first round and shown by nothing until
+ * now: a billion tokens and several hundred dollars across sixty-odd
+ * rounds, reachable only by reading the JSON. A council costs about
+ * as much as a good dinner, and the reader deciding whether to run
+ * another is the person who should be told.
+ *
+ * Silent when nobody reported, because a zero would claim the round
+ * was free rather than admit it was not measured.
+ */
+function spent(summary) {
+    const said = [];
+    // Grouped by hand rather than by locale. `toLocaleString` reads
+    // whatever ICU the host was built with, and a line that groups with
+    // spaces on one machine and commas on another is a line two readers
+    // cannot compare.
+    if (summary.tokens !== undefined)
+        said.push(`${grouped(summary.tokens)} tokens`);
+    if (summary.cost !== undefined)
+        said.push(money(summary.cost));
+    if (said.length === 0)
+        return "";
+    // "At least", when somebody who was asked reported nothing. A
+    // subtotal in the words of a total is the same lie as a zero for a
+    // round nobody priced, and it runs the wrong way: the participants
+    // most likely to be missing are the ones that died.
+    const so = summary.partlyPriced === true ? "at least " : "";
+    return `, ${so}${said.join(", ")}`;
+}
+/**
+ * A cost, without rounding a real one away.
+ *
+ * Two decimals turn anything under half a cent into "$0.00", which is
+ * the one claim this refuses to make: that a round was free when it
+ * was billed.
+ */
+function money(cost) {
+    return cost > 0 && cost < 0.005 ? "under $0.01" : `$${cost.toFixed(2)}`;
+}
+/** A whole number with thousands separated, the same way everywhere. */
+function grouped(value) {
+    // Rounded here, grouped there. The rule had been written out three
+    // times across the package, which is three chances for one of them
+    // to answer differently about the same number.
+    return group(Math.round(value));
+}
+/** What a round's answer says, in order. */
+export function roundAnswer(run, said) {
+    const summary = runSummary(run);
+    // One element per line, because a mark paints a line: an element
+    // holding two would put the glyph on the first and leave the second
+    // looking like prose.
+    const lines = describeRun(run)
+        .split("\n")
+        .map((text) => ({ text }));
+    // Before everything, not after: a caveat about which tree was read
+    // changes how every finding below it should be weighed.
+    //
+    // Falling back to the run means a round collected by a later
+    // session says it too. That reader has nothing but the file, and
+    // the file records a witness commit whether or not the reviewers
+    // could be given it. The caller's own caveat wins where there is
+    // one, since a live round can be more specific than what was
+    // written down.
+    const caveat = said?.caveat ?? run.unpinned;
+    if (caveat !== undefined)
+        lines.push({ mark: "refused", text: caveat });
+    // Above the roll call rather than among it, and the roll call says
+    // "as above" instead of repeating the paragraph, or hoisting a
+    // sentence already on every outcome would make a seven-reviewer
+    // round eight copies long rather than one.
+    const advisory = said?.sessionAnswered === true ? undefined : staleRuntimeAdvisory(run);
+    if (advisory !== undefined)
+        lines.push({ mark: "refused", text: advisory });
+    // Told what was hoisted rather than deciding it again, so a
+    // suppressed advisory cannot leave a roll call of reviewers
+    // pointing at a line that is not there.
+    const failures = failureLines(run, advisory);
+    for (const line of failures)
+        lines.push({ mark: "failed", text: line });
+    const nothing = nothingCameBack(run, summary.answered, failures.length);
+    if (nothing !== undefined)
+        lines.push({ text: nothing });
+    for (const warning of said?.warnings ?? [])
+        lines.push({ text: warning });
+    return lines;
+}
+/**
+ * That the round came back with nothing, when it did, said after the
+ * failures rather than before them.
+ *
+ * It used to say the failures above were the whole story while being
+ * printed above them, and to say it on a round that had failed at
+ * nothing: a council that has just opened has answered nobody and
+ * blamed nobody, and telling its reader that failures explain the
+ * silence invents seven that do not exist.
+ *
+ * Counted off the failures actually printed rather than off the
+ * summary. The two disagree on a settled round with a silent
+ * participant, which the summary calls failed and the roll call
+ * cannot name, and the sentence points at the roll call.
+ *
+ * An open round is the third case and the one the collect path
+ * reaches: every participant carries a failure saying nothing was on
+ * disk, and the warnings under it say the transcripts may be
+ * somewhere else and the round is deliberately left open. Calling
+ * that the whole story contradicts the next line down.
+ */
+function nothingCameBack(run, answered, named) {
+    if (answered > 0)
+        return undefined;
+    if (run.open === true) {
+        return named > 0
+            ? "Nothing came back from anybody, and the round is still open, so what is above may not be the end of it."
+            : "Nobody has answered yet, and nothing has gone wrong: the round is still open.";
+    }
+    return named > 0
+        ? "Nobody answered, so nothing was recorded. The failures above are the whole story."
+        : "Nobody answered, and nothing was recorded to say why.";
+}