toolroll 0.9.92 → 0.9.94

package/dist/chat-decide.js

@@ -13,6 +13,7 @@
  * The same in every chat app: Telegram's bridge and the shared engine Slack, Discord and Teams run on (chat-delivery.ts)
  * offer, mint and answer these through the same tokens (the `channel` column). Every act runs through the door the
  * console uses. */
+import { routeChangeOf } from "./route-change.js";
 import { NIGHTLY_CHECK_ONLY, RELEASE_MERGES_ONLY, nightlyTaskRef, releaseTaskRef } from "./store.js";
 import { isAcpProfile } from "./acp-agents.js";
 import { DECIDE_ACTS, readDecideActionRow } from "./contracts/chat-callback-rows.js";
@@ -41,13 +42,18 @@ import { PLATFORM_LIMITS } from "./text-limits.js";
 export { permissionPlainWords };
 /** The words, said once. */
 export const DECIDE_LABELS = {
-    accept: "Accept and finish",
-    changes: "Request changes",
+    accept: "Accept",
+    changes: "Send back",
     retry: "Retry",
     approve: "Approve & start",
     "not-now": "Not now",
     merge: "Merge",
     look: "Look first",
+    /** A result's one link (docs/plans/plain-toolroll.md P1.5). */
+    open: "Open result",
+    /** A plan card's one button: it shows the full terms, and the Approve sits under them. Never an approval itself. */
+    review: "Review plan",
+    details: "Details",
     edit: "Edit",
     yes: "Yes",
     cancel: "Cancel",
@@ -390,9 +396,11 @@ export function planCardText(store, taskId, scope, root, channel) {
     const goal = scope.goal.split("\n").filter(one => one.trim() !== "").slice(0, 2).map(one => phoneText(one, 160));
     const allowing = [permissionPlainWords(scope.profile), scope.budgetMicrousd === null ? "no attempt limit" : `up to ${money(scope.budgetMicrousd)} per attempt`]
         .filter((one) => one !== null);
+    const changed = routeChangeOf(store, taskId);
     if (channel === "telegram") {
         return [
             `Plan ready: ${title(store, taskId)}`,
+            ...(changed === null ? [] : [changed]),
             `Starting allows: ${allowing.join(" · ")}`,
             "",
             ...goal,
@@ -405,6 +413,7 @@ export function planCardText(store, taskId, scope, root, channel) {
     }
     return [
         `Plan ready: ${title(store, taskId)}`,
+        ...(changed === null ? [] : [changed]),
         "",
         ...goal,
         "",
@@ -433,7 +442,7 @@ export function decideOffer(store, target, who, now, channel, root) {
             const fresh = resultFresh(store, target.taskId, target.run, who, now, root);
             if (!fresh.ok)
                 return null;
-            const look = { label: DECIDE_LABELS.look, path: chatResultHref(target.taskId, target.run, "changes") };
+            const look = { label: DECIDE_LABELS.open, path: chatResultHref(target.taskId, target.run, "changes") };
             // A result accepted only with a reason ("Accept anyway") keeps its link: the reason is typed on the result.
             if (fresh.exception)
                 return null;
@@ -473,15 +482,17 @@ export function decideOffer(store, target, who, now, channel, root) {
                     rows: [[{ act: "approve", run: null, digest: releaseDigest(card), label: "Continue" }], [{ label: DECIDE_LABELS.edit, path: chatControlHref("approval", target.taskId) }, { act: "not-now", run: null, digest: releaseDigest(card) }]],
                     ...(channel === "telegram" ? { file: { name: card.fileName, text: card.full } } : {}) };
             }
-            return { text: planCardText(store, target.taskId, plan.scope, root, channel),
-                rows: [[{ act: "approve", run: null, digest: plan.digest }], [{ label: DECIDE_LABELS.edit, path: chatControlHref("approval", target.taskId) }, { act: "not-now", run: null, digest: plan.digest }]] };
+            // One line, one button and Details (docs/plans/plain-toolroll.md P1.5): Review plan shows the full terms in the
+            // card, and only there does Approve appear, bound to the same digest.
+            return { text: planLineOf(store, target.taskId, ref.id),
+                rows: [[{ act: "approve", run: null, digest: plan.digest, label: DECIDE_LABELS.review }], [{ label: DECIDE_LABELS.details, path: chatControlHref("approval", target.taskId) }]] };
         }
         case "requests": return requestsOffer(store, target.taskId, who, now, channel, root);
         case "merge": {
             const merge = mergeInChat(store, target.taskId, target.run, who.name, now, channel);
             if (!merge.ok)
                 return null;
-            return { text: null, rows: [[{ act: "merge", run: target.run, digest: merge.head }], [{ label: DECIDE_LABELS.look, path: chatResultHref(target.taskId, target.run, "changes") }]] };
+            return { text: null, rows: [[{ act: "merge", run: target.run, digest: merge.head }], [{ label: DECIDE_LABELS.open, path: chatResultHref(target.taskId, target.run, "changes") }]] };
         }
     }
 }
@@ -623,7 +634,7 @@ seat, root) {
     return { ok: true, card, modeDigest: plan.modeDigest, source: plan.source, scope: plan.scope };
 }
 const QUESTIONS = {
-    accept: name => `Accept and finish "${name}"?`,
+    accept: name => `Accept "${name}"?`,
     retry: name => `Retry "${name}"? It queues another attempt.`,
     approve: name => `Approve and start "${name}"?`,
     merge: name => `Merge "${name}"?`,
@@ -712,7 +723,7 @@ function staleWhy(store, row, who, now, channel, root) {
 /** The links a card keeps once its acts are spent or stale: where to look, never a token. */
 export function linksFor(target) {
     switch (target.kind) {
-        case "result": return [[{ label: DECIDE_LABELS.look, link: { label: DECIDE_LABELS.look, path: chatResultHref(target.taskId, target.run, "changes") } }]];
+        case "result": return [[{ label: DECIDE_LABELS.open, link: { label: DECIDE_LABELS.open, path: chatResultHref(target.taskId, target.run, "changes") } }]];
         case "merge": return [[{ label: "Open task", link: { label: "Open task", path: chatControlHref("task", target.taskId) } }]];
         case "plan": return [[{ label: "Review & start", link: { label: "Review & start", path: chatControlHref("approval", target.taskId) } }]];
         case "failed": return [[{ label: "Open task", link: { label: "Open task", path: chatControlHref("task", target.taskId) } }]];
@@ -740,7 +751,7 @@ export function planWhereNow(store, taskId, who, now, root) {
     }
     return { said: `"${name}" is under way.`, rows: [] };
 }
-const QUESTION_STARTS = ["Accept and finish \"", "Retry \"", "Approve and start \"", "Merge \"", "Approve release "];
+const QUESTION_STARTS = ["Accept \"", "Accept and finish \"", "Retry \"", "Approve and start \"", "Merge \"", "Approve release "];
 /** The card's words without a question this module appended. */
 function cardBody(shown) {
     const at = shown.lastIndexOf("\n\n");
@@ -847,6 +858,19 @@ export function applyDecideTap(store, seat, input) {
             return { ack: "Confirm below.", edit: { text: `${body}\n\n${asked}`,
                     rows: [[{ label: DECIDE_LABELS.yes, token: yes }, { label: DECIDE_LABELS.cancel, token: cancel }]], tokens: [yes, cancel] } };
         }
+        // A plan card's Review plan: the full terms in the card, and under them the Approve (the yes, bound to the same
+        // digest the card was minted with, checked again at the tap). Approve is reachable only from here.
+        if (row.act === "approve") {
+            const plan = planInChat(store, row.taskId, who.name, now, seat.channel, input.root);
+            if (!plan.ok)
+                return stale(plan.why);
+            spend();
+            const spec = { act: "approve", run: null, digest: row.digest };
+            const yes = mint(store, seat, input.message, spec, row.taskId, "yes", now);
+            const later = mint(store, seat, input.message, { act: "not-now", run: null, digest: row.digest }, row.taskId, "offer", now);
+            return { ack: "Read the plan, then approve.", edit: { text: `${planCardText(store, row.taskId, plan.scope, input.root, seat.channel)}\n\n${QUESTIONS.approve(name)} This approves exactly this plan.`,
+                    rows: [[{ label: DECIDE_LABELS.approve, token: yes }], [{ label: DECIDE_LABELS.edit, link: { label: DECIDE_LABELS.edit, path: chatControlHref("approval", row.taskId) } }, { label: DECIDE_LABELS["not-now"], token: later }]], tokens: [yes, later] } };
+        }
         // The first tap asks; only the yes acts, bound to exactly what this button was.
         spend();
         const spec = { act: row.act, run: row.run, digest: row.digest };
@@ -1007,3 +1031,7 @@ export function decideTargetOf(row) {
         return { kind: "failed", taskId: row.taskId };
     return null;
 }
+/** A plan card's one line: the task's number, "plan ready", and its title (docs/plans/plain-toolroll.md P1.5). */
+function planLineOf(store, taskId, number) {
+    return `#${number}: plan ready · ${title(store, taskId)}`;
+}

package/dist/chat-quiet.js

@@ -102,7 +102,7 @@ export function quietCardView(store, taskRefs, now, root, viewer) {
     const heading = `${lines.length} tasks`;
     const projects = [...new Set(lines.map(one => projectLabel(one.project)))];
     const text = [heading, ...lines.map(one => `${one.icon} ${phoneText(one.title, 60)} · ${one.status}`), "", projects.join(", ")].join("\n");
-    return { text, entities: [{ type: "bold", offset: 0, length: heading.length }], link: { label: "Open tasks", path: "/work" } };
+    return { text, entities: [{ type: "bold", offset: 0, length: heading.length }], link: { label: "Open tasks", path: "/tasks" } };
 }
 /** Facts that carry their own controls or must stand alone (a security alert, a decision, a flow card, a
  * screenshot, an acceptance packet, a youiyoux pass's card) are never folded into a batch. */
@@ -177,7 +177,7 @@ export function finishedView(store, batch, now, root, viewer) {
         return null;
     const text = batchLine(lines.map(one => one.fact));
     if (lines.length > 1)
-        return { text, entities: [], link: { label: "Open", path: "/work" } };
+        return { text, entities: [], link: { label: "Open", path: "/tasks" } };
     const target = lines[0].target ?? null;
     return { text, entities: [], link: lines[0].link, ...(lines[0].also.length === 0 ? {} : { also: lines[0].also }), ...(target === null ? {} : { target }) };
 }
@@ -244,7 +244,7 @@ export function enqueueEveningDigests(store, now, root) {
             if (body === null)
                 return;
             if (store.enqueueNotification({ dedupeKey: `digest:evening:${person.account}:${day}`, kind: "evening-digest", subject: "Evening digest", body,
-                link: "/work", source: { installation: true }, recipient: person.account }, now))
+                link: "/tasks", source: { installation: true }, recipient: person.account }, now))
                 queued++;
         });
     }

package/dist/chat-voice.d.ts

@@ -39,7 +39,7 @@ export type FinishedFact = {
 /** The two buttons under a result ready for a person: the real next step, then a look first. */
 export declare const READY_ACTIONS: {
     readonly merge: "Merge";
-    readonly complete: "Accept and finish";
+    readonly complete: "Accept";
     readonly look: "Look first";
 };
 /** Whether this line asks for the result's next step, so it carries [Merge] or [Accept and finish] and [Look first]. */

package/dist/chat-voice.js

@@ -48,7 +48,7 @@ export function inSentence(summary) {
     return /^\p{Lu}\p{Ll}/u.test(summary) ? summary[0].toLowerCase() + summary.slice(1) : summary;
 }
 /** The two buttons under a result ready for a person: the real next step, then a look first. */
-export const READY_ACTIONS = { merge: "Merge", complete: "Accept and finish", look: "Look first" };
+export const READY_ACTIONS = { merge: "Merge", complete: "Accept", look: "Look first" };
 /** Whether this line asks for the result's next step, so it carries [Merge] or [Accept and finish] and [Look first]. */
 export function asksToFinish(fact) {
     return fact.update == null && fact.headline === "Ready for review" && !fact.report;
@@ -67,7 +67,7 @@ export function finishedLine(fact) {
             if (fact.report)
                 return fact.lead === true ? `I wrote up ${lower}. The report is ready to read.` : `${name}: the report is ready to read.`;
             if (fact.checks === "passed")
-                return `${ready}. Your tests passed. ${fact.pullRequest === true ? "Merge it?" : "Accept and finish it?"}`;
+                return `${ready}. Your tests passed. ${fact.pullRequest === true ? "Merge it?" : "Accept it?"}`;
             if (fact.checks === "off")
                 return `${ready}. Its checks run at release, so look it over first.`;
             return `${ready}, but no tests ran. Look it over first.`;

package/dist/check-facts.d.ts

@@ -0,0 +1,126 @@
+import { type CheckReport } from "./contracts/release-check.js";
+import { type Store, type VerifyCommand } from "./store.js";
+/** The sources a result can come from, and the states it can have. */
+export declare const CHECK_RESULT_SOURCES: readonly ["receipt", "report", "log", "learn"];
+export type CheckResultSource = typeof CHECK_RESULT_SOURCES[number];
+export type CheckResultState = "failed" | "passed" | "skipped" | "passed-on-retry";
+/** The receipt's whole-check identity, and the one a failed check with nothing else named records. */
+export declare const WHOLE_CHECK = "check";
+export declare const UNEXPLAINED = "unexplained";
+/** How many result rows one check records at most (a report's own bounds are far above any real check). */
+export declare const MAX_RESULTS_PER_CHECK = 20000;
+/** How old a tracked observation may be and still be asked about (docs/plans/learning-loops.md, 90-day window). */
+export declare const OBSERVATION_WATCH_MS: number;
+/** What a check ran under, captured when its command started. `tree` null: its commit couldn't be read from verified
+ * objects, and nothing about the check is comparable. */
+export type CheckConditions = {
+    head: string;
+    tree: string | null;
+    commandDigest: string;
+    access: string;
+    harnessDigest: string | null;
+    lockfile: string | null;
+    conditionsDigest: string | null;
+    conditionsClass: string | null;
+    problem: string | null;
+};
+/**
+ * The conditions a check's command starts under: its commit's verified tree facts, the approved command's digest, its
+ * access, and the values of `envNames` (the variables the check inherits, builder.ts SETUP_ENV_ALLOWLIST) as this
+ * process holds them now — what the command is given. Hashed with checkContextOf's fields; the class reads
+ * `<platform>-<arch>-node<major>`. Values are hashed, never stored.
+ */
+export declare function captureCheckConditions(input: {
+    repo: string | null;
+    head: string;
+    command: VerifyCommand;
+    access: string;
+    envNames: readonly string[];
+    env?: NodeJS.ProcessEnv;
+}): CheckConditions;
+/** Why the task's check ran: a release's or the nightly's purpose, read from the plane's own records. */
+export declare function checkPurposeOf(store: Store, taskRef: number): "release" | "nightly" | "ordinary";
+/** The advisory learning line of a check's output, read strictly: exactly one line carrying this run's nonce, at most
+ * 64 KiB, before the report, matching its contract, naming only requested exact cases, each once. Anything else is
+ * not recorded, with why; that loses learning evidence only. */
+export declare function learningLinesOf(stdout: string, nonce: string, asked: readonly string[]): {
+    ok: true;
+    results: {
+        identity: string;
+        state: "passed" | "failed" | "skipped";
+    }[];
+} | {
+    ok: false;
+    why: string;
+};
+type Row = {
+    identity: string;
+    state: CheckResultState;
+    source: CheckResultSource;
+};
+/** The report's lines as results: every case it names; a file, group, version or part only when it didn't simply pass. */
+export declare function reportResults(report: CheckReport): Row[];
+export type CheckFactsInput = {
+    runId: number;
+    taskRef: number;
+    repo: string | null;
+    /** Captured when the command started; null when no command started (nothing comparable was run). */
+    conditions: CheckConditions | null;
+    /** What the plane recorded as the check's own outcome (run_check), unchanged. */
+    receipt: {
+        status: "passed" | "failed" | "not-run";
+    };
+    /** The sealed report, when the check gave a valid one. */
+    report: CheckReport | null;
+    /** The check's handshake facts, when it had one: its nonce and what it was asked about for learning. */
+    attempt: {
+        nonce: string;
+        learn: readonly string[];
+    } | null;
+    /** The check's final command output, for the learning line (the same bytes the report was read from). */
+    stdout: string | null;
+    now: Date;
+};
+/**
+ * Record what a settled check ran under and reported, once (first write wins), in one transaction: its fact row and
+ * every result row. Called at disposition by the builder right after it records the check's own outcome. Advisory:
+ * nothing reads these for a verdict, a rerun or an approval.
+ */
+export declare function recordCheckFacts(store: Store, root: string, input: CheckFactsInput): void;
+/** The storage sweep's own step: results older than the retention window go; their fact rows stay. */
+export declare function pruneCheckResults(store: Store, now: Date): number;
+/** A check's recorded facts, or null. */
+export type CheckFact = {
+    run: number;
+    repo: string | null;
+    taskRef: number;
+    head: string | null;
+    tree: string | null;
+    commandDigest: string | null;
+    access: string | null;
+    harnessDigest: string | null;
+    lockfile: string | null;
+    conditionsDigest: string | null;
+    conditionsClass: string | null;
+    purpose: "release" | "nightly" | "ordinary";
+    learnState: "recorded" | "not-recorded" | "not-asked";
+    learnWhy: string | null;
+    recordedAt: string;
+};
+export declare function checkFactOf(store: Store, runId: number): CheckFact | null;
+/** A check's recorded results, by source then identity. */
+export declare function checkResultsOf(store: Store, runId: number): {
+    identity: string;
+    state: CheckResultState;
+    source: CheckResultSource;
+}[];
+/**
+ * What a project's Full checks are asked about for learning (`learn`): its tracked identities (learning_watch) — an
+ * accepted note's until it ends, an observation's for 90 days — exact cases only, the most recently tracked first, at
+ * most 200. Those left out are counted (`leftOut`): a coverage gap, said, never hidden.
+ */
+export declare function learnRequestFor(store: Store, repo: string, now: Date, runId?: number): {
+    learn: string[];
+    leftOut: number;
+};
+export {};

package/dist/check-facts.js

@@ -0,0 +1,318 @@
+/**
+ * Check facts (docs/plans/learning-loops.md, "Foundation: check facts"): what each settled check ran under and what it
+ * reported, recorded at disposition, never trusted for authority. The only writer of `check_fact` and `check_result`
+ * (the v149 migration aside); release-auto's learning scan (eval-hooks.ts learningWriteProblem) needs a person for
+ * SQL that writes them from anywhere else. A policy path (release-auto.ts EVAL_POLICY): any change needs a person.
+ *
+ * - Conditions are captured when the check's command starts (captureCheckConditions, called from the builder's
+ *   runVerification), held in memory and passed here: the commit's tree read through verified objects (never the
+ *   checkout), the approved command's digest, the check's access, the harness digest and lockfile, and the values of
+ *   every environment variable the check inherits (the setup allowlist), hashed with checkContextOf's fields as
+ *   `conditions_digest`. Not re-read later.
+ * - Results are tagged by source: `receipt` (the plane's own whole-check result: trusted for "the check passed or
+ *   failed", nothing finer), `report` (the candidate-written report's lines), `log` (Vitest's FAIL lines in the sealed
+ *   log, failures only, file level) and `learn` (the advisory learning line). Every failure is recorded; the check's
+ *   blocking failure is the check's and is never changed here.
+ * - Explicit execution evidence is a `report` or `learn` line naming an identity. No line is no evidence: never
+ *   skipped, removed or passed.
+ * - Fail closed: an unreadable tree, or conditions never captured (the command never started), records the fact row
+ *   with no conditions and no results at all.
+ *
+ * Nothing here changes a check's outcome, a verdict, an approval or a rerun: every reader of a check's outcome reads
+ * the receipt and run_check, which this module never writes.
+ */
+import { createHash } from "node:crypto";
+import { failingTestsOf } from "./gate-failure.js";
+import { checkContextOf, projectGitDir, treeFactsOf } from "./check-report.js";
+import { readVerifiedArtifact } from "./evidence.js";
+import { recordObservations } from "./flaky.js";
+import { considerLessonNote, markTalliesPartial, revisedFailures, tallyCheck } from "./lesson-notes.js";
+import { CHECK_REPORT_PREFIX, isExactCase, learnLineSchema, learnRequest, LEARN_MAX_BYTES, LEARN_PREFIX } from "./contracts/release-check.js";
+import { nightlyTaskRef, releaseTaskRef } from "./store.js";
+/** The sources a result can come from, and the states it can have. */
+export const CHECK_RESULT_SOURCES = Object.freeze(["receipt", "report", "log", "learn"]);
+/** The receipt's whole-check identity, and the one a failed check with nothing else named records. */
+export const WHOLE_CHECK = "check";
+export const UNEXPLAINED = "unexplained";
+/** How many result rows one check records at most (a report's own bounds are far above any real check). */
+export const MAX_RESULTS_PER_CHECK = 20_000;
+/** How old a tracked observation may be and still be asked about (docs/plans/learning-loops.md, 90-day window). */
+export const OBSERVATION_WATCH_MS = 90 * 24 * 60 * 60 * 1000;
+/** How long per-identity results are kept (docs/plans/learning-loops.md, "Per table"). */
+const RESULT_RETAIN_MS = 180 * 24 * 60 * 60 * 1000;
+const sha256 = (value) => createHash("sha256").update(value).digest("hex");
+/**
+ * The conditions a check's command starts under: its commit's verified tree facts, the approved command's digest, its
+ * access, and the values of `envNames` (the variables the check inherits, builder.ts SETUP_ENV_ALLOWLIST) as this
+ * process holds them now — what the command is given. Hashed with checkContextOf's fields; the class reads
+ * `<platform>-<arch>-node<major>`. Values are hashed, never stored.
+ */
+export function captureCheckConditions(input) {
+    const none = (problem) => ({ head: input.head, tree: null, commandDigest: input.command.digest, access: input.access, harnessDigest: null, lockfile: null, conditionsDigest: null, conditionsClass: null, problem });
+    if (input.repo === null)
+        return none("the check's project isn't recorded");
+    const gitDir = projectGitDir(input.repo);
+    if (gitDir === null)
+        return none("the project's Git directory can't be read");
+    let read;
+    // Advisory: whatever happens reading the tree, the check itself is never stopped by it.
+    try {
+        read = treeFactsOf(gitDir, input.head);
+    }
+    catch (error) {
+        return none(`the checked commit can't be read from verified objects (${error instanceof Error ? error.message : String(error)})`);
+    }
+    if (!read.ok)
+        return none(`the checked commit can't be read from verified objects (${read.problem})`);
+    const context = checkContextOf(read.facts, input.command, input.access);
+    const env = input.env ?? process.env;
+    const environment = Object.fromEntries([...new Set(input.envNames)].sort().map(name => [name, env[name] ?? null]));
+    const digest = sha256(JSON.stringify({ version: 1, context, environment }));
+    const major = /^v?(\d+)/.exec(context.node)?.[1] ?? "unknown";
+    return { head: input.head, tree: read.facts.tree, commandDigest: input.command.digest, access: input.access, harnessDigest: read.facts.harnessDigest, lockfile: read.facts.lockfile,
+        conditionsDigest: digest, conditionsClass: `${context.platform}-${context.arch}-node${major}`, problem: null };
+}
+/** Why the task's check ran: a release's or the nightly's purpose, read from the plane's own records. */
+export function checkPurposeOf(store, taskRef) {
+    if (nightlyTaskRef(store, taskRef))
+        return "nightly";
+    if (releaseTaskRef(store, taskRef))
+        return "release";
+    const terms = store.handle.prepare(`SELECT s.release_terms_json, s.release_check_json FROM task_scope s JOIN task_ref r ON r.external_id = s.task_id AND r.backend = 'built-in' WHERE r.id = ?`).get(taskRef);
+    return terms !== undefined && (terms["release_terms_json"] != null || terms["release_check_json"] != null) ? "release" : "ordinary";
+}
+/** The advisory learning line of a check's output, read strictly: exactly one line carrying this run's nonce, at most
+ * 64 KiB, before the report, matching its contract, naming only requested exact cases, each once. Anything else is
+ * not recorded, with why; that loses learning evidence only. */
+export function learningLinesOf(stdout, nonce, asked) {
+    const lines = stdout.split("\n");
+    let reportAt = -1;
+    for (let at = lines.length - 1; at >= 0; at--)
+        if (lines[at].startsWith(CHECK_REPORT_PREFIX)) {
+            reportAt = at;
+            break;
+        }
+    const ours = [];
+    let oversized = false, others = false, unreadable = false;
+    lines.forEach((line, at) => {
+        if (!line.startsWith(LEARN_PREFIX))
+            return;
+        if (Buffer.byteLength(line) > LEARN_MAX_BYTES) {
+            oversized = true;
+            return;
+        }
+        let value;
+        try {
+            value = JSON.parse(line.slice(LEARN_PREFIX.length));
+        }
+        catch {
+            unreadable = true;
+            return;
+        }
+        if (value === null || typeof value !== "object" || value["nonce"] !== nonce) {
+            others = true;
+            return;
+        }
+        ours.push({ at, value });
+    });
+    if (ours.length === 0)
+        return { ok: false, why: oversized ? "the learning line was over 64 KiB" : unreadable ? "the learning line couldn't be read" : others ? "no learning line carried this run's nonce" : "the check printed no learning line" };
+    if (ours.length > 1)
+        return { ok: false, why: "the check printed more than one learning line" };
+    if (oversized)
+        return { ok: false, why: "a learning line was over 64 KiB" };
+    const only = ours[0];
+    if (reportAt >= 0 && only.at > reportAt)
+        return { ok: false, why: "the learning line came after the report" };
+    const read = learnLineSchema.safeParse(only.value);
+    if (!read.success)
+        return { ok: false, why: "the learning line doesn't match its contract" };
+    const wanted = new Set(asked);
+    const seen = new Set();
+    for (const one of read.data.results) {
+        if (!wanted.has(one.identity) || !isExactCase(one.identity))
+            return { ok: false, why: "the learning line named an identity it wasn't asked about" };
+        if (seen.has(one.identity))
+            return { ok: false, why: "the learning line named an identity twice" };
+        seen.add(one.identity);
+    }
+    return { ok: true, results: read.data.results };
+}
+const RANK = { passed: 0, skipped: 1, "passed-on-retry": 2, failed: 3 };
+/** The report's lines as results: every case it names; a file, group, version or part only when it didn't simply pass. */
+export function reportResults(report) {
+    const rows = [];
+    const add = (identity, state) => rows.push({ identity, state, source: "report" });
+    for (const one of report.units?.identities ?? [])
+        add(`unit:${one.file}::${one.name}`, one.state === "passed" && one.flaky ? "passed-on-retry" : one.state);
+    for (const one of report.units?.files ?? []) {
+        if (one.state !== "passed")
+            add(`file:${one.file}`, one.state);
+        else if (one.flaky)
+            add(`file:${one.file}`, "passed-on-retry");
+    }
+    for (const run of report.journeys)
+        for (const group of run.groups) {
+            if (group.state === "failed")
+                add(`group:${run.script}:${run.kind}:${group.group}`, "failed");
+            else if (group.state === "passed" && group.retried)
+                add(`group:${run.script}:${run.kind}:${group.group}`, "passed-on-retry");
+            if (group.state === "not-run")
+                continue;
+            for (const journey of group.journeys)
+                add(`journey:${run.script}:${run.kind}:${group.group}::${journey.name}`, journey.state === "passed" && group.retried ? "passed-on-retry" : journey.state);
+        }
+    for (const one of report.upgrades?.versions ?? [])
+        if (one.state === "failed")
+            add(`upgrade:${one.version}`, "failed");
+    for (const part of report.parts)
+        if (part.selected && part.ran && (part.code !== 0 || part.timedOut))
+            add(`part:${part.part}`, "failed");
+    return rows;
+}
+/** The sealed log's FAIL lines (Vitest), failures only, file level; nothing when the log's own count disagrees. */
+function logResults(store, root, runId) {
+    const logs = store.artifactsFor(runId).filter(one => one.kind === "check-log");
+    if (logs.length !== 1)
+        return [];
+    const read = readVerifiedArtifact(root, logs[0]);
+    if (!read.ok)
+        return [];
+    const failing = failingTestsOf(read.content.toString("utf8")) ?? [];
+    return failing.filter(one => /^(?!\/)(?!.*(?:^|\/)\.\.?(?:\/|$))[^\u0000-\u001f\\]{1,512}$/.test(one.file)).map(one => ({ identity: `file:${one.file}`, state: "failed", source: "log" }));
+}
+/**
+ * Record what a settled check ran under and reported, once (first write wins), in one transaction: its fact row and
+ * every result row. Called at disposition by the builder right after it records the check's own outcome. Advisory:
+ * nothing reads these for a verdict, a rerun or an approval.
+ */
+export function recordCheckFacts(store, root, input) {
+    const conditions = input.conditions;
+    const comparable = conditions !== null && conditions.tree !== null && conditions.conditionsDigest !== null;
+    const asked = input.attempt === null ? [] : learnRequest(input.attempt.learn);
+    let learnState = asked.length === 0 ? "not-asked" : "not-recorded";
+    let learnWhy = null;
+    const rows = [];
+    if (comparable) {
+        if (input.receipt.status !== "not-run")
+            rows.push({ identity: WHOLE_CHECK, state: input.receipt.status, source: "receipt" });
+        if (input.report !== null)
+            rows.push(...reportResults(input.report));
+        rows.push(...logResults(store, root, input.runId));
+    }
+    if (asked.length > 0) {
+        if (!comparable)
+            learnWhy = conditions === null ? "the check's command never started" : conditions.problem ?? "the check's conditions weren't recorded";
+        else if (input.stdout === null || input.attempt === null)
+            learnWhy = "the check's output wasn't kept";
+        else {
+            const learned = learningLinesOf(input.stdout, input.attempt.nonce, asked);
+            if (!learned.ok)
+                learnWhy = learned.why;
+            else {
+                learnState = "recorded";
+                for (const one of learned.results)
+                    rows.push({ identity: one.identity, state: one.state, source: "learn" });
+            }
+        }
+    }
+    if (comparable && input.receipt.status === "failed" && !rows.some(one => one.source !== "receipt" && one.state === "failed"))
+        rows.push({ identity: UNEXPLAINED, state: "failed", source: "receipt" });
+    // One row per (identity, source), its worst state; bounded.
+    const kept = new Map();
+    for (const row of rows) {
+        if (row.identity.length < 1 || row.identity.length > 2600)
+            continue;
+        const key = `${row.source}\u0000${row.identity}`;
+        const before = kept.get(key);
+        if (before === undefined || RANK[row.state] > RANK[before.state])
+            kept.set(key, row);
+    }
+    const at = input.now.toISOString();
+    let recorded = false;
+    try {
+        store.transact(() => {
+            const inserted = store.handle.prepare(`INSERT INTO check_fact (run, repo, task_ref, head, tree, command_digest, access, harness_digest, lockfile, conditions_digest,
+        conditions_class, purpose, learn_state, learn_why, recorded_at) SELECT id, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? FROM run WHERE id = ?
+      ON CONFLICT (run) DO NOTHING`).run(input.repo, input.taskRef, conditions?.head ?? null, comparable ? conditions.tree : null, conditions?.commandDigest ?? null, conditions?.access ?? null, comparable ? conditions.harnessDigest : null, comparable ? conditions.lockfile : null, comparable ? conditions.conditionsDigest : null, comparable ? conditions.conditionsClass : null, checkPurposeOf(store, input.taskRef), learnState, learnState === "not-recorded" ? learnWhy ?? "not recorded" : null, at, input.runId);
+            if (Number(inserted.changes) !== 1)
+                return;
+            const insert = store.handle.prepare("INSERT INTO check_result (run, identity, state, source, recorded_at) VALUES (?, ?, ?, ?, ?)");
+            for (const row of [...kept.values()].slice(0, MAX_RESULTS_PER_CHECK))
+                insert.run(input.runId, row.identity, row.state, row.source, at);
+            // In the same transaction: what this check adds to the flaky-test list and to accepted notes' tallies, advisory like
+            // everything here.
+            const observations = recordObservations(store, input.runId, input.now);
+            if (input.repo !== null)
+                tallyCheck(store, input.runId, input.repo, observations, input.now);
+            recorded = true;
+        });
+    }
+    catch (error) {
+        // Not every check was counted this month: its tallies say so.
+        if (input.repo !== null) {
+            try {
+                markTalliesPartial(store, input.repo, input.now);
+            }
+            catch { /* the note reads as it was */ }
+        }
+        throw error;
+    }
+    // A person's lesson note, when this check is what passed a revision. Advisory: nothing here reaches the check.
+    if (recorded) {
+        try {
+            considerLessonNote(store, root, input.runId, input.now);
+        }
+        catch { /* no note */ }
+    }
+}
+/** The storage sweep's own step: results older than the retention window go; their fact rows stay. */
+export function pruneCheckResults(store, now) {
+    const cut = new Date(now.getTime() - RESULT_RETAIN_MS).toISOString();
+    return Number(store.handle.prepare("DELETE FROM check_result WHERE recorded_at < ?").run(cut).changes);
+}
+export function checkFactOf(store, runId) {
+    const row = store.handle.prepare("SELECT * FROM check_fact WHERE run = ?").get(runId);
+    if (row === undefined)
+        return null;
+    const text = (key) => row[key] === null ? null : String(row[key]);
+    return { run: Number(row["run"]), repo: text("repo"), taskRef: Number(row["task_ref"]), head: text("head"), tree: text("tree"), commandDigest: text("command_digest"), access: text("access"),
+        harnessDigest: text("harness_digest"), lockfile: text("lockfile"), conditionsDigest: text("conditions_digest"), conditionsClass: text("conditions_class"),
+        purpose: String(row["purpose"]), learnState: String(row["learn_state"]), learnWhy: text("learn_why"), recordedAt: String(row["recorded_at"]) };
+}
+/** A check's recorded results, by source then identity. */
+export function checkResultsOf(store, runId) {
+    return store.handle.prepare("SELECT identity, state, source FROM check_result WHERE run = ? ORDER BY source, identity").all(runId)
+        .map(row => ({ identity: String(row["identity"]), state: String(row["state"]), source: String(row["source"]) }));
+}
+/**
+ * What a project's Full checks are asked about for learning (`learn`): its tracked identities (learning_watch) — an
+ * accepted note's until it ends, an observation's for 90 days — exact cases only, the most recently tracked first, at
+ * most 200. Those left out are counted (`leftOut`): a coverage gap, said, never hidden.
+ */
+export function learnRequestFor(store, repo, now, runId) {
+    const since = new Date(now.getTime() - OBSERVATION_WATCH_MS).toISOString();
+    let tracked;
+    // Advisory: a read that fails asks about nothing, and the check runs as it would have.
+    try {
+        tracked = store.handle.prepare(`SELECT identity, MAX(since) AS latest FROM learning_watch
+      WHERE repo = ? AND ((reason = 'note' AND until IS NULL) OR (reason = 'observation' AND since >= ?))
+      GROUP BY identity ORDER BY latest DESC, identity`).all(repo, since).map(row => String(row["identity"])).filter(isExactCase);
+    }
+    catch {
+        return { learn: [], leftOut: 0 };
+    }
+    // First, the failed cases of the check this run revises (lesson-notes.ts rule 4).
+    let revised = [];
+    if (runId !== undefined) {
+        try {
+            revised = revisedFailures(store, runId);
+        }
+        catch {
+            revised = [];
+        }
+    }
+    const all = [...new Set([...revised, ...tracked])];
+    const learn = learnRequest(all);
+    return { learn, leftOut: all.length - learn.length };
+}