@shiyuphan/follow-me 0.8.0 → 0.9.1

package/dist/src/comments.js

@@ -1,6 +1,7 @@
 import { parseLoc } from "./coverage.js";
 import { isRepoPath, isSha, isUnitId } from "./diff.js";
 import { diagramProblem, isArray, isCommentId, isConcernId, isFields, isOfferId, isPlanVersion, isSeverity, parsePlacedConcern, } from "./plan.js";
+import { parseRefText } from "./refs.js";
 /**
  * The wire formats of review state, parsed once at the boundary: comments, replies, concern
  * decisions, the review file, its autosaved draft and the events a hosted session logs. Every
@@ -49,26 +50,42 @@ function parseAnchor(v) {
     }
     return { kind: "hunk", unit: v.unit, commit, changes, offsets };
 }
+/** A place written as a ref string (`path:a-b`, tip lines) or as { path, start, end }. */
+function parsePlace(raw) {
+    if (typeof raw !== "string")
+        return parseLoc(raw);
+    const spec = parseRefText(raw);
+    if (spec === null)
+        return null;
+    if (spec.at !== null)
+        return `${JSON.stringify(raw)}: a map is in tip lines; drop the @`;
+    return parseLoc({ path: spec.path, start: spec.start, end: spec.end });
+}
 function parseLocs(v, at, needed) {
-    const what = `${at}: expected a list of { path, start, end }${needed ? " with at least one place" : ""}`;
+    const what = `${at}: expected a list of "path:a-b" or { path, start, end }${needed ? " with at least one place" : ""}`;
     if (!isArray(v) || (needed && v.length === 0))
         return what;
     const out = [];
     for (const [i, raw] of v.entries()) {
-        const loc = parseLoc(raw);
+        const loc = parsePlace(raw);
         if (loc === null)
-            return `${at}[${i}]: expected { path, start, end } with 1 <= start <= end`;
+            return `${at}[${i}]: expected "path:a-b" or { path, start, end } with 1 <= start <= end`;
+        if (typeof loc === "string")
+            return `${at}[${i}]: ${loc}`;
         out.push(loc);
     }
     return out;
 }
 const TRANSITION_ENDS = ["from", "to"];
+/** A stateDiagram's start and end marker. */
+const START_END = "[*]";
 function escapeRegExp(text) {
     return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 /**
  * Boundary parse of a reply's state map. Every state has at least one place, every transition
- * names states of the map, and with a stateDiagram every state name appears in it. The reason
+ * names states of the map, and with a stateDiagram every state name appears in it. A transition
+ * to or from `[*]` is dropped: the diagram marks the start and end. The reason
  * names the bad entry, as map.states.<name>[i] or map.transitions[i].<field>.
  */
 export function parseStateMap(v, diagram) {
@@ -95,6 +112,10 @@ export function parseStateMap(v, diagram) {
         const at = `map.transitions[${i}]`;
         if (!isFields(raw))
             return `${at}: expected { from, to, event, at }`;
+        // The diagram's [*] already marks where the machine starts and ends; a move to or from it
+        // has no code of its own, so it is dropped rather than refused.
+        if (raw.from === START_END || raw.to === START_END)
+            continue;
         for (const end of TRANSITION_ENDS) {
             const state = raw[end];
             if (typeof state !== "string" || !named.has(state)) {
@@ -148,6 +169,55 @@ export function mapOffTip(map, lines, show = (path) => path) {
         ...(map.transitions ?? []).flatMap((t, i) => t.at.flatMap((loc, j) => check(loc, `map.transitions[${i}].at[${j}]`))),
     ];
 }
+function parseSpan(v) {
+    if (v === null)
+        return null;
+    if (!isFields(v) || !isLine(v.start) || !isLine(v.end) || v.end < v.start) {
+        return "expected null or { start, end } with 1 <= start <= end";
+    }
+    return { start: v.start, end: v.end };
+}
+function parseCodeRef(v) {
+    if (!isFields(v))
+        return "expected an object";
+    const { n, path, start, end, at, quote, tip } = v;
+    if (!isLine(n))
+        return "n is not a number from 1";
+    if (typeof path !== "string" || !isRepoPath(path))
+        return "path is not a repo path";
+    if (!isLine(start) || !isLine(end) || end < start)
+        return "expected 1 <= start <= end";
+    if (at !== null && at !== "base" && !isLine(at))
+        return 'at is not a commit, "base" or null';
+    if (!isArray(quote) || !quote.every(isString))
+        return "quote is not a list of strings";
+    if (typeof tip !== "string" || !isSha(tip))
+        return "tip is not a commit sha";
+    const lines = parseSpan(v.lines);
+    const old = parseSpan(v.old);
+    if (typeof lines === "string")
+        return `lines: ${lines}`;
+    if (typeof old === "string")
+        return `old: ${old}`;
+    return { n, path, start, end, at, quote: quote.filter(isString), tip, lines, old };
+}
+/** refs as stored beside an agent's words: absent, or a list numbered 1, 2, 3 in order. */
+function parseCodeRefs(v) {
+    if (v === undefined)
+        return [];
+    if (!isArray(v))
+        return "refs is not a list";
+    const refs = [];
+    for (const [i, raw] of v.entries()) {
+        const ref = parseCodeRef(raw);
+        if (typeof ref === "string")
+            return `refs[${i}]: ${ref}`;
+        if (ref.n !== i + 1)
+            return `refs[${i}]: n is not ${i + 1}`;
+        refs.push(ref);
+    }
+    return refs;
+}
 /** A stored reply. Replies a client posts go through parseNewReply, which mints id and time. */
 export function parseReply(v) {
     if (!isFields(v)) {
@@ -165,32 +235,43 @@ export function parseReply(v) {
     const map = v.map === undefined ? undefined : parseStateMap(v.map, v.diagram);
     if (typeof map === "string")
         return map;
+    const refs = parseCodeRefs(v.refs);
+    if (typeof refs === "string")
+        return refs;
     return {
         id: v.id,
         author: v.author,
         body: v.body,
         ...(v.diagram === undefined ? {} : { diagram: v.diagram }),
         ...(map === undefined ? {} : { map }),
+        ...(refs.length === 0 ? {} : { refs }),
         createdAt: v.createdAt,
     };
 }
 /**
  * The body of POST .../replies: who speaks, what, and an optional Mermaid diagram. The body may be
- * empty only when the diagram is the answer.
+ * empty only when the diagram is the answer. Only the agent's words carry refs.
  */
 export function parseNewReply(v) {
-    if (!isFields(v))
+    if (!isFields(v)) {
         return "the reply is not an object";
+    }
     if (v.author !== "agent" && v.author !== "reviewer")
         return 'author is not "agent" or "reviewer"';
     if (typeof v.body !== "string")
         return "body is not a string";
+    const refs = parseCodeRefs(v.refs);
+    if (typeof refs === "string")
+        return refs;
+    if (refs.length > 0 && v.author !== "agent")
+        return "refs are only for the agent's words";
+    const withRefs = refs.length === 0 ? {} : { refs };
     if (v.diagram === undefined) {
         if (v.map !== undefined)
             return "map needs the diagram it ties to code";
         if (v.body.trim() === "")
             return "body is empty; a reply needs words or a diagram";
-        return { author: v.author, body: v.body };
+        return { author: v.author, body: v.body, ...withRefs };
     }
     if (typeof v.diagram !== "string")
         return "diagram is not a string";
@@ -205,6 +286,7 @@ export function parseNewReply(v) {
         body: v.body,
         diagram: v.diagram,
         ...(map === undefined ? {} : { map }),
+        ...withRefs,
     };
 }
 function isString(v) {
@@ -262,6 +344,11 @@ export function parseComment(v) {
             return "offer is only for a reviewer's question";
         }
     }
+    const refs = parseCodeRefs(v.refs);
+    if (typeof refs === "string")
+        return refs;
+    if (refs.length > 0 && v.author !== "agent")
+        return "refs are only for an agent's comment";
     const replies = parseList(v.replies, parseReply, "replies");
     if (typeof replies === "string")
         return replies;
@@ -281,6 +368,7 @@ export function parseComment(v) {
         ...(replies.length === 0 ? {} : { replies }),
         ...(v.author === "agent" ? { author: "agent" } : {}),
         ...(v.diagram === undefined ? {} : { diagram: v.diagram }),
+        ...(refs.length === 0 ? {} : { refs }),
         ...(offer === undefined ? {} : { offer }),
     };
 }

package/dist/src/coverage.js

@@ -15,9 +15,12 @@ export class LcovError extends Error {
 const RECORD = /^([A-Z][A-Z0-9_]*):(.*)$/;
 const DA = /^([1-9][0-9]*),([0-9]+)(?:,.*)?$/;
 const BRDA = /^([1-9][0-9]*),([^,]+),(.+),(-|[0-9]+)$/;
+/** FN:<start>,<name>, or lcov 2's FN:<start>,<end>,<name>. */
+const FN = /^([1-9][0-9]*),(?:([1-9][0-9]*),)?(.+)$/;
 /**
  * Reads lcov's tracefile format: TN names the test of the records after it, SF opens a file, DA
- * and BRDA give line and branch hits, end_of_record closes it. Other records are skipped.
+ * and BRDA give line and branch hits, FN a function's place, end_of_record closes it. Other
+ * records are skipped.
  */
 export function parseLcov(text) {
     const records = [];
@@ -50,10 +53,10 @@ export function parseLcov(text) {
             close();
             if (value === "")
                 throw new LcovError(n, "SF needs a path");
-            open = { path: value, test, lines: new Map(), branches: new Map() };
+            open = { path: value, test, lines: new Map(), branches: new Map(), functions: [] };
             continue;
         }
-        if (key !== "DA" && key !== "BRDA")
+        if (key !== "DA" && key !== "BRDA" && key !== "FN")
             continue;
         if (open === null)
             throw new LcovError(n, `${key} comes before any SF`);
@@ -65,15 +68,27 @@ export function parseLcov(text) {
             open.lines.set(line, (open.lines.get(line) ?? 0) + Number(da[2]));
             continue;
         }
+        if (key === "FN") {
+            const fn = FN.exec(value);
+            if (fn === null)
+                throw new LcovError(n, `FN needs <line>,<name>, got "${value}"`);
+            const start = Number(fn[1]);
+            const end = fn[2] === undefined ? undefined : Number(fn[2]);
+            const name = fn[3] ?? "";
+            if (end !== undefined && end < start)
+                throw new LcovError(n, "FN ends before it starts");
+            open.functions.push(end === undefined ? { name, start } : { name, start, end });
+            continue;
+        }
         const br = BRDA.exec(value);
         if (br === null) {
             throw new LcovError(n, `BRDA needs <line>,<block>,<branch>,<taken>, got "${value}"`);
         }
         const line = Number(br[1]);
         const id = `${br[2]},${br[3]}`;
-        const taken = br[4] !== "-" && Number(br[4]) > 0;
+        const taken = br[4] === "-" ? 0 : Number(br[4]);
         const branches = open.branches.get(line) ?? new Map();
-        branches.set(id, (branches.get(id) ?? false) || taken);
+        branches.set(id, (branches.get(id) ?? 0) + taken);
         open.branches.set(line, branches);
     }
     close();
@@ -110,10 +125,42 @@ export function tipPlacer(root, cwd, atTip) {
         return null;
     };
 }
+/** Adds a record's branch counts into `into`, keeping lcov's branch order per line. */
+function countInto(into, path, record) {
+    const joined = into.get(path) ?? new Map();
+    for (const [line, ids] of record.branches) {
+        const on = joined.get(line) ?? new Map();
+        for (const [id, n] of ids)
+            on.set(id, (on.get(id) ?? 0) + n);
+        joined.set(line, on);
+    }
+    into.set(path, joined);
+}
+function countsOf(counting) {
+    const out = new Map();
+    for (const [path, byLine] of counting) {
+        if (byLine.size === 0)
+            continue;
+        out.set(path, sorted(new Map([...byLine].map(([line, ids]) => [line, [...ids.values()]]))));
+    }
+    return out;
+}
+/** Functions of both lists, once each by start and name, in line order. */
+function joinFunctions(a, b) {
+    const seen = new Map();
+    for (const f of [...a, ...b]) {
+        const key = `${f.start}|${f.name}`;
+        const had = seen.get(key);
+        if (had === undefined || (had.end === undefined && f.end !== undefined))
+            seen.set(key, f);
+    }
+    return [...seen.values()].sort((x, y) => x.start - y.start);
+}
 /** Sums hits and joins branches over records of the same file; drops what `place` rejects. */
 export function runOf(records, place) {
     const lines = new Map();
     const branches = new Map();
+    const functions = new Map();
     const tests = new Map();
     for (const record of records) {
         const path = place(record.path);
@@ -123,37 +170,42 @@ export function runOf(records, place) {
         for (const [line, n] of record.lines)
             hits.set(line, (hits.get(line) ?? 0) + n);
         lines.set(path, hits);
-        const joined = branches.get(path) ?? new Map();
-        for (const [line, ids] of record.branches) {
-            const on = joined.get(line) ?? new Map();
-            for (const [id, taken] of ids)
-                on.set(id, (on.get(id) ?? false) || taken);
-            joined.set(line, on);
-        }
-        branches.set(path, joined);
+        countInto(branches, path, record);
+        functions.set(path, joinFunctions(functions.get(path) ?? [], record.functions));
         if (record.test === null)
             continue;
-        const ran = tests.get(record.test) ?? new Map();
-        const set = ran.get(path) ?? new Set();
+        const ran = tests.get(record.test) ?? { lines: new Map(), branches: new Map() };
+        const set = ran.lines.get(path) ?? new Set();
         for (const [line, n] of record.lines)
             if (n > 0)
                 set.add(line);
-        ran.set(path, set);
+        ran.lines.set(path, set);
+        countInto(ran.branches, path, record);
         tests.set(record.test, ran);
     }
     const files = new Map();
     for (const [path, hits] of lines) {
         const counted = new Map();
         for (const [line, ids] of branches.get(path) ?? []) {
-            counted.set(line, [[...ids.values()].filter(Boolean).length, ids.size]);
+            const n = [...ids.values()];
+            counted.set(line, [n.filter((c) => c > 0).length, n.length]);
         }
-        files.set(path, { lines: sorted(hits), branches: sorted(counted) });
+        const fns = functions.get(path) ?? [];
+        files.set(path, {
+            lines: sorted(hits),
+            branches: sorted(counted),
+            ...(fns.length === 0 ? {} : { functions: fns }),
+        });
     }
     return {
         files,
+        counts: countsOf(branches),
         tests: new Map([...tests].map(([id, ran]) => [
             id,
-            new Map([...ran].map(([path, set]) => [path, [...set].sort((a, b) => a - b)])),
+            {
+                lines: new Map([...ran.lines].map(([path, set]) => [path, [...set].sort((a, b) => a - b)])),
+                branches: countsOf(ran.branches),
+            },
         ])),
     };
 }
@@ -184,7 +236,12 @@ function mergeMax(a, b) {
             const [t, n] = branches.get(l) ?? [0, 0];
             branches.set(l, [Math.max(taken, t), Math.max(total, n)]);
         }
-        out.set(path, { lines: sorted(lines), branches: sorted(branches) });
+        const functions = joinFunctions(had.functions ?? [], f.functions ?? []);
+        out.set(path, {
+            lines: sorted(lines),
+            branches: sorted(branches),
+            ...(functions.length === 0 ? {} : { functions }),
+        });
     }
     return out;
 }
@@ -197,7 +254,7 @@ export const PREVIEW_LINES = 8;
 export function recordRun(prior, run, at) {
     const { tip, takenAt, test } = at;
     if (test === undefined) {
-        const tests = new Map([...run.tests].map(([id, lines]) => [id, { lines }]));
+        const tests = new Map([...run.tests].map(([id, ran]) => [id, testEntry(ran)]));
         return { tip, takenAt, files: run.files, tests };
     }
     const base = prior !== null && prior.tip === tip ? prior : null;
@@ -205,18 +262,18 @@ export function recordRun(prior, run, at) {
     const entry = {
         ...(test.at === undefined ? {} : { at: test.at }),
         ...(test.preview === undefined ? {} : { preview: test.preview }),
-        lines: hitLines(run.files),
+        ...testEntry({ lines: hitLines(run.files), branches: run.counts }),
     };
     tests.set(test.id, entry);
     const files = base === null ? run.files : mergeMax(base.files, run.files);
     return { tip, takenAt, files, tests };
 }
-/**
- * Per file, the branch's added rows that lcov calls executable, and how many ran. Every added
- * row is a tip line, which is where the run was taken. Files without such rows are left out.
- */
-export function changedLines(units, files) {
-    const out = new Map();
+/** A test's lines, and its branch counts when the run had any. */
+function testEntry(ran) {
+    return { lines: ran.lines, ...(ran.branches.size === 0 ? {} : { branches: ran.branches }) };
+}
+/** Calls visit with each added row's tip line, per hunk, for files the run covers. */
+function eachAddedLine(units, files, visit) {
     for (const unit of units.values()) {
         if (unit.kind !== "hunk")
             continue;
@@ -224,22 +281,37 @@ export function changedLines(units, files) {
         if (file === undefined)
             continue;
         let line = tipStartOf(unit, units);
-        let { covered, executable } = out.get(unit.path) ?? { covered: 0, executable: 0 };
         for (const row of unit.body) {
-            const hits = row.op === "+" ? file.lines.get(line) : undefined;
-            if (hits !== undefined) {
-                executable += 1;
-                if (hits > 0)
-                    covered += 1;
-            }
+            if (row.op === "+")
+                visit(unit.path, file, line);
             if (row.op !== "-")
                 line += 1;
         }
-        if (executable > 0)
-            out.set(unit.path, { covered, executable });
     }
+}
+/**
+ * Per file, the branch's added rows that lcov calls executable, and how many ran. Every added
+ * row is a tip line, which is where the run was taken. Files without such rows are left out.
+ */
+export function changedLines(units, files) {
+    const out = new Map();
+    eachAddedLine(units, files, (path, file, line) => {
+        const hits = file.lines.get(line);
+        if (hits === undefined)
+            return;
+        const { covered, executable } = out.get(path) ?? { covered: 0, executable: 0 };
+        out.set(path, { covered: covered + (hits > 0 ? 1 : 0), executable: executable + 1 });
+    });
     return out;
 }
+/** How many branches the run took on the branch's added rows, summed over every decision. */
+export function changedBranchesTaken(units, files) {
+    let taken = 0;
+    eachAddedLine(units, files, (_, file, line) => {
+        taken += file.branches.get(line)?.[0] ?? 0;
+    });
+    return taken;
+}
 export function totalOf(tallies) {
     let covered = 0;
     let executable = 0;
@@ -278,6 +350,7 @@ export function serializeCoverage(c) {
         {
             lines: Object.fromEntries(f.lines),
             ...(f.branches.size === 0 ? {} : { branches: Object.fromEntries(f.branches) }),
+            ...(f.functions === undefined ? {} : { functions: f.functions }),
         },
     ]));
     const tests = Object.fromEntries([...c.tests].map(([id, t]) => [
@@ -286,6 +359,11 @@ export function serializeCoverage(c) {
             ...(t.at === undefined ? {} : { at: t.at }),
             ...(t.preview === undefined ? {} : { preview: [...t.preview] }),
             lines: Object.fromEntries([...t.lines].map(([p, ls]) => [p, [...ls]])),
+            ...(t.branches === undefined
+                ? {}
+                : {
+                    branches: Object.fromEntries([...t.branches].map(([p, byLine]) => [p, Object.fromEntries(byLine)])),
+                }),
         },
     ]));
     return { tip: c.tip, takenAt: c.takenAt, files, ...(c.tests.size === 0 ? {} : { tests }) };
@@ -321,6 +399,52 @@ export function parseLocArg(raw, place) {
     const end = m[3] === undefined ? start : Number(m[3]);
     return end < start ? `--at ${raw} runs backwards` : { path, start, end };
 }
+function parseFunction(v) {
+    if (!isFields(v))
+        return null;
+    const { name, start, end } = v;
+    if (typeof name !== "string" || !isLine(start))
+        return null;
+    if (end === undefined)
+        return { name, start };
+    return isLine(end) && end >= start ? { name, start, end } : null;
+}
+function parseFunctions(v) {
+    if (v === undefined)
+        return undefined;
+    if (!Array.isArray(v))
+        return "functions is not a list";
+    const out = [];
+    for (const raw of v) {
+        const f = parseFunction(raw);
+        if (f === null)
+            return "a function is not a { name, start, end? }";
+        out.push(f);
+    }
+    return out;
+}
+function parseCounts(v) {
+    if (v === undefined)
+        return undefined;
+    const files = entries(v);
+    if (files === null)
+        return "branches is not an object";
+    const out = new Map();
+    for (const [path, raw] of files) {
+        const lines = entries(raw);
+        if (!isRepoPath(path) || lines === null)
+            return `branches of ${path} are not by line`;
+        const byLine = new Map();
+        for (const [key, counts] of lines) {
+            if (!LINE_KEY.test(key) || !Array.isArray(counts) || !counts.every(isCount)) {
+                return `branches of ${path}:${key} are not counts`;
+            }
+            byLine.set(Number(key), counts.filter(isCount));
+        }
+        out.set(path, sorted(byLine));
+    }
+    return out;
+}
 function parseFile(v) {
     if (!isFields(v))
         return "a file is not an object";
@@ -347,7 +471,14 @@ function parseFile(v) {
         }
         branches.set(Number(key), [taken, total]);
     }
-    return { lines: sorted(hits), branches: sorted(branches) };
+    const functions = parseFunctions(v.functions);
+    if (typeof functions === "string")
+        return functions;
+    return {
+        lines: sorted(hits),
+        branches: sorted(branches),
+        ...(functions === undefined ? {} : { functions }),
+    };
 }
 function parseTest(v) {
     if (!isFields(v))
@@ -370,10 +501,14 @@ function parseTest(v) {
         }
         lines.set(path, list);
     }
+    const branches = parseCounts(v.branches);
+    if (typeof branches === "string")
+        return branches;
     return {
         ...(at === undefined ? {} : { at }),
         ...(preview === undefined ? {} : { preview: preview.filter((l) => typeof l === "string") }),
         lines,
+        ...(branches === undefined ? {} : { branches }),
     };
 }
 /** The one place coverage.json becomes a Coverage. */

package/dist/src/host.js

@@ -122,6 +122,7 @@ async function loadHosted(registration, held) {
         }
         const verdict = validatePlan(session.diff, serializePlanFile(stored.file), {
             lastReview: session.lastReview(),
+            frozen: true,
         });
         if (!verdict.ok) {
             throw new RegistrationError(`plan v${version} no longer fits ${branch}; check it again`);

package/dist/src/plan.js

@@ -556,12 +556,13 @@ function deriveConcernId(unit, c) {
 }
 /**
  * Gives every concern its id and checks where it sits: lines must be change lines the commit
- * takes, and a unit carries at most one concern across the whole plan.
+ * takes, and a unit carries at most one concern in each commit, so each slice of a hunk split
+ * across commits may carry its own.
  */
 function placeConcerns(diff, file, claims, issues) {
     const ids = new Set();
-    const holders = new Map();
     const placedPerCommit = file.commits.map((commit, k) => {
+        const held = new Map();
         const placed = [];
         const add = (c, unit) => {
             const id = deriveConcernId(unit, c);
@@ -578,7 +579,7 @@ function placeConcerns(diff, file, claims, issues) {
             const concerns = ref.concerns ?? [];
             if (concerns.length === 0)
                 return;
-            holders.set(ref.unit, [...(holders.get(ref.unit) ?? []), ...concerns.map(() => k)]);
+            held.set(ref.unit, (held.get(ref.unit) ?? 0) + concerns.length);
             const taken = claims.resolved[k]?.[j]?.select;
             const unit = diff.units.get(ref.unit);
             for (const c of concerns) {
@@ -591,25 +592,25 @@ function placeConcerns(diff, file, claims, issues) {
                     });
                     continue;
                 }
-                const outside = taken?.kind === "lines" ? lines.filter((n) => !taken.changes.includes(n)) : [];
-                if (outside.length > 0) {
+                const takes = taken?.kind === "lines" ? taken : null;
+                const outside = takes === null ? [] : lines.filter((n) => !takes.changes.includes(n));
+                if (takes !== null && outside.length > 0) {
                     issues.push({
                         kind: "bad-concern",
                         commit: k,
-                        reason: `${ref.unit}: concern lines ${outside.join(", ")} are not change lines this commit takes`,
+                        reason: `${ref.unit}: concern lines ${outside.join(", ")} are not change lines this commit takes; \`lines\` are the hunk's [n] as prompt.md shows them, on a slice too, and this commit takes ${formatUnitRef({ unit: ref.unit, select: takes })}`,
                     });
                 }
                 else
                     add(c, ref.unit);
             }
         });
+        for (const [unit, count] of held) {
+            if (count > 1)
+                issues.push({ kind: "too-many-concerns", unit, commit: k, count });
+        }
         return placed;
     });
-    for (const [unit, commits] of holders) {
-        if (commits.length > 1) {
-            issues.push({ kind: "too-many-concerns", unit, commits: [...new Set(commits)] });
-        }
-    }
     return placedPerCommit;
 }
 /** "o_" + 8 hex over the unit and the label: stable while the offer stays at its place. */
@@ -744,6 +745,36 @@ function answerProblem(file, r, isQuestion) {
  * Parses and checks a draft against the diff: every change line used exactly once, every
  * commit's tree valid, and the last commit equal to the tip. Collects all issues at once.
  */
+/**
+ * Sections read top-down: story, steps, details, wiring. A later section never comes back, so a
+ * commit whose section ranks below an earlier commit's must move ahead of the first such commit.
+ */
+function sectionOrder(file) {
+    const issues = [];
+    const placed = [];
+    file.commits.forEach((c, commit) => {
+        if (c.section === undefined)
+            return;
+        const rank = SECTIONS.indexOf(c.section);
+        const first = placed.find((p) => p.rank > rank);
+        if (first !== undefined) {
+            issues.push({
+                kind: "section-order",
+                commit,
+                section: c.section,
+                before: first.commit,
+                beforeSection: first.section,
+            });
+        }
+        else
+            placed.push({ commit, rank, section: c.section });
+    });
+    return issues;
+}
+/**
+ * Judges a draft against the diff. `frozen` re-checks a plan that already passed when it was
+ * frozen: section order is a rule for drafts, so a plan frozen before it was one still fits.
+ */
 export function validatePlan(diff, draft, opts = {}) {
     const parsed = parsePlanFile(draft);
     if (Array.isArray(parsed))
@@ -766,6 +797,8 @@ export function validatePlan(diff, draft, opts = {}) {
             issues.push({ kind: "empty-commit", commit: k });
     });
     issues.push(...offerLimits(file));
+    if (opts.frozen !== true)
+        issues.push(...sectionOrder(file));
     const assignment = [];
     const claims = claim(diff, file, assignment);
     issues.push(...assignment);
@@ -788,17 +821,6 @@ export function validatePlan(diff, draft, opts = {}) {
         if (length > LONG_TITLE)
             warnings.push({ kind: "long-title", commit, length });
     });
-    // Sections read top-down: story, steps, details, wiring. A later section never comes back.
-    let reached = null;
-    file.commits.forEach((c, commit) => {
-        if (c.section === undefined)
-            return;
-        if (reached !== null && SECTIONS.indexOf(c.section) < SECTIONS.indexOf(reached)) {
-            warnings.push({ kind: "section-order", commit, section: c.section, after: reached });
-        }
-        else
-            reached = c.section;
-    });
     const asked = new Map(review?.comments.map((c) => [c.id, c.kind === "question"]));
     for (const r of file.responses) {
         const isQuestion = asked.get(r.comment);