@feigi/fleet-ctl 3.46.0 → 3.46.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/package.json +1 -1
- package/scripts/compute-board.mjs +56 -47
- package/scripts/fleet-tick.mjs +71 -21
- package/scripts/tier-check.mjs +7 -1
package/package.json
CHANGED
|
@@ -22,11 +22,19 @@
|
|
|
22
22
|
// an unsignaled row (no mention, no PR-bound member, no review=/reviewed=)
|
|
23
23
|
// still gets pr: null here while fleet-tick.mjs's own row-key fallback keys
|
|
24
24
|
// it to its ticket number regardless; see the same paragraph below.
|
|
25
|
+
// A card's review, finisher and fix-applier state is its PR's, read off
|
|
26
|
+
// fleet-tick.mjs's own per-PR fold (foldLedger, in its lenient mode: a token
|
|
27
|
+
// it cannot read is skipped and flags the row `ledger-error`, never thrown),
|
|
28
|
+
// not off the card's own row — a ticket retried under a new PR has that PR's
|
|
29
|
+
// tokens on another row. A fallback `#M` row for a PR a ticket row's latest
|
|
30
|
+
// attempt claims is that card's other half and renders no card of its own:
|
|
31
|
+
// its row-level signals (`ledger-error`, held-behind, the cause words, a live
|
|
32
|
+
// member) are the claiming card's.
|
|
25
33
|
// fleet-tick.mjs's I/O and main() never run here, main() being guarded on
|
|
26
34
|
// argv[1].
|
|
27
35
|
import { assessBeat, isStalled, isReported, stallReport, NO_OWNER } from "./fleet-state.mjs";
|
|
28
|
-
import { parseToken, rowPr, premisesOf, HALT_CAUSES, REVIEW
|
|
29
|
-
import { latestFinisherAttempts } from "./fleet-tick.mjs";
|
|
36
|
+
import { parseToken, rowPr, premisesOf, HALT_CAUSES, REVIEW } from "./ledger-grammar.mjs";
|
|
37
|
+
import { latestFinisherAttempts, foldLedger, pastPinDue } from "./fleet-tick.mjs";
|
|
30
38
|
|
|
31
39
|
// A ledger row is freeform, controller-authored text. Two example shapes:
|
|
32
40
|
// #<n> impl-<n>=PR#<m> → PR#<m> → MERGED 73b356de
|
|
@@ -85,14 +93,14 @@ import { latestFinisherAttempts } from "./fleet-tick.mjs";
|
|
|
85
93
|
// live until the token is settled `=failed` or a later `reviewed=` records
|
|
86
94
|
// its result.
|
|
87
95
|
//
|
|
88
|
-
// A `review=` token puts the PR under review only while
|
|
89
|
-
//
|
|
90
|
-
//
|
|
91
|
-
//
|
|
92
|
-
//
|
|
93
|
-
//
|
|
94
|
-
//
|
|
95
|
-
//
|
|
96
|
+
// A `review=` token puts the PR under review only while it is live. A settled
|
|
97
|
+
// `review=…=failed` is a dead review and the PR is owed one again, as run-team
|
|
98
|
+
// SKILL.md defines review-due and as fleet-tick.mjs's `reviewedAny` reads the
|
|
99
|
+
// token: the PR is owed none while any row naming it carries ANY live
|
|
100
|
+
// `review=` — wherever it sits, not only as the last one — or any `reviewed=`.
|
|
101
|
+
// A `review=` token outside the grammar is read as live by foldLedger's
|
|
102
|
+
// lenient mode, which the board reads the PR's state through; the strict tick
|
|
103
|
+
// refuses that ledger outright instead, and the board flags the row.
|
|
96
104
|
//
|
|
97
105
|
// `#N excluded · behind-pr:#M` / `behind-issue:#M` is an Exclusion — pool
|
|
98
106
|
// supply, not a claim — read through ledger-grammar.mjs's premisesOf(), the
|
|
@@ -149,16 +157,12 @@ export function parseRow(row) {
|
|
|
149
157
|
// exists for.
|
|
150
158
|
const live = [];
|
|
151
159
|
const implOutcomes = new Map();
|
|
152
|
-
const finisherOutcomes = new Map();
|
|
153
160
|
const settled = new Set();
|
|
154
161
|
let lastImpl = null; // the latest well-formed impl token (laterAttempt)
|
|
155
|
-
const finishers = []; // well-formed finisher tokens, for the row's PR below
|
|
156
162
|
let anyImpl = false;
|
|
157
163
|
let prMember = false;
|
|
158
164
|
let review = false; // any review= token: a PR-bound signal on a row with no impl token
|
|
159
|
-
let reviewLive = false; // one not settled `=failed`: a live review
|
|
160
165
|
let reviewed = false;
|
|
161
|
-
let reviewedHead = null;
|
|
162
166
|
let runners = [];
|
|
163
167
|
let malformed = false;
|
|
164
168
|
for (const tok of row.split(/\s+/).filter(Boolean)) {
|
|
@@ -174,32 +178,18 @@ export function parseRow(row) {
|
|
|
174
178
|
if (!lastImpl || laterAttempt(t, lastImpl, ticket)) lastImpl = t;
|
|
175
179
|
}
|
|
176
180
|
}
|
|
177
|
-
if (t.family === "finisher-pr" && !t.error) {
|
|
178
|
-
if (t.outcome !== null) finisherOutcomes.set(t.name, t.outcome);
|
|
179
|
-
finishers.push(t);
|
|
180
|
-
}
|
|
181
181
|
if (t.bound === "pr") prMember = true;
|
|
182
182
|
continue;
|
|
183
183
|
}
|
|
184
184
|
if (tok.startsWith("review=")) {
|
|
185
185
|
review = true;
|
|
186
186
|
const { kind, name, failed } = REVIEW.exec(tok)?.groups ?? {};
|
|
187
|
-
if (!failed) reviewLive = true;
|
|
188
187
|
if (kind === "member") {
|
|
189
188
|
if (failed) settled.add(name);
|
|
190
189
|
else { live.push({ kind: "runner", name }); runners.push(name); }
|
|
191
190
|
}
|
|
192
191
|
} else if (tok.startsWith("reviewed=")) {
|
|
193
192
|
reviewed = true;
|
|
194
|
-
// The head that review actually read — the cockpit's own copy
|
|
195
|
-
// of fleet-tick.mjs's `reviewedHead`, needed below to tell a past-pin
|
|
196
|
-
// halt already answered by this review apart from one still owed a
|
|
197
|
-
// fresh one. A token fleet-tick.mjs refuses — one that names no review
|
|
198
|
-
// run — earns the row the same `ledger-error` flag any malformed token
|
|
199
|
-
// does, rather than a row reviewed at no head.
|
|
200
|
-
const m = REVIEWED.exec(tok);
|
|
201
|
-
if (m) reviewedHead = m[1].toLowerCase();
|
|
202
|
-
else malformed = true;
|
|
203
193
|
for (const r of runners) settled.add(r);
|
|
204
194
|
runners = [];
|
|
205
195
|
}
|
|
@@ -222,16 +212,11 @@ export function parseRow(row) {
|
|
|
222
212
|
if (own !== null) pr = own;
|
|
223
213
|
else if ((prMember || review || reviewed) && row.split(/\s/)[0] === issueM[0]) pr = Number(issueM[1]);
|
|
224
214
|
}
|
|
225
|
-
let lastFinisher = null;
|
|
226
|
-
for (const t of finishers) {
|
|
227
|
-
if (t.number === pr && (!lastFinisher || laterAttempt(t, lastFinisher, pr))) lastFinisher = t;
|
|
228
|
-
}
|
|
229
215
|
return {
|
|
230
216
|
issue: Number(issueM[1]),
|
|
231
217
|
excluded,
|
|
232
218
|
impl: lastImpl?.name ?? null,
|
|
233
219
|
implOutcome,
|
|
234
|
-
finisherOutcome: lastFinisher ? (finisherOutcomes.get(lastFinisher.name) ?? null) : null,
|
|
235
220
|
agent: alive.length ? alive[alive.length - 1].name : null,
|
|
236
221
|
pr,
|
|
237
222
|
merged: !!mergedM,
|
|
@@ -239,9 +224,6 @@ export function parseRow(row) {
|
|
|
239
224
|
heldBehind: heldM ? Number(heldM[1]) : null,
|
|
240
225
|
causes,
|
|
241
226
|
malformed,
|
|
242
|
-
reviewed,
|
|
243
|
-
reviewedHead,
|
|
244
|
-
underReview: reviewLive || alive.some((e) => e.kind === "member" && (e.token.family === "fix-pr" || e.token.family === "finisher-pr")),
|
|
245
227
|
};
|
|
246
228
|
}
|
|
247
229
|
|
|
@@ -470,13 +452,45 @@ export function computeBoard(inputs) {
|
|
|
470
452
|
if (s.issue != null) ruledByPr.set(s.issue, s.subject);
|
|
471
453
|
}
|
|
472
454
|
|
|
473
|
-
const
|
|
455
|
+
const rows = ledger.rows || [];
|
|
456
|
+
const fold = foldLedger({ rows, dispatched: ledger.dispatched || [] }, new Set(prs.map((p) => p.number)), { lenient: true });
|
|
457
|
+
const parsed = [];
|
|
458
|
+
for (const [i, row] of rows.entries()) {
|
|
459
|
+
const p = parseRow(row);
|
|
460
|
+
if (p) parsed.push({ ...p, malformed: p.malformed || fold.malformed.has(i) });
|
|
461
|
+
}
|
|
462
|
+
// The ticket row each PR's latest attempt settled to, first row wins.
|
|
463
|
+
const claimedBy = new Map();
|
|
464
|
+
for (const p of parsed) if (p.impl !== null && p.pr != null && !claimedBy.has(p.pr)) claimedBy.set(p.pr, p);
|
|
465
|
+
// A fallback `#M` row — no impl token of its own, keyed to its own ticket
|
|
466
|
+
// number — for a PR a ticket row's latest attempt claims is that card's other
|
|
467
|
+
// half, not a second card: what the row says about the PR goes onto the
|
|
468
|
+
// claiming card, and a live member on it is the card's agent.
|
|
469
|
+
const cards = [];
|
|
470
|
+
for (const p of parsed) {
|
|
471
|
+
const claimer = p.impl === null && p.pr === p.issue ? claimedBy.get(p.pr) : undefined;
|
|
472
|
+
if (claimer === undefined) { cards.push(p); continue; }
|
|
473
|
+
claimer.malformed ||= p.malformed;
|
|
474
|
+
claimer.heldBehind ??= p.heldBehind;
|
|
475
|
+
for (const c of p.causes) if (!claimer.causes.includes(c)) claimer.causes.push(c);
|
|
476
|
+
claimer.agent = p.agent ?? claimer.agent;
|
|
477
|
+
claimer.merged ||= p.merged;
|
|
478
|
+
}
|
|
474
479
|
const unqueued = new Set(prs.filter((p) => p.state === "OPEN" && !(p.labels || []).includes("ready-to-merge")).map((p) => p.number));
|
|
475
|
-
const latestFinishers = new Map(latestFinisherAttempts({ rows
|
|
480
|
+
const latestFinishers = new Map(latestFinisherAttempts({ rows, dispatched: ledger.dispatched || [] }, unqueued).map((u) => [u.pr, u.outcome]));
|
|
481
|
+
// Review state is the PR's, read off the tick's own fold — a card's
|
|
482
|
+
// PR is its row's latest attempt, whichever row carries that PR's tokens.
|
|
483
|
+
const liveMember = (names) => [...names].some((n) => fold.members.get(n).outcome === null);
|
|
484
|
+
const reviewOwed = (prNum) => {
|
|
485
|
+
const st = fold.byPr.get(prNum);
|
|
486
|
+
if (st === undefined) return true;
|
|
487
|
+
if (st.inFlight || liveMember(st.fixMembers) || liveMember(st.finishers)) return false;
|
|
488
|
+
return !st.reviewedAny || pastPinDue(st, prByNum.get(prNum)?.headRefOid);
|
|
489
|
+
};
|
|
476
490
|
const rowIssues = new Set();
|
|
477
491
|
const tickets = [];
|
|
478
492
|
|
|
479
|
-
for (const p of
|
|
493
|
+
for (const p of cards) {
|
|
480
494
|
const pr = p.pr != null ? prByNum.get(p.pr) : undefined;
|
|
481
495
|
const prevTicket = prevByIssue.get(p.issue);
|
|
482
496
|
const prState = p.pr == null ? null
|
|
@@ -525,19 +539,14 @@ export function computeBoard(inputs) {
|
|
|
525
539
|
|
|
526
540
|
// Backlog is a PR nobody has reviewed and nobody is reviewing: no live
|
|
527
541
|
// `review=` (a settled `=failed` one is no review), no
|
|
528
|
-
// `reviewed=`, and no live fix-applier or finisher on the
|
|
542
|
+
// `reviewed=`, and no live fix-applier or finisher on the PR — or
|
|
529
543
|
// a returned review whose finisher halted `past-pin` against a head it
|
|
530
544
|
// never read: owed again until the head catches up to what `reviewed=`
|
|
531
545
|
// recorded, the same rule fleet-tick.mjs's reviewDue reads off headRefOid
|
|
532
546
|
// (pastPinDue). A PR absent from the open list (closed, not yet MERGED)
|
|
533
547
|
// reads as an unmatched head, never as answered — silence is not review.
|
|
534
|
-
|
|
535
|
-
const
|
|
536
|
-
&& !String(prByNum.get(p.pr)?.headRefOid ?? "").toLowerCase().startsWith(p.reviewedHead);
|
|
537
|
-
const reviewBacklog = tickets.filter((t) => {
|
|
538
|
-
const p = parsedByIssue.get(t.issue);
|
|
539
|
-
return t.column === "REVIEW" && !p.underReview && (!p.reviewed || pastPinBacklog(p));
|
|
540
|
-
}).length;
|
|
548
|
+
// Counted once per PR, off the per-PR fold, however many cards name it.
|
|
549
|
+
const reviewBacklog = new Set(tickets.filter((t) => t.column === "REVIEW" && reviewOwed(t.pr)).map((t) => t.pr)).size;
|
|
541
550
|
const cardsInPool = tickets.filter((t) => t.column === "POOL").length;
|
|
542
551
|
// A capped pool read makes this count a floor, and it says so the way
|
|
543
552
|
// fleet-tick.mjs's claimed count does — `"100+"`, never a bare 100 that
|
package/scripts/fleet-tick.mjs
CHANGED
|
@@ -525,7 +525,20 @@ export function unlabelledFinishers(ledger, unqueued) {
|
|
|
525
525
|
.map((u) => ({ pr: u.pr, labelled: u.attempts.filter((a) => a.outcome === "labelled").map((a) => a.name) }));
|
|
526
526
|
}
|
|
527
527
|
|
|
528
|
-
|
|
528
|
+
// The per-PR fold: every row and `## Dispatched` entry read once into one
|
|
529
|
+
// state per PR, shared by every row that resolves to it. deriveRun reads its
|
|
530
|
+
// counts off this, and compute-board.mjs reads each card's PR state off the
|
|
531
|
+
// same one — a second row→PR join in the cockpit is a second answer to which
|
|
532
|
+
// PR a token speaks for. Returns `{members, byPr, verdicts, claimed, excluded,
|
|
533
|
+
// malformed}`: `members` the merged record per member name, `byPr` the state
|
|
534
|
+
// per PR, `malformed` the indexes of the `rows` a token was skipped on.
|
|
535
|
+
//
|
|
536
|
+
// Strict by default: a token it cannot read throws LedgerError. `lenient` is
|
|
537
|
+
// the cockpit's mode — its contract is that unknown text is flagged, never
|
|
538
|
+
// fatal — and skips that token instead, recording its row in `malformed`. A
|
|
539
|
+
// skipped `review=` still reads as a live review and a skipped `reviewed=` as
|
|
540
|
+
// a returned one at no head, the readings the cockpit has always given them.
|
|
541
|
+
export function foldLedger({ rows, dispatched }, open, { lenient = false } = {}) {
|
|
529
542
|
// One entry per member name across `## Dispatched` and every row. A member
|
|
530
543
|
// settled ANYWHERE is settled: `settle` is the only writer of an outcome, and
|
|
531
544
|
// a bare copy beside it is what a whole-line `row` rewrite leaves behind.
|
|
@@ -538,19 +551,26 @@ export function deriveRun({ rows, dispatched, drain }, prs, closed = new Set(),
|
|
|
538
551
|
// row naming no PR, which settles no PR-bound member); a stray's token
|
|
539
552
|
// still creates the member, live, as before.
|
|
540
553
|
const members = new Map();
|
|
554
|
+
const malformed = new Set();
|
|
541
555
|
const note = (t, where, rowPr) => {
|
|
542
|
-
if (t.error)
|
|
556
|
+
if (t.error) {
|
|
557
|
+
if (lenient) return false;
|
|
558
|
+
throw new LedgerError(`${where}: ${t.name}: ${t.error}`);
|
|
559
|
+
}
|
|
543
560
|
const m = members.get(t.name) ?? { name: t.name, family: t.family, number: t.number, outcome: null };
|
|
544
561
|
if (t.outcome !== null && (t.bound !== "pr" || rowPr === undefined || t.number === rowPr)) m.outcome = t.outcome;
|
|
545
562
|
members.set(t.name, m);
|
|
563
|
+
return true;
|
|
546
564
|
};
|
|
547
565
|
for (const e of dispatched) {
|
|
548
566
|
const t = parseToken(e);
|
|
549
|
-
if (!t)
|
|
567
|
+
if (!t) {
|
|
568
|
+
if (lenient) continue;
|
|
569
|
+
throw new LedgerError(`## Dispatched entry '${e}' is not a member token — fix the ledger by hand before the tick can count from it`);
|
|
570
|
+
}
|
|
550
571
|
note(t, `## Dispatched entry '${e}'`);
|
|
551
572
|
}
|
|
552
573
|
|
|
553
|
-
const open = new Set(prs.map((p) => p.number));
|
|
554
574
|
const claimed = new Set();
|
|
555
575
|
const excluded = [];
|
|
556
576
|
const byPr = new Map();
|
|
@@ -581,7 +601,7 @@ export function deriveRun({ rows, dispatched, drain }, prs, closed = new Set(),
|
|
|
581
601
|
if (t && !t.error && t.family === "fix-pr" && t.number === pr && t.outcome !== null) settledInRow.add(t.name);
|
|
582
602
|
}
|
|
583
603
|
}
|
|
584
|
-
for (const text of rows) {
|
|
604
|
+
for (const [i, text] of rows.entries()) {
|
|
585
605
|
const { keyNum, pr } = rowNums(text);
|
|
586
606
|
const where = `row '${text}'`;
|
|
587
607
|
// One state per PR, shared by every row that resolves to it: a
|
|
@@ -618,10 +638,10 @@ export function deriveRun({ rows, dispatched, drain }, prs, closed = new Set(),
|
|
|
618
638
|
inFlight: false, reviewedAny: false, survived: 0, unverified: 0, reviewFixed: false,
|
|
619
639
|
fixMembers: new Set(), fixLanded: new Set(), conflictLanded: new Set(), held: [],
|
|
620
640
|
conflictOpen: false, reviewedHead: null, reviewedRun: null, pastPinHalt: false, dispositions: [], workers: new Set(),
|
|
641
|
+
finishers: new Set(),
|
|
621
642
|
};
|
|
622
643
|
// The finisher-pr token currently deciding `pastPinHalt`, picked by
|
|
623
|
-
// retry suffix ("" < "b" < "c" …)
|
|
624
|
-
// laterAttempt does — never by row-text position. A
|
|
644
|
+
// retry suffix ("" < "b" < "c" …) — never by row-text position. A
|
|
625
645
|
// `-b` retry can sit before an older `halted:past-pin` token after a row
|
|
626
646
|
// rewrite, and text order must not read the stale one as the live
|
|
627
647
|
// finisher's replacement. Reset at each `reviewed=`, since `pastPinHalt`
|
|
@@ -630,7 +650,10 @@ export function deriveRun({ rows, dispatched, drain }, prs, closed = new Set(),
|
|
|
630
650
|
for (const tok of text.split(/\s+/).filter(Boolean)) {
|
|
631
651
|
const t = parseToken(tok);
|
|
632
652
|
if (t) {
|
|
633
|
-
note(t, where, pr)
|
|
653
|
+
if (!note(t, where, pr)) {
|
|
654
|
+
malformed.add(i);
|
|
655
|
+
continue;
|
|
656
|
+
}
|
|
634
657
|
if ((t.bound === "pr" && t.number === pr) || t.family === "impl") st.workers.add(t.name);
|
|
635
658
|
// A settled `failed`/`killed` fix-applier leaves review findings or a
|
|
636
659
|
// conflict unfixed and no successor dispatched — the PR stays fix-due
|
|
@@ -675,6 +698,7 @@ export function deriveRun({ rows, dispatched, drain }, prs, closed = new Set(),
|
|
|
675
698
|
} else st.reviewFixed = true;
|
|
676
699
|
}
|
|
677
700
|
}
|
|
701
|
+
if (t.family === "finisher-pr" && t.number === pr) st.finishers.add(t.name);
|
|
678
702
|
if (t.family === "finisher-pr" && t.number === pr
|
|
679
703
|
&& (!latestFinisher || (t.retry ?? "") > (latestFinisher.retry ?? ""))) {
|
|
680
704
|
latestFinisher = t;
|
|
@@ -684,11 +708,23 @@ export function deriveRun({ rows, dispatched, drain }, prs, closed = new Set(),
|
|
|
684
708
|
}
|
|
685
709
|
if (tok.startsWith("review=")) {
|
|
686
710
|
const m = REVIEW.exec(tok);
|
|
711
|
+
if (!m && lenient) {
|
|
712
|
+
malformed.add(i);
|
|
713
|
+
st.inFlight = true;
|
|
714
|
+
st.reviewedAny = true;
|
|
715
|
+
continue;
|
|
716
|
+
}
|
|
687
717
|
if (!m) throw new LedgerError(`${where}: '${tok}' is not review=wf:<runId> | member:review-pr-<n>, optionally =failed`);
|
|
688
718
|
st.inFlight = !m.groups.failed;
|
|
689
719
|
if (!m.groups.failed) st.reviewedAny = true;
|
|
690
720
|
} else if (tok.startsWith("reviewed=")) {
|
|
691
721
|
const m = REVIEWED.exec(tok);
|
|
722
|
+
if (!m && lenient) {
|
|
723
|
+
malformed.add(i);
|
|
724
|
+
latestFinisher = null;
|
|
725
|
+
Object.assign(st, { inFlight: false, reviewedAny: true, reviewFixed: false, pastPinHalt: false });
|
|
726
|
+
continue;
|
|
727
|
+
}
|
|
692
728
|
if (!m && REVIEWED_RUNLESS.test(tok)) {
|
|
693
729
|
throw new LedgerError(`${where}: '${tok}' names no review run — reviewed= is now <head>:<survived>/<refuted>/<unverified>:<run>, `
|
|
694
730
|
+ "<run> the run-XXXXXXXX directory holding that review's review.json; drop the token with `ledger.mjs row` and record it again with `ledger.mjs review <pr>`");
|
|
@@ -700,7 +736,8 @@ export function deriveRun({ rows, dispatched, drain }, prs, closed = new Set(),
|
|
|
700
736
|
reviewedHead: m[1].toLowerCase(), reviewedRun: m[5], pastPinHalt: false,
|
|
701
737
|
});
|
|
702
738
|
} else if (labelOffMember(tok) === null) {
|
|
703
|
-
throw new LedgerError(`${where}: '${tok}' is not label-off=<finisher-pr member> — fix the row with \`ledger.mjs row\``);
|
|
739
|
+
if (!lenient) throw new LedgerError(`${where}: '${tok}' is not label-off=<finisher-pr member> — fix the row with \`ledger.mjs row\``);
|
|
740
|
+
malformed.add(i);
|
|
704
741
|
} else {
|
|
705
742
|
const h = HELD.exec(tok);
|
|
706
743
|
if (h) st.held.push(Number(h[1]));
|
|
@@ -710,14 +747,18 @@ export function deriveRun({ rows, dispatched, drain }, prs, closed = new Set(),
|
|
|
710
747
|
// misrecorded one, and read on a guess it would either hold the
|
|
711
748
|
// wrong PR or leave this one silently stalled.
|
|
712
749
|
if (Number(c[1]) !== pr) {
|
|
713
|
-
|
|
750
|
+
if (!lenient) {
|
|
751
|
+
throw new LedgerError(`${where}: '${tok}' names PR #${c[1]}, but this row is ${pr === null ? "no PR's" : `PR #${pr}'s`} — a conflict hold goes on the held PR's own row`);
|
|
752
|
+
}
|
|
753
|
+
malformed.add(i);
|
|
754
|
+
} else {
|
|
755
|
+
// A fresh hold is unresolved whatever settled before it, the way a
|
|
756
|
+
// fresh `reviewed=` resets `reviewFixed` above. A redundant re-hold
|
|
757
|
+
// (merge-bot retrying a PR it has already held) changes
|
|
758
|
+
// nothing a live fix-applier holds off: liveness is not read off
|
|
759
|
+
// token order.
|
|
760
|
+
st.conflictOpen = true;
|
|
714
761
|
}
|
|
715
|
-
// A fresh hold is unresolved whatever settled before it, the way a
|
|
716
|
-
// fresh `reviewed=` resets `reviewFixed` above. A redundant re-hold
|
|
717
|
-
// (merge-bot retrying a PR it has already held) changes
|
|
718
|
-
// nothing a live fix-applier holds off: liveness is not read off
|
|
719
|
-
// token order.
|
|
720
|
-
st.conflictOpen = true;
|
|
721
762
|
}
|
|
722
763
|
const v = TIER_VERDICT.exec(tok);
|
|
723
764
|
if (v) verdicts[v[1]].add(v[2]);
|
|
@@ -741,6 +782,20 @@ export function deriveRun({ rows, dispatched, drain }, prs, closed = new Set(),
|
|
|
741
782
|
}
|
|
742
783
|
if (pr !== null) byPr.set(pr, st);
|
|
743
784
|
}
|
|
785
|
+
return { members, byPr, verdicts, claimed, excluded, malformed };
|
|
786
|
+
}
|
|
787
|
+
|
|
788
|
+
// A PR whose latest finisher halted `past-pin` against a returned review owes
|
|
789
|
+
// a fresh one while its head is still past what that review read: a
|
|
790
|
+
// `reviewed=` head (7-40 hex) prefix-matching gh's full headRefOid is the head
|
|
791
|
+
// that review read, and there is nothing more to review. `st` is a `byPr`
|
|
792
|
+
// state, `undefined` for a PR no row names.
|
|
793
|
+
export const pastPinDue = (st, head) => st !== undefined && st.pastPinHalt && !st.inFlight && st.reviewedHead !== null
|
|
794
|
+
&& !String(head).toLowerCase().startsWith(st.reviewedHead);
|
|
795
|
+
|
|
796
|
+
export function deriveRun({ rows, dispatched, drain }, prs, closed = new Set(), finished = new Set()) {
|
|
797
|
+
const open = new Set(prs.map((p) => p.number));
|
|
798
|
+
const { members, byPr, verdicts, claimed, excluded } = foldLedger({ rows, dispatched }, open);
|
|
744
799
|
|
|
745
800
|
const all = [...members.values()];
|
|
746
801
|
const live = (family) => all.filter((m) => m.family === family && m.outcome === null).length;
|
|
@@ -797,11 +852,6 @@ export function deriveRun({ rows, dispatched, drain }, prs, closed = new Set(),
|
|
|
797
852
|
const retry = parseMember(cur.member).retry ?? "";
|
|
798
853
|
return ![...st.fixLanded].some((n) => !st.conflictLanded.has(n) && (parseMember(n).retry ?? "") > retry);
|
|
799
854
|
};
|
|
800
|
-
// The halt holds only while the head is still past what was reviewed: a
|
|
801
|
-
// `reviewed=` head (7-40 hex) prefix-matching gh's full headRefOid is the
|
|
802
|
-
// head that review read, and there is nothing more to review.
|
|
803
|
-
const pastPinDue = (st, head) => st !== undefined && st.pastPinHalt && !st.inFlight && st.reviewedHead !== null
|
|
804
|
-
&& !String(head).toLowerCase().startsWith(st.reviewedHead);
|
|
805
855
|
// A `review=` token with no `reviewed=` after it reads as in flight, and the
|
|
806
856
|
// ledger alone never says otherwise: a review whose own `reviewed=` write
|
|
807
857
|
// never landed stays in flight after its PR merges, holding a reviewer slot
|
package/scripts/tier-check.mjs
CHANGED
|
@@ -117,7 +117,13 @@ export function declaredPairFor(frontmatter) {
|
|
|
117
117
|
// assistant turn's own `model`: the identity exists before the member's
|
|
118
118
|
// first turn, where the per-turn model does not, so preferring it is what
|
|
119
119
|
// makes this check usable immediately after a background dispatch rather
|
|
120
|
-
// than only once a member has already produced output.
|
|
120
|
+
// than only once a member has already produced output. A mid-run retry
|
|
121
|
+
// fallback (omp's `retry.fallbackChains` substituting a model after
|
|
122
|
+
// dispatch) is outside this check by design: `session_init` is never
|
|
123
|
+
// rewritten, so the identity stays the dispatched route, and the model that
|
|
124
|
+
// served the member's last turn is member-outcomes.mjs's per-turn `model`
|
|
125
|
+
// (last turn wins, so a fallback that reverts within the run never shows in
|
|
126
|
+
// it), not a tier verdict.
|
|
121
127
|
export function resolveActual({ transcriptText, resolvedModel, resolvedThinkingLevel }) {
|
|
122
128
|
if (resolvedModel && resolvedThinkingLevel) {
|
|
123
129
|
return { model: resolvedModel, level: resolvedThinkingLevel, viaJobRecord: true };
|