toolroll 0.9.31 → 0.9.33

package/dist/project-learning.js

@@ -54,13 +54,100 @@ const git = (repo, args, seen) => {
     seen?.set(key, out);
     return out;
 };
+const sameValue = (n) => typeof n === 'bigint' ? n.toString() : n;
 /** Path plus the physical shared Git database: replacing a repository does not inherit its lessons. */
-export function learningIdentity(repo, seen) {
+export const identityOf = (repo, common, st) => learningSha(JSON.stringify([repo, common, sameValue(st.ino), st.birthtimeMs]));
+/** The formula before 0.9.33, which also hashed st.dev; macOS may renumber a volume at restart. */
+export const legacyIdentityOf = (repo, common, st) => learningSha(JSON.stringify([repo, common, sameValue(st.dev), sameValue(st.ino), st.birthtimeMs]));
+function identityFacts(repo, seen) {
     if (canonicalProject(repo) !== repo)
         throw new Error('Project identity changed.');
     const common = realpathSync(resolve(repo, git(repo, ['rev-parse', '--git-common-dir'], seen)));
-    const st = statSync(common);
-    return learningSha(JSON.stringify([repo, common, st.dev, st.ino, st.birthtimeMs]));
+    return { common, st: statSync(common) };
+}
+export function learningIdentity(repo, seen) {
+    const { common, st } = identityFacts(repo, seen);
+    return identityOf(repo, common, st);
+}
+/** Projects whose rows have already been checked for a same-repository carry, per store. */
+const reconciled = new WeakMap();
+// Every table that saves a project identity. Rows are never rewritten: a carry aliases them.
+const STORED_IDENTITY = `SELECT 1 FROM project_knowledge WHERE repo=?1 AND identity=?2
+ UNION ALL SELECT 1 FROM knowledge_change WHERE repo=?1 AND identity=?2
+ UNION ALL SELECT 1 FROM knowledge_snapshot WHERE repo=?1 AND identity=?2
+ UNION ALL SELECT 1 FROM project_skill_change WHERE repo=?1 AND identity=?2
+ UNION ALL SELECT 1 FROM skill_test JOIN task_ref ON task_ref.id=skill_test.task_ref WHERE task_ref.repo=?1 AND skill_test.identity=?2
+ UNION ALL SELECT 1 FROM learning_policy WHERE repo=?1 AND identity=?2
+ UNION ALL SELECT 1 FROM project_lesson WHERE repo=?1 AND identity=?2
+ UNION ALL SELECT 1 FROM learning_capture WHERE repo=?1 AND identity=?2
+ UNION ALL SELECT 1 FROM learning_snapshot WHERE repo=?1 AND identity=?2
+ UNION ALL SELECT 1 FROM project_decision WHERE repo=?1 AND identity=?2 LIMIT 1`;
+/**
+ * Record that saved project rows under `from` belong to the project now known as `to`.
+ * Knowledge saved under `from` also gets a new revision under `to`; older revisions stay as they are.
+ * Returns the new knowledge revision, or null when knowledge needed none.
+ */
+export function carryProject(store, repo, args, now = new Date()) {
+    return store.transact(() => {
+        store.handle.prepare('INSERT OR IGNORE INTO project_identity_carry(repo,from_identity,to_identity,actor,at,how) VALUES (?,?,?,?,?,?)').run(repo, args.from, args.to, args.actor, now.toISOString(), args.how);
+        const row = store.handle.prepare('SELECT * FROM project_knowledge WHERE repo=?').get(repo);
+        if (!row || row['identity'] !== args.from)
+            return null;
+        const history = store.handle.prepare('SELECT sha FROM knowledge_change WHERE repo=? AND identity=? AND revision=?').get(repo, args.from, row['revision']);
+        if (history?.['sha'] !== row['sha'] || learningSha(String(row['payload'])) !== row['sha'])
+            throw new Error('Project knowledge history could not be verified.');
+        const revision = Number(row['revision']) + 1;
+        store.handle.prepare('INSERT INTO knowledge_change(repo,identity,revision,actor,at,payload,sha) VALUES (?,?,?,?,?,?,?)').run(repo, args.to, revision, args.actor, now.toISOString(), String(row['payload']), String(row['sha']));
+        store.handle.prepare('UPDATE project_knowledge SET identity=?,revision=? WHERE repo=?').run(args.to, revision, repo);
+        return revision;
+    });
+}
+export const SAME_REPOSITORY = 'toolroll (same repository)';
+/**
+ * Carry silently only what is provably the same repository: rows saved under the
+ * previous formula with this volume's current device number (no restart since).
+ */
+export function reconcileIdentity(store, repo, seen, now = new Date()) {
+    const { common, st } = identityFacts(repo, seen);
+    const current = identityOf(repo, common, st), legacy = legacyIdentityOf(repo, common, st);
+    let done = reconciled.get(store);
+    if (!done)
+        reconciled.set(store, done = new Set());
+    const key = `${repo}\n${legacy}`;
+    if (legacy !== current && !done.has(key)) {
+        if (!store.handle.prepare('SELECT 1 FROM project_identity_carry WHERE repo=? AND from_identity=? AND to_identity=?').get(repo, legacy, current)
+            && store.handle.prepare(STORED_IDENTITY).get(repo, legacy)) {
+            // Damaged knowledge history keeps its own error; retry on the next read.
+            try {
+                carryProject(store, repo, { from: legacy, to: current, actor: SAME_REPOSITORY, how: 'automatic' }, now);
+            }
+            catch {
+                return { current, legacy };
+            }
+        }
+        done.add(key);
+    }
+    return { current, legacy };
+}
+/** The current identity and every identity carried into it. Checks accept these; writes use the current one. */
+export function acceptedIdentities(store, repo, seen) {
+    const { current, legacy } = reconcileIdentity(store, repo, seen);
+    const accepted = new Set([current, legacy]);
+    const carries = store.handle.prepare('SELECT from_identity,to_identity FROM project_identity_carry WHERE repo=?').all(repo).map(r => [String(r['from_identity']), String(r['to_identity'])]);
+    for (let grew = true; grew;) {
+        grew = false;
+        for (const [from, to] of carries)
+            if (accepted.has(to) && !accepted.has(from)) {
+                accepted.add(from);
+                grew = true;
+            }
+    }
+    return accepted;
+}
+/** Without a database: the current identity, or the previous formula on this same volume. */
+export function identityMatches(repo, identity) {
+    const { common, st } = identityFacts(repo);
+    return identity === identityOf(repo, common, st) || identity === legacyIdentityOf(repo, common, st);
 }
 function environmentFingerprint(store, repo) {
     return learningSha(JSON.stringify({ platform: process.platform, arch: process.arch, node: process.version,
@@ -158,7 +245,7 @@ export function queueLearning(store, source, reviewer, value, catalog, now, asse
         // Legacy reviews without a learning snapshot need no optional failure.
         if (empty && assessment === undefined && !snapshot)
             return;
-        if (!snapshot || snapshot['repo'] !== repo || snapshot['identity'] !== learningIdentity(repo) || learningSha(String(snapshot['payload'])) !== snapshot['sha'])
+        if (!snapshot || snapshot['repo'] !== repo || !acceptedIdentities(store, repo).has(String(snapshot['identity'])) || learningSha(String(snapshot['payload'])) !== snapshot['sha'])
             throw new Error('Learning review identity is unavailable.');
         const result = assessmentOf(assessment, value);
         // A contradictory decision cannot publish suggestions. Keep its sealed
@@ -216,6 +303,8 @@ export function recoverLearning(store, root, repo, now = new Date(), seen = new
         projects.set(repo, cursor = { reviewer: 0, reviewerEnd: 0, source: 0, sourceEnd: 0 });
     // Freeze each sweep's end so a stream of new arrivals cannot postpone retry
     // of an earlier failed row indefinitely. Cursors never confer eligibility.
+    let accepted;
+    const carried = (identity) => (accepted ??= acceptedIdentities(store, repo, seen)).has(String(identity));
     if (!cursor.reviewerEnd)
         cursor.reviewerEnd = Number(store.handle.prepare('SELECT max(id) AS id FROM run').get()?.['id'] ?? 0);
     // If the optional outbox write failed, recover from the already sealed accepted response.
@@ -234,7 +323,7 @@ export function recoverLearning(store, root, repo, now = new Date(), seen = new
             if (!source || !reviewer || source.taskRef !== reviewer.taskRef)
                 continue;
             const snapshot = reviewSnapshot(store, reviewer.id);
-            if (!snapshot || snapshot['identity'] !== learningIdentity(repo, seen))
+            if (!snapshot || !carried(snapshot['identity']))
                 continue;
             const response = store.artifactsFor(reviewer.id).find(a => a.kind === 'structured-output' && a.captureStatus === 'ok');
             const read = response && readVerifiedArtifact(root, response);
@@ -270,7 +359,7 @@ export function recoverLearning(store, root, repo, now = new Date(), seen = new
                     throw new Error('Learning review provenance is unavailable.');
                 const candidates = parseLearning(JSON.parse(String(row['payload'])));
                 const identity = learningIdentity(repo, seen);
-                if (identity !== row['identity'])
+                if (!carried(row['identity']))
                     throw new Error('Learning project identity changed.');
                 const head = run.headRevision ?? run.baseRevision ?? '';
                 const diff = store.artifactsFor(source).find(a => a.kind === 'terminal-diff');
@@ -312,7 +401,7 @@ function lessonOf(row) {
     return { id: Number(row['id']), repo: String(row['repo']), source: Number(row['source']), reviewer: Number(row['reviewer']), status: String(row['status']), version: Number(row['version']), payload, sha: String(row['sha']), identity: String(row['identity']), adoptedBy: row['adopted_by'] == null ? null : String(row['adopted_by']) };
 }
 function supported(store, root, lesson, seen) {
-    if (lesson.identity !== learningIdentity(lesson.repo, seen))
+    if (!acceptedIdentities(store, lesson.repo, seen).has(lesson.identity))
         throw new Error('Project identity changed.');
     const capture = store.handle.prepare('SELECT catalog FROM learning_capture WHERE source=? AND reviewer=? AND repo=?').get(lesson.source, lesson.reviewer, lesson.repo);
     if (!capture || reviewedSource(store, lesson.reviewer) !== lesson.source)
@@ -325,9 +414,9 @@ function supported(store, root, lesson, seen) {
 export function learningView(store, root, repo, actor, before = 0) {
     admission(store, repo, actor);
     recoverLearning(store, root, repo);
-    const identity = learningIdentity(repo);
+    const identity = learningIdentity(repo), accepted = acceptedIdentities(store, repo);
     const p = store.handle.prepare('SELECT * FROM learning_policy WHERE repo=?').get(repo);
-    const revision = Number(p?.['revision'] ?? 0), enabled = p?.['identity'] === identity && p?.['enabled'] === 1;
+    const revision = Number(p?.['revision'] ?? 0), enabled = accepted.has(String(p?.['identity'])) && p?.['enabled'] === 1;
     let damaged = false;
     const lessons = store.handle.prepare('SELECT * FROM project_lesson WHERE repo=? ORDER BY id DESC LIMIT 50').all(repo).flatMap(row => { try {
         return [lessonOf(row)];
@@ -344,8 +433,9 @@ export function changeLearning(store, root, args, now = new Date()) {
         admission(store, args.repo, args.actor, true);
         if (learningIdentity(args.repo) !== args.identity)
             throw new Error('Project identity changed. Reload Learning.');
+        const accepted = acceptedIdentities(store, args.repo);
         const p = store.handle.prepare('SELECT * FROM learning_policy WHERE repo=?').get(args.repo);
-        if (Number(p?.['revision'] ?? 0) !== args.revision || (p && p['identity'] !== args.identity && args.action !== 'reset'))
+        if (Number(p?.['revision'] ?? 0) !== args.revision || (p && !accepted.has(String(p['identity'])) && args.action !== 'reset'))
             throw new Error('Learning changed. Reload before trying again.');
         let before = p?.['enabled'] === 1 ? 'enabled' : 'paused', after = before, ev = [], source = null;
         if (args.action === 'adopt' || args.action === 'disable') {
@@ -353,7 +443,7 @@ export function changeLearning(store, root, args, now = new Date()) {
             if (!row)
                 throw new Error('Learning lesson is unavailable.');
             const l = lessonOf(row);
-            if (l.version !== args.version || l.sha !== args.sha || l.identity !== args.identity)
+            if (l.version !== args.version || l.sha !== args.sha || !accepted.has(l.identity))
                 throw new Error('Learning changed. Reload before trying again.');
             if (l.payload.kind !== 'project' || (args.action === 'adopt' ? l.status !== 'proposed' : l.status !== 'adopted'))
                 throw new Error('This suggestion cannot take that action.');
@@ -396,14 +486,14 @@ export function learningContext(store, root, runId, phase, now = new Date(), val
             const runner = store.getRunner(run.runner)?.runner;
             if (!runner || runner.retiredAt !== null || !runner.repos.includes(repo) || (phase === 'review') !== (run.role === 'reviewer') || (phase === 'plan') !== (run.role === 'planner'))
                 return '';
-            const identity = learningIdentity(repo, seen);
+            const identity = learningIdentity(repo, seen), accepted = acceptedIdentities(store, repo, seen), carried = JSON.stringify([...accepted]);
             const existing = store.handle.prepare('SELECT * FROM learning_snapshot WHERE run=?').get(runId);
             if (existing) {
-                if (existing['repo'] !== repo || existing['identity'] !== identity || learningSha(String(existing['payload'])) !== existing['sha'])
+                if (existing['repo'] !== repo || !accepted.has(String(existing['identity'])) || learningSha(String(existing['payload'])) !== existing['sha'])
                     throw new Error('Learning snapshot no longer verifies.');
                 return String(existing['payload']);
             }
-            const policy = store.handle.prepare('SELECT * FROM learning_policy WHERE repo=? AND identity=? AND enabled=1').get(repo, identity);
+            const policy = store.handle.prepare('SELECT * FROM learning_policy WHERE repo=? AND identity IN (SELECT value FROM json_each(?)) AND enabled=1').get(repo, carried);
             const scope = ref && store.getScope(ref.externalId);
             const source = run.role === 'reviewer' && run.parentRun !== null ? store.getRun(run.parentRun) : run;
             // Prepared coding handoffs defer recording their validated base until
@@ -415,7 +505,7 @@ export function learningContext(store, root, runId, phase, now = new Date(), val
             const unscopedPlan = phase === 'plan' && scope === null && !run.scopeDigest;
             const eligible = [];
             if (policy && (paths.length > 0 || unscopedPlan)) {
-                for (const row of store.handle.prepare("SELECT * FROM project_lesson WHERE repo=? AND identity=? AND status='adopted' ORDER BY id DESC LIMIT 100").all(repo, identity)) {
+                for (const row of store.handle.prepare("SELECT * FROM project_lesson WHERE repo=? AND identity IN (SELECT value FROM json_each(?)) AND status='adopted' ORDER BY id DESC LIMIT 100").all(repo, carried)) {
                     try {
                         const l = lessonOf(row);
                         if (!store.handle.prepare("SELECT 1 FROM learning_event WHERE lesson=? AND action='adopt' AND actor=?").get(l.id, l.adoptedBy ?? '') || l.source === source?.id || l.payload.kind !== 'project' || !l.adoptedBy || !store.accountCanAccess(l.adoptedBy, repo) || store.accountOf(l.adoptedBy)?.role !== 'approver' || !l.payload.phases.includes(phase) || l.payload.platform !== process.platform || (!unscopedPlan && !l.payload.paths.some(p => paths.some(t => p === t || p.startsWith(t.replace(/\/$/, '') + '/')))))

package/dist/project-skills.js

@@ -3,7 +3,7 @@ import { createHash } from "node:crypto";
 import { mkdirSync, mkdtempSync, writeFileSync, chmodSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { parseDocument } from "yaml";
-import { learningIdentity, learningSha } from "./project-learning.js";
+import { acceptedIdentities, learningIdentity, learningSha } from "./project-learning.js";
 import { scanForSecrets } from "./evidence.js";
 import { fileTaskProposal } from "./proposal.js";
 export const SKILLS_SCHEMA = `
@@ -120,8 +120,11 @@ function admit(store, repo, actor, write = false) {
         !store.accountCanAccess(actor, repo) ||
         (write && store.accountOf(actor)?.role !== "approver"))
         throw Error("Skills are outside your project access.");
-    return learningIdentity(repo);
+    return { identity: learningIdentity(repo), accepted: acceptedIdentities(store, repo) };
 }
+/** Revisions under any identity this project accepts, as a bound JSON list. */
+const IN_ACCEPTED = "identity IN (SELECT value FROM json_each(?))";
+const listOf = (accepted) => JSON.stringify([...accepted]);
 function unpack(payload, sha) {
     if (typeof payload !== "string" || learningSha(payload) !== sha)
         throw Error("Saved skills could not be verified.");
@@ -135,13 +138,13 @@ function packageOf(store, sha) {
         throw Error("That skill version is unavailable.");
     return { ...unpack(row["payload"], sha), sha };
 }
-function current(store, repo, identity) {
+function current(store, repo, accepted) {
     const row = store.handle
         .prepare("SELECT * FROM project_skill_change WHERE repo=? ORDER BY revision DESC LIMIT 1")
         .get(repo);
     if (!row)
         return { revision: 0, selection: {} };
-    if (row["identity"] !== identity)
+    if (!accepted.has(String(row["identity"])))
         throw Error("The project changed. Its previous skills have not been applied.");
     return {
         revision: Number(row["revision"]),
@@ -149,7 +152,7 @@ function current(store, repo, identity) {
     };
 }
 export function skillsView(store, repo, actor) {
-    const identity = admit(store, repo, actor), value = current(store, repo, identity);
+    const { identity, accepted } = admit(store, repo, actor), value = current(store, repo, accepted);
     const visible = new Set(store.handle
         .prepare("SELECT sha FROM skill_owner WHERE actor=? ORDER BY at,sha")
         .all(actor)
@@ -162,7 +165,7 @@ export function skillsView(store, repo, actor) {
             .get(project);
         if (row) {
             try {
-                if (row["identity"] !== learningIdentity(project))
+                if (!acceptedIdentities(store, project).has(String(row["identity"])))
                     continue;
             }
             catch {
@@ -183,8 +186,8 @@ export function skillsView(store, repo, actor) {
         .map((sha) => packageOf(store, sha))
         .sort((a, b) => a.name.localeCompare(b.name));
     const history = store.handle
-        .prepare("SELECT revision,actor,at,payload,sha FROM project_skill_change WHERE repo=? AND identity=? ORDER BY revision DESC LIMIT 20")
-        .all(repo, identity)
+        .prepare(`SELECT revision,actor,at,payload,sha FROM project_skill_change WHERE repo=? AND ${IN_ACCEPTED} ORDER BY revision DESC LIMIT 20`)
+        .all(repo, listOf(accepted))
         .map((r) => ({
         revision: Number(r["revision"]),
         actor: String(r["actor"]),
@@ -197,8 +200,8 @@ export function skillsView(store, repo, actor) {
 }
 /** Current enabled versions, admitted and hash-verified, without any worker-run writes. */
 export function selectProjectSkills(store, repo, actor) {
-    const identity = admit(store, repo, actor);
-    const value = current(store, repo, identity);
+    const { identity, accepted } = admit(store, repo, actor);
+    const value = current(store, repo, accepted);
     const packages = Object.values(value.selection).filter(choice => choice.enabled).map(choice => packageOf(store, choice.sha));
     if (packages.length > SKILL_LIMITS.enabled || Buffer.byteLength(JSON.stringify(packages)) > SKILL_LIMITS.selectionBytes)
         throw Error('Enable up to 8 skills, totaling at most 2 MB.');
@@ -206,10 +209,10 @@ export function selectProjectSkills(store, repo, actor) {
 }
 /** The same verified selection used by Restore, including disabled versions. */
 export function skillsVersion(store, repo, actor, revision) {
-    const identity = admit(store, repo, actor);
+    const { accepted } = admit(store, repo, actor);
     if (!Number.isSafeInteger(revision) || revision < 1)
         throw Error("Choose a saved skills version.");
-    const row = store.handle.prepare("SELECT payload,sha FROM project_skill_change WHERE repo=? AND identity=? AND revision=?").get(repo, identity, revision);
+    const row = store.handle.prepare(`SELECT payload,sha FROM project_skill_change WHERE repo=? AND ${IN_ACCEPTED} AND revision=?`).get(repo, listOf(accepted), revision);
     if (!row)
         throw Error("That skills version is unavailable.");
     const selection = unpack(row["payload"], row["sha"]);
@@ -238,7 +241,7 @@ export function importSkill(store, repo, actor, files, source, now = new Date())
     return { ...skill, sha };
 }
 export function changeSkills(store, args, now = new Date()) {
-    const identity = admit(store, args.repo, args.actor, true);
+    const { identity, accepted } = admit(store, args.repo, args.actor, true);
     if (identity !== args.identity || !Number.isSafeInteger(args.revision))
         throw Error("The project changed. Reload Skills.");
     store.transact(() => {
@@ -248,8 +251,8 @@ export function changeSkills(store, args, now = new Date()) {
         let selection = view.selection;
         if (args.action === "restore") {
             const row = store.handle
-                .prepare("SELECT * FROM project_skill_change WHERE repo=? AND identity=? AND revision=?")
-                .get(args.repo, identity, args.restore ?? -1);
+                .prepare(`SELECT * FROM project_skill_change WHERE repo=? AND ${IN_ACCEPTED} AND revision=?`)
+                .get(args.repo, listOf(accepted), args.restore ?? -1);
             if (!row)
                 throw Error("That version is unavailable.");
             selection = unpack(row["payload"], row["sha"]);
@@ -316,7 +319,7 @@ export function readSkillsSnapshot(store, runId) {
     const saved = unpack(row["payload"], row["sha"]);
     const { packageShas, ...facts } = saved;
     if (packageShas.length &&
-        facts.identity !== learningIdentity(String(row["repo"])))
+        !acceptedIdentities(store, String(row["repo"])).has(facts.identity))
         throw Error("The project identity saved for this run changed.");
     return {
         ...facts,
@@ -370,7 +373,11 @@ export function freezeSkills(store, runId) {
         if (inherited)
             snapshot = { ...inherited, inheritedFrom: parent.id };
         else if (!parent || (run.role !== "reviewer" && test)) {
-            if (test && test["identity"] !== learningIdentity(ref.repo))
+            const saved = store.handle
+                .prepare("SELECT identity FROM project_skill_change WHERE repo=? ORDER BY revision DESC LIMIT 1")
+                .get(ref.repo);
+            const accepted = test || saved ? acceptedIdentities(store, ref.repo) : new Set();
+            if (test && !accepted.has(String(test["identity"])))
                 throw Error("The project for this test changed. Create a new test.");
             if (test)
                 snapshot = {
@@ -380,10 +387,9 @@ export function freezeSkills(store, runId) {
                     inheritedFrom: null,
                     packages: [packageOf(store, String(test["package"]))],
                 };
-            else if (store.handle
-                .prepare("SELECT 1 FROM project_skill_change WHERE repo=?")
-                .get(ref.repo)) {
-                const value = current(store, ref.repo, learningIdentity(ref.repo));
+            // Skills saved under another identity wait for an approver; the run proceeds without them.
+            else if (saved && accepted.has(String(saved["identity"]))) {
+                const value = current(store, ref.repo, accepted);
                 snapshot = {
                     ...snapshot,
                     revision: value.revision,

package/dist/result-follow-ups.d.ts

@@ -8,6 +8,19 @@ export declare const FOLLOW_UP_LOG = "follow-up check log v1";
 export declare const FOLLOW_UP_RECEIPT = "follow-up check receipt v1";
 export declare const ADD_TESTS_ACTION = "tests task filed";
 export type RunLevel = Exclude<CheckLevel, "off">;
+/** How a batch check (batch-checks.ts) reached this result's outcome. `together`: one check on a temporary
+ * merge of `members`; `split`: its batch failed, so it was checked on its own; `conflict`: it couldn't be merged
+ * with the others, so it was checked on its own; `alone`: nothing joined it within the window. */
+export type BatchFacts = {
+    mode: "together" | "split" | "conflict" | "alone";
+    tested: string;
+    base: string | null;
+    members: {
+        task: string;
+        run: number;
+        head: string;
+    }[];
+};
 export type FollowUpCheck = {
     request: number;
     runId: number;
@@ -15,13 +28,19 @@ export type FollowUpCheck = {
     head: string;
     actor: string;
     at: string;
-    why: "person" | "pull-request";
+    why: "person" | "pull-request" | "batch";
     /** The approved command's digest when checks were asked for: only that exact command runs. */
     digest: string;
     state: "waiting" | "running" | "passed" | "failed" | "not-run";
     exitCode: number | null;
     logArtifactId: number | null;
     note: string | null;
+    /** A batch request: the project base it is merged onto. */
+    base?: string | null;
+    /** The commit the check actually ran on: the result's own, or a temporary batch commit. Null until it ran. */
+    tested?: string | null;
+    /** From the sealed receipt of a batch check. */
+    batch?: BatchFacts | null;
 };
 type Refusal = {
     ok: false;
@@ -43,8 +62,9 @@ export declare function requestFollowUpChecks(store: Store, input: {
     level: RunLevel;
     existing: boolean;
 } | Refusal;
-/** Requests nobody has started yet, oldest first. */
+/** Requests nobody has started yet, oldest first. Batch requests wait for the batch pass (batch-checks.ts). */
 export declare function waitingCheckRequests(store: Store, now: Date): FollowUpCheck[];
+export declare function waitingRequestsOfAnyKind(store: Store, now: Date): FollowUpCheck[];
 export type CheckRunDeps = {
     runner?: Runner;
     git?: Runner;

package/dist/result-follow-ups.js

@@ -47,28 +47,34 @@ export function followUpChecksOf(store, runId, now = new Date(), root) {
                 const body = JSON.parse(read.content.toString("utf8"));
                 if (typeof body.request !== "number")
                     continue;
+                const head = typeof body.head === "string" ? body.head : null;
                 receipts.set(body.request, { ran: body.result?.ran === true, exitCode: typeof body.result?.exitCode === "number" ? body.result.exitCode : null,
-                    log: typeof body.log?.artifactId === "number" ? body.log.artifactId : null });
+                    log: typeof body.log?.artifactId === "number" ? body.log.artifactId : null, head,
+                    tested: typeof body.tested === "string" ? body.tested : head, batch: batchFactsOf(body.batch, runId, head) });
             }
             catch { /* an unreadable receipt upgrades nothing */ }
         }
     }
     return rows.filter(row => row.action === CHECKS_REQUESTED && (row.outcome === "quick" || row.outcome === "full")).map(request => {
-        const [head = "", why = "person", digest = ""] = (request.detail ?? "").split(" · ");
+        const [head = "", why = "person", digest = "", recordedBase = ""] = (request.detail ?? "").split(" · ");
         const started = rows.find(row => row.action === CHECKS_STARTED && row.outcome === String(request.id)) ?? null;
         const finished = rows.find(row => row.action === CHECKS_FINISHED && row.outcome.startsWith(`${request.id}:`)) ?? null;
         const base = { request: request.id, runId, level: request.outcome, head, digest, actor: request.actor, at: request.at,
-            why: why === "pull-request" ? "pull-request" : "person", exitCode: null, logArtifactId: null, note: null };
+            why: why === "pull-request" ? "pull-request" : why === "batch" ? "batch" : "person", exitCode: null, logArtifactId: null, note: null,
+            ...(why === "batch" ? { base: /^[a-f0-9]{40}$/.test(recordedBase) ? recordedBase : null } : {}) };
         if (finished !== null) {
             const status = finished.outcome.slice(String(request.id).length + 1);
             const sealed = receipts.get(request.id) ?? null;
-            // With the evidence at hand, only a sealed receipt can say passed.
-            if (status === "passed" && root !== undefined && (sealed === null || !sealed.ran || sealed.exitCode !== 0)) {
+            // With the evidence at hand, only a sealed receipt can say passed: for this result's own commit, and,
+            // for a batch, a batch that names this result.
+            if (status === "passed" && root !== undefined && (sealed === null || !sealed.ran || sealed.exitCode !== 0 || (sealed.head !== null && sealed.head !== head)
+                || (base.why === "batch" && sealed.batch === null))) {
                 return { ...base, state: "not-run", note: "The saved check result could not be verified." };
             }
             const exit = /exit (\d+)/.exec(finished.detail ?? "");
             return { ...base, state: status === "passed" ? "passed" : status === "failed" ? "failed" : "not-run",
-                exitCode: exit === null ? sealed?.exitCode ?? null : Number(exit[1]), logArtifactId: sealed?.log ?? null, note: status === "not-run" ? finished.detail : null };
+                exitCode: exit === null ? sealed?.exitCode ?? null : Number(exit[1]), logArtifactId: sealed?.log ?? null, note: status === "not-run" ? finished.detail : null,
+                ...(sealed === null ? {} : { tested: sealed.ran ? sealed.tested : null, batch: sealed.batch }) };
         }
         if (started !== null) {
             const limit = Number(/limit (\d+)/.exec(started.detail ?? "")?.[1] ?? 3_600_000);
@@ -79,6 +85,26 @@ export function followUpChecksOf(store, runId, now = new Date(), root) {
         return { ...base, state: "waiting" };
     });
 }
+/** A receipt's batch facts, only when they are whole and name this result at its own commit. */
+function batchFactsOf(value, runId, head) {
+    if (value === null || typeof value !== "object")
+        return null;
+    const raw = value;
+    const modes = ["together", "split", "conflict", "alone"];
+    const mode = modes.find(one => one === raw.mode);
+    if (mode === undefined || typeof raw.tested !== "string" || !/^[a-f0-9]{40}$/.test(raw.tested) || !Array.isArray(raw.members))
+        return null;
+    const members = raw.members.flatMap(one => {
+        const m = one;
+        return typeof m?.task === "string" && typeof m.run === "number" && typeof m.head === "string" ? [{ task: m.task, run: m.run, head: m.head }] : [];
+    });
+    if (members.length !== raw.members.length || !members.some(one => one.run === runId && one.head === head))
+        return null;
+    // Checked on its own: the commit tested is the result's own.
+    if (mode !== "together" && (members.length !== 1 || raw.tested !== head))
+        return null;
+    return { mode, tested: raw.tested, base: typeof raw.base === "string" ? raw.base : null, members };
+}
 /** Whether a result can have checks run on it, and with which command. */
 function checkTarget(store, runId, level) {
     const run = store.getRun(runId);
@@ -110,8 +136,11 @@ export function requestFollowUpChecks(store, input, now) {
         return { ok: true, request, level: target.level, existing: false };
     });
 }
-/** Requests nobody has started yet, oldest first. */
+/** Requests nobody has started yet, oldest first. Batch requests wait for the batch pass (batch-checks.ts). */
 export function waitingCheckRequests(store, now) {
+    return waitingRequestsOfAnyKind(store, now).filter(one => one.why !== "batch");
+}
+export function waitingRequestsOfAnyKind(store, now) {
     const runs = store.handle.prepare(`SELECT DISTINCT r.run_id AS run FROM action_ledger r WHERE r.action = ? AND r.run_id IS NOT NULL
     AND NOT EXISTS (SELECT 1 FROM action_ledger s WHERE s.run_id = r.run_id AND s.action = ? AND s.outcome = CAST(r.id AS TEXT)) ORDER BY r.id`)
         .all(CHECKS_REQUESTED, CHECKS_STARTED).map(row => Number(row["run"]));
@@ -204,7 +233,7 @@ export async function runFollowUpCheck(store, root, request, deps = {}) {
     const text = log.length === 0 ? "No command started." : log.join("\n\n");
     const logId = storeEvidence(store, root, runId, "structured-output", `follow-up-check-${request}.log`, Buffer.from(text, "utf8"), FOLLOW_UP_LOG, at, { captureStatus: "ok" });
     const logArtifact = store.getArtifact(logId);
-    const receipt = JSON.stringify({ version: 1, request, run: runId, head: target.head, level: target.level,
+    const receipt = JSON.stringify({ version: 1, request, run: runId, head: target.head, tested: target.head, level: target.level,
         command: { repo: target.command.repo, command: target.command.command, digest: target.command.digest, approvedBy: target.command.approvedBy },
         result, log: { artifactId: logArtifact.id, sha256: logArtifact.sha256, bytesStored: logArtifact.bytesStored, truncated: logArtifact.truncated } }, null, 1);
     storeEvidence(store, root, runId, "structured-output", `follow-up-check-${request}.json`, Buffer.from(receipt, "utf8"), FOLLOW_UP_RECEIPT, at, { captureStatus: "ok" });
@@ -262,9 +291,14 @@ export function fullCheckGate(store, runId, now) {
     const level = runCheckLevel(store, runId);
     const repo = repoOfRun(store, runId);
     const run = store.getRun(runId);
-    if (level === null || level === "full" || repo === null || run === null || store.liveVerifyCommand(repo) === null)
+    if (level === null || repo === null || run === null)
+        return { state: "clear" };
+    const fulls = followUpChecksOf(store, runId, now).filter(one => one.level === "full" && one.head === run.headRevision);
+    // A Full build that waited for a batch check has had no check of its own: Merge waits for the batch, like Quick does.
+    const batched = level === "full" && fulls.some(one => one.why === "batch");
+    if ((level === "full" && !batched) || (!batched && store.liveVerifyCommand(repo) === null))
         return { state: "clear" };
-    const last = followUpChecksOf(store, runId, now).filter(one => one.level === "full" && one.head === run.headRevision).at(-1);
+    const last = fulls.at(-1);
     if (last === undefined)
         return { state: "not-requested", message: "The full check hasn't run on this commit yet. Merge once it passes, or merge anyway." };
     if (last.state === "passed")