toolroll 0.9.91 → 0.9.93

package/dist/browser-crew.js

@@ -15,8 +15,8 @@ export function browserWorkActionHref(item) {
         return '/settings/agents#providers';
     if (action.code === 'answer-agent' && runId !== null)
         return `/agents?run=${runId}`;
-    if (action.code === 'confirm-stopped')
-        return `/t/${encodeURIComponent(item.rootId)}#confirm-stopped`;
+    if (action.code === 'recheck-stopped')
+        return `/t/${encodeURIComponent(item.rootId)}#recheck-stopped`;
     if (action.code === 'open-result' && runId !== null)
         return chatResultHref(taskId, runId);
     if (action.code === 'open-pr' && /^https:\/\/github\.com\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+\/pull\/\d+$/.test(item.publicationUrl ?? ''))

package/dist/browser-workspace.d.ts

@@ -381,11 +381,10 @@ export type BrowserTaskView = {
     statusHtml: string;
     /** The approval ceremony or its updated terms, exactly as signed. */
     approval: string;
-    /** Confirm it stopped, behind the password, when the status asks for it. */
-    confirmStopped?: {
+    /** Check again (a build Toolroll could not prove stopped from this computer), when the status asks for it. */
+    recheckStopped?: {
         action: string;
         run: number;
-        checked?: boolean;
     } | null;
     /** Build again, in place, when the status asks for it (a result built to an earlier plan). */
     rebuild?: {
@@ -703,7 +702,7 @@ export type BrowserResultDecision = {
         why: string | null;
     };
 };
-/** A Needs you action: a link, (Confirm it stopped) a form behind the password, (Build again) one
+/** A Needs you action: a link, (Check again, Build again) one
  * button, or (on the result itself) Accept, which records the person's acceptance; `note` asks why
  * when the evidence disagrees. */
 export type BrowserNeedAction = {
@@ -713,7 +712,6 @@ export type BrowserNeedAction = {
         action: string;
         run: number;
         returnTo: string;
-        checked?: boolean;
     } | null;
     accept?: {
         action: string;

package/dist/build-review.js

@@ -126,6 +126,8 @@ function sendBack(store, root, runId, taskId, repo, high, now) {
         run: runId, source: revisionSourceOf(store.getScope(taskId)?.digest ?? null), actor, repos: [repo], batch: "",
         note: revisionNoteOf(high), path: "", line: "",
         request: createHash("sha256").update(`build-review:${runId}`).digest("hex").slice(0, 32), allowMode: true,
+        // The automatic review's send-back, even when the mode's signer is its actor: never a person's act.
+        origin: "automatic-review",
     }, now);
     return revised.ok ? { ok: true, id: revised.id } : { ok: false, problem: revised.message };
 }

package/dist/builder.js

@@ -5,6 +5,7 @@ import { checkoutGit } from "./teardown-git.js";
 import { isAcpProvider } from "./acp-agents.js";
 import { OBSERVATION_MAILBOX, observationBrief, parseObservationCases, collectObservations } from "./observations.js";
 import { checkCommandFor, effectiveCheckLevel, recordRunCheckLevel } from "./check-levels.js";
+import { captureCheckConditions, learnRequestFor, recordCheckFacts } from "./check-facts.js";
 import { queueBatchCheck } from "./batch-checks.js";
 import { batchesFullCheck } from "./batch-policy.js";
 import { skillsContext } from "./project-skills.js";
@@ -2324,9 +2325,12 @@ async function settleProof(captured, statArtifactId, sealedHead) {
     let checkAttempt = null;
     let releaseFacts = null;
     const verification = { last: null };
+    // What the check ran under, captured as its command starts (check-facts.ts): advisory, recorded at disposition.
+    const checkConditions = { last: null };
     const checkLog = [];
     const checkOutcomes = [];
     const checkSuites = [];
+    let settledReport = null;
     const noteCheckSuite = (name, result) => {
         checkSuites.push({
             name,
@@ -2382,7 +2386,9 @@ async function settleProof(captured, statArtifactId, sealedHead) {
             const release = decision.authority !== null || releaseCheckScope(store.getScope(request.taskId));
             try {
                 checkAttempt = prepareCheckAttempt(store, root, { runId, repo, head: sealedHead, command: configured, access, authority: decision.authority,
-                    ...(decision.mode === "targeted" ? { plan: decision.plan, snapshot: decision.snapshot } : {}), watch: decision.watch, release }, now());
+                    ...(decision.mode === "targeted" ? { plan: decision.plan, snapshot: decision.snapshot } : {}), watch: decision.watch, release,
+                    // Advisory only (docs/plans/learning-loops.md): the project's tracked identities, a separate handshake field.
+                    learn: learnRequestFor(store, repo, now()).learn }, now());
             }
             catch (error) {
                 // A recorded last release that can't be verified (eval-harness review 2, finding 4): nothing runs.
@@ -2404,6 +2410,9 @@ async function settleProof(captured, statArtifactId, sealedHead) {
         const checkProgress = new CheckProgressTracker(snapshot => progressWrites.push(snapshot));
         const runVerification = async (label, missing = null) => {
             const streamed = { stdout: false, stderr: false };
+            // The conditions it starts under (verified tree, command, access, inherited environment): advisory, never authority.
+            if (missing === null)
+                checkConditions.last = captureCheckConditions({ repo, head: sealedHead, command: configured, access: checkLaunchOf(store, runId, captured.effective.profile).access, envNames: SETUP_ENV_ALLOWLIST });
             // The check runs under the stop watch (v52), owned by this run.
             const result = missing !== null
                 ? { code: 127, stdout: "", stderr: `Toolroll did not start the check: ${missing} wasn't found.`, timedOut: false, notFound: false }
@@ -2624,7 +2633,7 @@ async function settleProof(captured, statArtifactId, sealedHead) {
         const last = verification.last;
         let sealedReport = null;
         if (checkAttempt !== null && last !== null && !last.notFound) {
-            sealedReport = sealCheckOutcome(store, root, checkAttempt, { stdout: last.stdout, exitCode: last.timedOut ? null : last.code }, now());
+            sealedReport = settledReport = sealCheckOutcome(store, root, checkAttempt, { stdout: last.stdout, exitCode: last.timedOut ? null : last.code }, now());
             // Where the check's time went (latency-timeline.ts): each part's start and end, display only.
             keepCheckTimeline(store, { runId, taskId: request.taskId, report: sealedReport, stdout: last.stdout, now: now() });
         }
@@ -2683,6 +2692,16 @@ async function settleProof(captured, statArtifactId, sealedHead) {
         exitCode: checkExitCode,
         suites,
     }, now());
+    // What the check ran under and reported, every failure in it, each tagged by source (check-facts.ts): advisory, never
+    // read for this outcome, a verdict or an approval.
+    // A failure to record them is said on the run and never reaches the check's outcome.
+    try {
+        recordCheckFacts(store, root, { runId, taskRef: captured.taskRef, repo, conditions: checkConditions.last, receipt: { status: checkStatus }, report: settledReport,
+            attempt: checkAttempt === null ? null : { nonce: checkAttempt.nonce, learn: checkAttempt.learn }, stdout: verification.last?.stdout ?? null, now: now() });
+    }
+    catch (error) {
+        store.addRunNote(runId, "Toolroll", `This check's facts for the flaky-test list weren't recorded (${redactSecretText(error instanceof Error ? error.message : String(error))}); its result is unchanged.`, now());
+    }
     // 4. The sealed diff-stat was restated above, before the correction; it
     // is re-read now, after the gate, and the cached facts are adjudicated
     // only when the artifact still states exactly them. The gate receipt

package/dist/chat-actions.d.ts

@@ -1,5 +1,3 @@
-/** Shared, exact-state actions. Models may prepare; only the existing human
- * confirmation door executes. Protected actions use a one-use review receipt. */
 import { type Authority } from "./local-owner.js";
 import { type Store } from "./store.js";
 import { type VerifiedApprover } from "./principal.js";
@@ -231,6 +229,16 @@ export declare const CHAT_ACTIONS: {
         readonly protected: false;
         readonly password: false;
     };
+    readonly suggestion_not_now: {
+        readonly label: "Not now";
+        readonly protected: false;
+        readonly password: false;
+    };
+    readonly trial_stop: {
+        readonly label: "Stop trial";
+        readonly protected: false;
+        readonly password: false;
+    };
     readonly lead_about_you: {
         readonly label: "Remember";
         readonly protected: false;
@@ -279,7 +287,7 @@ export declare function sharedActionReviewPath(id: number): string;
 export declare function mintSharedActionReview(store: Store, who: VerifiedApprover, id: number, root: string, now: Date): {
     payload: {
         version: 1;
-        operation: "decision_record" | "decision_retire" | "flow_browser" | "flow_browser_off" | "flow_card_add" | "flow_card_approve" | "flow_card_assign" | "flow_card_cancel" | "flow_card_choose" | "flow_card_comment" | "flow_card_move" | "flow_card_send_back" | "flow_card_watch" | "flow_create" | "flow_edit" | "flow_script_save" | "flow_starter" | "flow_trigger_add" | "flow_trigger_pause" | "flow_trigger_remove" | "flow_trigger_resume" | "kit_setup" | "knowledge_instructions" | "knowledge_remove" | "knowledge_restore" | "knowledge_save" | "lead_about_you" | "result_accept" | "scope_approve" | "skill_disable" | "skill_enable" | "skill_import" | "skill_restore" | "skill_test" | "subagent_answer" | "subagent_ask" | "subagent_create" | "subagent_memory" | "subagent_note" | "subagent_routine" | "subagent_soul" | "subagent_state" | "subagent_tools" | "subagent_undo" | "sweep_cancel_rest" | "sweep_file" | "task_cancel" | "task_resume" | "tool_add" | "tool_remove";
+        operation: "decision_record" | "decision_retire" | "flow_browser" | "flow_browser_off" | "flow_card_add" | "flow_card_approve" | "flow_card_assign" | "flow_card_cancel" | "flow_card_choose" | "flow_card_comment" | "flow_card_move" | "flow_card_send_back" | "flow_card_watch" | "flow_create" | "flow_edit" | "flow_script_save" | "flow_starter" | "flow_trigger_add" | "flow_trigger_pause" | "flow_trigger_remove" | "flow_trigger_resume" | "kit_setup" | "knowledge_instructions" | "knowledge_remove" | "knowledge_restore" | "knowledge_save" | "lead_about_you" | "result_accept" | "scope_approve" | "skill_disable" | "skill_enable" | "skill_import" | "skill_restore" | "skill_test" | "subagent_answer" | "subagent_ask" | "subagent_create" | "subagent_memory" | "subagent_note" | "subagent_routine" | "subagent_soul" | "subagent_state" | "subagent_tools" | "subagent_undo" | "suggestion_not_now" | "sweep_cancel_rest" | "sweep_file" | "task_cancel" | "task_resume" | "tool_add" | "tool_remove" | "trial_stop";
         request: {
             [x: string]: unknown;
         };

package/dist/chat-actions.js

@@ -1,5 +1,6 @@
 /** Shared, exact-state actions. Models may prepare; only the existing human
  * confirmation door executes. Protected actions use a one-use review receipt. */
+import { dismissSuggestion, ruleById, stopTrial, suggestionsFor, suggestionWords, taskEvidenceWords, trialWords } from "./route-rules.js";
 import { CHAT_ACTION_LOCAL_ACTS, currentLocalOwner } from "./local-owner.js";
 import { fileTaskProposal } from "./proposal.js";
 import { heuristicSizing } from "./task-sizing.js";
@@ -128,6 +129,10 @@ export const CHAT_ACTIONS = {
     kit_setup: { label: "Set up kit", protected: false, password: false },
     decision_record: { label: "Record decision", protected: false, password: false },
     decision_retire: { label: "Retire decision", protected: false, password: false },
+    // Not now only takes a suggestion off the list for 30 days: nothing about which models run changes.
+    suggestion_not_now: { label: "Not now", protected: false, password: false },
+    // Stopping a trial only lowers: new tasks build on the configured model; approved ones keep theirs.
+    trial_stop: { label: "Stop trial", protected: false, password: false },
     // What the owner's own lead knows about them: theirs alone, in no project (lead-about.ts).
     lead_about_you: { label: "Remember", protected: false, password: false },
     scope_approve: { label: "Approve work", protected: true, password: true },
@@ -279,7 +284,7 @@ export function prepareSharedAction(store, who, operation, input, root, now = ne
         const stamp = hash({ operation, request, repo: "", state, terms, actor: who.name, generation: who.generation, ceiling: who.ceilingDigest });
         return { version: SHARED_ACTION_VERSION, operation, request, repo: "", title, terms, stamp, state };
     }
-    const task = operation.startsWith("skill_") || operation.startsWith("knowledge_") || operation.startsWith("decision_") || operation.startsWith("tool_") || operation.startsWith("flow_") || operation.startsWith("subagent_") || operation.startsWith("kit_") || operation.startsWith("sweep_")
+    const task = operation.startsWith("skill_") || operation.startsWith("knowledge_") || operation.startsWith("decision_") || operation.startsWith("tool_") || operation.startsWith("flow_") || operation.startsWith("subagent_") || operation.startsWith("kit_") || operation.startsWith("sweep_") || operation.startsWith("suggestion_") || operation.startsWith("trial_")
         ? null
         : text(input, "task", 64);
     const flowTarget = operation.startsWith("flow_") && operation !== "flow_create" && operation !== "flow_script_save" && operation !== "flow_starter" ? flowTargetOf(store, input) : null;
@@ -866,6 +871,26 @@ export function prepareSharedAction(store, who, operation, input, root, now = ne
             }
         }
     }
+    else if (operation === "suggestion_not_now") {
+        // Only a suggestion on offer now, by its exact id (which binds its evidence, prices and Models generations).
+        const asked = text(input, "suggestion", 200);
+        const offer = suggestionsFor(store, repo, now).find(one => one.id === asked);
+        if (offer === undefined)
+            throw Error("That suggestion isn't on offer any more. See Settings → Models.");
+        state = { suggestion: offer.id };
+        title = `Not now: ${offer.name} for ${offer.cohortSize === "small" ? "small" : "routine"} tasks`;
+        terms.push(suggestionWords(offer), "Keeps this suggestion quiet for 30 days. Nothing about which models run changes. To accept it instead, review it in Settings → Models.");
+    }
+    else if (operation === "trial_stop") {
+        // Only a live trial of this project, by its number; the card is stale once the trial moves.
+        const asked = integer(input, "trial");
+        const trial = Number.isSafeInteger(asked) ? ruleById(store, asked) : null;
+        if (trial === null || trial.kind !== "trial" || trial.repo !== repo || (trial.state !== "trialling" && trial.state !== "paused"))
+            throw Error("That trial isn't running any more. See Settings → Models.");
+        state = { trial: trial.id, generation: trial.generation };
+        title = "Stop trying a cheaper model";
+        terms.push(trialWords(store, trial), "New tasks build on the configured model again. Tasks a person already approved on the trial keep that model.");
+    }
     else if (operation.startsWith("decision_")) {
         // The staleness fence: the newest decision id and the active count, so a
         // card drafted before a subagent recorded or retired one is refused.
@@ -947,10 +972,11 @@ export function prepareSharedAction(store, who, operation, input, root, now = ne
             if (!authority.ok)
                 throw Error(authority.problem);
             state["authMode"] = authority.authMode;
-            terms.push(...describeScope(scope)
+            terms.push(...describeScope(scope, undefined, taskEvidenceWords(store, scope.taskId, now))
                 .filter((line) => !/^\s*(reference|approved)\s/.test(line))
                 .map((line) => line
                 .trimStart()
+                .replace(/^why model\s+/, "Why this model: ")
                 .replace(/^goal\s+/, "Work: ")
                 .replace(/^not this\s+/, "Excluded: ")
                 .replace(/^touches\s+/, "Allowed files: ")), `Agent permissions and limits\n${runtimeTerms(authority.profile)}\n${authority.authMode === "api-key" ? "Uses your API key; spend is charged to that account." : authority.authMode === "subscription" ? "Uses your subscription login." : ""}`);
@@ -1246,6 +1272,25 @@ export function executeSharedAction(store, who, id, payload, now, options) {
                 if (!removeToolFrom(store, repo, String(req["name"]), actor, now))
                     throw Error("That tool was already removed.");
             }
+            else if (payload.operation === "trial_stop") {
+                const door = currentLocalOwner() !== null ? { kind: "local-owner", actor } : { kind: "person", person: { actor: who.name, generation: who.generation, method: "session", live: () => true } };
+                const trial = ruleById(store, Number(payload.state["trial"]));
+                if (trial === null || trial.generation !== Number(payload.state["generation"]))
+                    throw Error("That trial changed since this card was made. See Settings → Models.");
+                const done = stopTrial(store, trial.id, door, now);
+                if (!done.ok)
+                    throw Error(done.problem);
+                return { ok: true, taskId: null, said: "Trial stopped. New tasks build on the configured model.", href: `/settings/models?scope=${encodeURIComponent(repo)}#models-suggested` };
+            }
+            else if (payload.operation === "suggestion_not_now") {
+                // The rule door (route-store.ts proveRuleDoor) re-proves who says it: this computer's local owner only inside
+                // its `dismiss-suggestion` act, or the confirming person.
+                const door = currentLocalOwner() !== null ? { kind: "local-owner", actor } : { kind: "person", person: { actor: who.name, generation: who.generation, method: "session", live: () => true } };
+                const done = dismissSuggestion(store, { repo, id: String(payload.state["suggestion"]) }, door, now);
+                if (!done.ok)
+                    throw Error(done.problem);
+                return { ok: true, taskId: null, said: "Not now: this suggestion stays quiet for 30 days.", href: `/settings/models?scope=${encodeURIComponent(repo)}#models-suggested` };
+            }
             else if (payload.operation === "decision_record")
                 recordDecision(store, { repo, actor, draft: { claim: String(req["claim"]), why: String(req["why"]), sourceKind: "conversation",
                         ...(req["source"] === undefined ? {} : { sourceRef: String(req["source"]) }), ...(payload.state["supersedes"] === undefined ? {} : { supersedes: Number(payload.state["supersedes"]) }) } }, now);

package/dist/chat-decide.js

@@ -972,6 +972,8 @@ export function applyDecideFeedback(store, seat, prompt, text, repos, root, now)
     const revised = requestResultChanges(store, root, {
         run: prompt.run, batch: "", source: prompt.digest, actor: verified.who.name, repos: verified.who.repos,
         note: text, path: "", line: "", request: sha(`chat-decide:${seat.channel}:${prompt.id}`).slice(0, 32), allowMode: true,
+        // The chat's own verified person, answering "What should change?" in their own words.
+        origin: "person",
     }, now);
     if (!revised.ok)
         return { said: `Your feedback wasn't sent: ${revised.message}`, link: null };

package/dist/chat-review.d.ts

@@ -1,3 +1,4 @@
+import type { RevisionOrigin } from "./contracts/route-results.js";
 import type { Store } from "./store.js";
 import type { VerifiedApprover } from "./principal.js";
 import { type FeedbackImage } from "./result-review.js";
@@ -41,7 +42,7 @@ export declare function reviewInputProblem(note: string | null, path: string | n
 /** Chat and the result form write the same comments and call the same revision service.
  * A failed combined note+revision rolls back the note too; no half-completed action.
  */
-export declare function applyChatReview(store: Store, who: VerifiedApprover, evidenceRoot: string, request: ReviewRequest, now: Date, allowMode: boolean): {
+export declare function applyChatReview(store: Store, who: VerifiedApprover, evidenceRoot: string, request: ReviewRequest, now: Date, allowMode: boolean, origin: RevisionOrigin): {
     ok: true;
     taskId: string;
     run: number;

package/dist/chat-review.js

@@ -48,7 +48,7 @@ export function reviewInputProblem(note, path, line) {
 /** Chat and the result form write the same comments and call the same revision service.
  * A failed combined note+revision rolls back the note too; no half-completed action.
  */
-export function applyChatReview(store, who, evidenceRoot, request, now, allowMode) {
+export function applyChatReview(store, who, evidenceRoot, request, now, allowMode, origin) {
     try {
         return store.transact(() => store.savepoint(() => {
             const fail = (message) => { throw new ReviewRefusal(message); };
@@ -86,7 +86,7 @@ export function applyChatReview(store, who, evidenceRoot, request, now, allowMod
             if (batch.length === 0)
                 return fail("Add feedback or select saved notes before requesting changes.");
             const result = createResultRevision(store, evidenceRoot, {
-                run: live.run, batch: batch.join(","), source: live.source, actor: who.name, repos: who.repos, allowMode,
+                run: live.run, batch: batch.join(","), source: live.source, actor: who.name, repos: who.repos, allowMode, origin,
             }, now);
             if (!result.ok)
                 return fail(result.message);

package/dist/check-facts.d.ts

@@ -0,0 +1,124 @@
+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;
+/** 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): {
+    learn: string[];
+    leftOut: number;
+};
+export {};