toolroll 0.9.5 → 0.9.7

package/dist/project-concurrency.d.ts

@@ -0,0 +1,62 @@
+export declare const PROJECT_CONCURRENCY_DEFAULT = 2;
+export declare const projectConcurrencyPath: (databaseFile: string) => string;
+/** A number as typed: a whole number from 1 to RUNNER_CAPACITY_MAX, or null. */
+export declare function parseProjectConcurrency(value: string): number | null;
+/** Every saved number, by canonical project path. An unreadable file reads as none saved. */
+export declare function savedProjectConcurrency(databaseFile: string): Map<string, number>;
+/** The project's own number: saved, or the default. */
+export declare function projectConcurrency(databaseFile: string, repo: string): number;
+/** Save one project's number atomically; returns the number before and after. */
+export declare function saveProjectConcurrency(databaseFile: string, repo: string, n: number): {
+    before: number;
+    after: number;
+};
+/** What a project actually gets on one worker: its number, never above the worker's capacity. */
+export declare function effectiveConcurrency(setting: number, capacity: number): number;
+/**
+ * The in-process record of when each project's builder last finished a
+ * pass, shared by every project loop of one service. A project that yields
+ * a free slot to another waits only until that project has had a pass to
+ * take it: a waiting project that cannot use the slot (a missing tool, a
+ * paused provider) never holds a busy one back for long.
+ */
+export declare class ProjectPasses {
+    private readonly finished;
+    private tick;
+    /** A monotonic stamp, so ordering never depends on the wall clock. */
+    stamp(): number;
+    passed(repo: string): void;
+    lastPass(repo: string): number;
+}
+export type SlotFacts = {
+    repo: string;
+    /** This worker's capacity. */
+    capacity: number;
+    /** Builds this worker holds now, by project (the asking lane holds none). */
+    running: ReadonlyMap<string, number>;
+    /** Each project's own number. */
+    limitOf: (repo: string) => number;
+    /** Projects with work this worker could start now. */
+    waiting: ReadonlySet<string>;
+    /** Since when this lane has been yielding, or null. */
+    yieldingSince: number | null;
+    passes: ProjectPasses;
+};
+export type SlotAnswer = {
+    take: true;
+} | {
+    take: false;
+    why: "limit" | "capacity" | "fair-share";
+    to?: string;
+};
+/**
+ * May a build lane of `repo` start one more task now?
+ *
+ * - never past the project's own number (capped by the worker's capacity);
+ * - never past the worker's capacity;
+ * - fair share: a project already building yields a free slot to any other
+ *   project with ready work that is building fewer, until that project has
+ *   had a pass to take it. A project building nothing never yields, so every
+ *   project with work gets its first build ahead of another's second.
+ */
+export declare function maySlotTake(facts: SlotFacts): SlotAnswer;

package/dist/project-concurrency.js

@@ -0,0 +1,116 @@
+/**
+ * How many tasks of one project the service builds at once, and which
+ * project gets a free slot when several are waiting.
+ *
+ * The number is a per-project setting an approver changes (Settings →
+ * Projects, or `toolroll project concurrency <n> --repo <p>`), kept in a
+ * small file beside the database and recorded in the ledger as before →
+ * after. A project without a saved number builds up to two at once. The
+ * worker's own capacity always caps the total: a project's number above
+ * it means "as many as the worker has".
+ */
+import { lstatSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { dirname, join } from "node:path";
+import { RUNNER_CAPACITY_MAX } from "./runner.js";
+export const PROJECT_CONCURRENCY_DEFAULT = 2;
+export const projectConcurrencyPath = (databaseFile) => join(dirname(databaseFile), "project-concurrency.json");
+/** A number as typed: a whole number from 1 to RUNNER_CAPACITY_MAX, or null. */
+export function parseProjectConcurrency(value) {
+    const n = Number(value.trim());
+    return value.trim() !== "" && Number.isInteger(n) && n >= 1 && n <= RUNNER_CAPACITY_MAX ? n : null;
+}
+/** Every saved number, by canonical project path. An unreadable file reads as none saved. */
+export function savedProjectConcurrency(databaseFile) {
+    const saved = new Map();
+    const file = projectConcurrencyPath(databaseFile);
+    try {
+        const stat = lstatSync(file, { throwIfNoEntry: false });
+        if (stat === undefined || !stat.isFile() || stat.size > 262_144)
+            return saved;
+        const value = JSON.parse(readFileSync(file, "utf8"));
+        const projects = value !== null && typeof value === "object" ? value.projects : undefined;
+        if (projects === null || typeof projects !== "object")
+            return saved;
+        for (const [repo, n] of Object.entries(projects)) {
+            if (typeof n === "number" && Number.isInteger(n) && n >= 1 && n <= RUNNER_CAPACITY_MAX)
+                saved.set(repo, n);
+        }
+    }
+    catch {
+        // A damaged file never stops building: every project falls back to the default.
+    }
+    return saved;
+}
+/** The project's own number: saved, or the default. */
+export function projectConcurrency(databaseFile, repo) {
+    return savedProjectConcurrency(databaseFile).get(repo) ?? PROJECT_CONCURRENCY_DEFAULT;
+}
+/** Save one project's number atomically; returns the number before and after. */
+export function saveProjectConcurrency(databaseFile, repo, n) {
+    const saved = savedProjectConcurrency(databaseFile);
+    const before = saved.get(repo) ?? PROJECT_CONCURRENCY_DEFAULT;
+    saved.set(repo, n);
+    const file = projectConcurrencyPath(databaseFile);
+    const temp = `${file}.${randomBytes(6).toString("hex")}.tmp`;
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(temp, `${JSON.stringify({ version: 1, projects: Object.fromEntries([...saved].sort(([a], [b]) => a.localeCompare(b))) }, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+    renameSync(temp, file);
+    return { before, after: n };
+}
+/** What a project actually gets on one worker: its number, never above the worker's capacity. */
+export function effectiveConcurrency(setting, capacity) {
+    return Math.max(1, Math.min(setting, capacity));
+}
+/**
+ * The in-process record of when each project's builder last finished a
+ * pass, shared by every project loop of one service. A project that yields
+ * a free slot to another waits only until that project has had a pass to
+ * take it: a waiting project that cannot use the slot (a missing tool, a
+ * paused provider) never holds a busy one back for long.
+ */
+export class ProjectPasses {
+    finished = new Map();
+    tick = 0;
+    /** A monotonic stamp, so ordering never depends on the wall clock. */
+    stamp() {
+        return ++this.tick;
+    }
+    passed(repo) {
+        this.finished.set(repo, this.stamp());
+    }
+    lastPass(repo) {
+        return this.finished.get(repo) ?? 0;
+    }
+}
+/**
+ * May a build lane of `repo` start one more task now?
+ *
+ * - never past the project's own number (capped by the worker's capacity);
+ * - never past the worker's capacity;
+ * - fair share: a project already building yields a free slot to any other
+ *   project with ready work that is building fewer, until that project has
+ *   had a pass to take it. A project building nothing never yields, so every
+ *   project with work gets its first build ahead of another's second.
+ */
+export function maySlotTake(facts) {
+    const here = facts.running.get(facts.repo) ?? 0;
+    const total = [...facts.running.values()].reduce((sum, n) => sum + n, 0);
+    if (here >= effectiveConcurrency(facts.limitOf(facts.repo), facts.capacity))
+        return { take: false, why: "limit" };
+    if (total >= facts.capacity)
+        return { take: false, why: "capacity" };
+    if (here === 0)
+        return { take: true };
+    for (const other of [...facts.waiting].sort()) {
+        if (other === facts.repo)
+            continue;
+        const theirs = facts.running.get(other) ?? 0;
+        if (theirs >= here || theirs >= effectiveConcurrency(facts.limitOf(other), facts.capacity))
+            continue;
+        if (facts.yieldingSince !== null && facts.passes.lastPass(other) > facts.yieldingSince)
+            continue;
+        return { take: false, why: "fair-share", to: other };
+    }
+    return { take: true };
+}

package/dist/project-delete-ui.d.ts

@@ -12,6 +12,13 @@ export type ProjectSettingsView = {
     holdings: ProjectHoldings;
     running: string[];
     canDelete: boolean;
+    /** How many of its tasks build at once: the saved number, what its worker allows, how many build now. */
+    builds?: {
+        setting: number;
+        capacity: number | null;
+        building: number;
+        canChange: boolean;
+    };
 };
 /** The project's page: its path, what Toolroll holds for it, and (for an instance operator) Delete project. */
 export declare function projectSettingsHtml(view: ProjectSettingsView, csrf: string, notice: {

package/dist/project-delete-ui.js

@@ -11,12 +11,29 @@ export const PROJECT_DELETE_CSS = `.project-settings,.project-delete{max-width:7
     `.project-settings details.danger-zone[open]{padding-bottom:14px}.project-settings form,.project-delete form{display:grid;gap:12px;margin-top:12px}.project-settings label,.project-delete label{display:grid;gap:4px;font-size:.8125rem;font-weight:500}` +
     `.project-settings input,.project-delete input{max-width:100%;min-height:36px}.project-delete .removes{margin:12px 0;padding-left:20px}.project-delete .removes li{margin:2px 0}` +
     `.project-delete .actions{display:flex;flex-wrap:wrap;gap:12px;align-items:center}.project-delete button.danger,.project-settings button.danger{background:var(--danger);color:#fff;border-color:var(--danger);white-space:nowrap}` +
-    `.project-settings button,.project-delete button{justify-self:start;min-height:36px;white-space:nowrap}.project-delete .actions a{min-height:36px;display:inline-flex;align-items:center}`;
+    `.project-settings button,.project-delete button{justify-self:start;min-height:36px;white-space:nowrap}.project-delete .actions a{min-height:36px;display:inline-flex;align-items:center}` +
+    `.project-settings .builds-at-once{margin-top:20px}.project-settings .builds-at-once h2{font-size:1rem;margin:0 0 4px}.project-settings .builds-at-once form{margin-top:4px;gap:4px}` +
+    `.project-settings .builds-at-once .builds-row{display:flex;gap:8px;align-items:stretch}.project-settings .builds-at-once input{width:5.5rem;min-height:44px;margin:0;box-sizing:border-box}.project-settings .builds-at-once button{min-height:44px;margin:0}` +
+    `.project-settings .builds-at-once .meta{margin:0}`;
+/** Builds at once: one number, one Save. The worker's cap is said only when it lowers the number. */
+function buildsHtml(view, csrf) {
+    const b = view.builds;
+    if (b === undefined)
+        return "";
+    const capped = b.capacity !== null && b.capacity < b.setting ? ` Its worker runs ${b.capacity} at once, so ${b.capacity} for now.` : "";
+    const now = `${b.building} building now.${capped}`;
+    if (!b.canChange)
+        return `<section class="builds-at-once"><h2>Builds at once</h2><p>Up to ${b.setting}. ${e(now)}</p></section>`;
+    return `<section class="builds-at-once"><h2>Builds at once</h2><form method="post" action="/settings/project/concurrency">` +
+        `<input type="hidden" name="csrf" value="${e(csrf)}"><input type="hidden" name="repo" value="${e(view.repo)}">` +
+        `<div class="builds-row"><input type="number" name="concurrency" min="1" max="64" step="1" inputmode="numeric" value="${b.setting}" aria-label="Builds at once" aria-describedby="builds-now"><button type="submit">Save</button></div>` +
+        `<p class="meta" id="builds-now">${e(now)}</p></form></section>`;
+}
 const note = (notice) => notice.problem ? `<p class="problem" role="alert">${e(notice.problem)}</p>` : notice.said ? `<p role="status">${e(notice.said)}</p>` : "";
 /** The project's page: its path, what Toolroll holds for it, and (for an instance operator) Delete project. */
 export function projectSettingsHtml(view, csrf, notice) {
     const held = `<p>Toolroll holds ${e(holdingsWords(view.holdings))} for <strong>${e(view.name)}</strong>.</p>`;
-    const head = `<section class="project-settings">${note(notice)}<p class="path">${e(view.repo)}</p>${held}`;
+    const head = `<section class="project-settings">${note(notice)}<p class="path">${e(view.repo)}</p>${held}${buildsHtml(view, csrf)}`;
     if (!view.canDelete)
         return `${head}<p class="meta">An instance operator can delete a project.</p></section>`;
     const body = view.running.length > 0

package/dist/project-delete.js

@@ -233,6 +233,7 @@ function deleteRows(store, repo, d, now) {
     del("telegram_outbound_message", `project = ? OR ${IN("notification")} OR ${IN("task_ref")} OR ${IN("source_run")}`, repo, notifications, T, R);
     del("chat_card_task", IN("task_ref"), T);
     del("push_delivery", IN("notification"), notifications);
+    del("notification_actor", IN("notification"), notifications);
     del("notification_delivery", IN("notification"), notifications);
     del("notification", IN("id"), notifications);
     del("chat_focus", IN("task"), K);
@@ -287,6 +288,8 @@ function deleteRows(store, repo, d, now) {
     del("workflow_preview", "repo = ?", repo);
     del("coding_handoff_scope", `id IN (SELECT id FROM coding_handoff WHERE json_extract(payload, '$.repo') = ?)`, repo);
     del("coding_handoff", "json_extract(payload, '$.repo') = ?", repo);
+    for (const table of ["task_act", "task_replacement"])
+        del(table, IN("task_ref"), T);
     del("task_ref", IN("id"), T);
     del("task_scope", IN("task_id"), K);
     del("task_edge", `${IN("blocked")} OR ${IN("blocker")}`, K, K);
@@ -313,6 +316,7 @@ function deleteRows(store, repo, d, now) {
     del("routine_fire", "routine_id IN (SELECT id FROM routine WHERE repo = ?)", repo);
     for (const [table, column] of SETTINGS)
         del(table, `${column} = ?`, repo);
+    del("project_mute", "repo = ?", repo);
     for (const table of ["knowledge_change", "project_skill_change", "memory_gap", "memory_proposal", "memory_rejection", "memory_session", "memory_search", "mode_rail", "side_spend", "watch_episode", "worktree", "coordinator_proposal"])
         del(table, "repo = ?", repo);
     // A builder watching the project keeps its lease until it stops; an ended one goes.

package/dist/pull-request-flow.d.ts

@@ -137,6 +137,8 @@ export declare function mergeAsPerson(store: Store, input: {
     password: string;
     exec?: PublishExec;
     clock?: () => Date;
+    /** A person's choice to merge without waiting for the full check (Quick or Off results). */
+    anyway?: boolean;
 }): Promise<Result<{
     commit: string | null;
 }>>;
@@ -152,6 +154,8 @@ export declare function mergePullRequest(store: Store, input: {
     clock?: () => Date;
     /** A flow's Pull request zone merges its own way; otherwise the project's. */
     method?: MergeMethod;
+    /** Only a person merging by hand may skip waiting for the full check. */
+    anyway?: boolean;
 }): Promise<Result<{
     commit: string | null;
 }>>;
@@ -166,6 +170,11 @@ export type PullRequestView = {
     mergeMethod: MergeMethod;
     canMerge: boolean;
     revisionTask: string | null;
+    /** Quick or Off results: the full check Merge waits for, unless a person merges anyway. */
+    fullCheck: {
+        state: "not-requested" | "waiting" | "failed" | "not-run";
+        message: string;
+    } | null;
 };
 /** The pull request a result opened through Complete, in plain words; null when it opened none. */
 export declare function pullRequestViewOf(store: Store, runId: number): PullRequestView | null;

package/dist/pull-request-flow.js

@@ -23,6 +23,7 @@ import { requestResultChanges } from "./result-actions.js";
 import { revisionSourceOf } from "./result-review.js";
 import { authenticateApprover } from "./scope.js";
 import { BRANCH_PREFIX, headWithin } from "./names.js";
+import { fullCheckGate, requestFollowUpChecks } from "./result-follow-ups.js";
 export const MERGE_METHODS = ["squash", "merge", "rebase"];
 /** CI revisions one task may file across its revisions before a person is asked instead. */
 export const MAX_CI_REVISIONS = 2;
@@ -198,6 +199,9 @@ export function owePullRequest(store, runId, actor, flowCard, now) {
         }
         store.handle.prepare("INSERT OR IGNORE INTO pull_request_follow (publication, flow_card, revisions, created_at, updated_at) VALUES (?, ?, ?, ?, ?)")
             .run(publication.id, flowCard, inheritedRevisions(store, run.taskRef), now.toISOString(), now.toISOString());
+        // Built with Quick or Off checks: the full check runs on this commit now, and Merge waits for it.
+        if (fullCheckGate(store, run.id, now).state === "not-requested")
+            requestFollowUpChecks(store, { runId: run.id, level: "full", actor, why: "pull-request" }, now);
         store.bumpWake();
         return publication;
     });
@@ -327,6 +331,9 @@ export async function followPullRequests(store, seen, options) {
             continue;
         }
         if (one.state === "passing" && one.headOid === publication.headSha && follow.readyHead !== one.headOid) {
+            // A Quick or Off result is ready only once its full check passed too; this is read again next time.
+            if (fullCheckGate(store, publication.run, clock()).state !== "clear")
+                continue;
             const grant = store.publicationGrantFor(store.refById(publication.taskRef)?.repo ?? "");
             updateFollow(store, publication.id, { ready_head: one.headOid }, clock());
             if (grant?.mergeWhenGreen === true && grant.publishOn === "complete") {
@@ -365,7 +372,7 @@ export async function mergeAsPerson(store, input) {
         return refuse("password", "Enter your password to merge.");
     if (!authenticateApprover(store, input.name, input.password, repo).ok)
         return refuse("password", "That password didn't work, or you can't merge in this project.");
-    return mergePullRequest(store, { runId: input.runId, by: input.name, ...(input.exec === undefined ? {} : { exec: input.exec }), ...(input.clock === undefined ? {} : { clock: input.clock }) });
+    return mergePullRequest(store, { runId: input.runId, by: input.name, ...(input.anyway === true ? { anyway: true } : {}), ...(input.exec === undefined ? {} : { exec: input.exec }), ...(input.clock === undefined ? {} : { clock: input.clock }) });
 }
 /**
  * Merge a followed pull request: callers have already established who is merging. A fresh read must show it open,
@@ -407,7 +414,7 @@ export async function mergePullRequest(store, input) {
             store.recordPublicationRemoteState(publication.id, "MERGED", now);
             store.resolveCiEpisodes(publication.githubRepo, publication.prNumber, null, now);
             store.recordAction({ at: now.toISOString(), actor: by, repo: ref.repo, taskId: ref.externalId, runId: publication.run, action: MERGED_ACTION,
-                outcome: commit ?? "merged", source: "work", detail: `PR #${pr} by ${method}, branch deleted` });
+                outcome: commit ?? "merged", source: "work", detail: `PR #${pr} by ${method}, branch deleted${skippedFullCheck ? ", merged without waiting for the full check" : ""}` });
             store.enqueueNotification({ source: { run: publication.run }, dedupeKey: `pull-request:${publication.id}:merged`, kind: "pull-request-merged",
                 subject: `Merged: ${ref.externalId} (PR #${pr})`, body: `${publication.prUrl ?? publication.githubRepo}${commit === null ? "" : ` — ${commit.slice(0, 12)}`}`,
                 link: `/t/${encodeURIComponent(ref.externalId)}` }, now);
@@ -417,6 +424,13 @@ export async function mergePullRequest(store, input) {
         updateFollow(store, publication.id, { merge_error: message.slice(0, 300) }, clock());
         return refuse(reason, message);
     };
+    // Built with Quick or Off checks: Merge waits for the full check on this commit, unless a person merges anyway.
+    const gate = fullCheckGate(store, publication.run, clock());
+    if (gate.state === "not-requested")
+        requestFollowUpChecks(store, { runId: publication.run, level: "full", actor: input.by, why: "pull-request" }, clock());
+    const skippedFullCheck = gate.state !== "clear";
+    if (skippedFullCheck && input.anyway !== true)
+        return fail("full-checks", gate.message);
     const before = await view();
     if (before === null)
         return fail("unread", "GitHub couldn't be read just now. Try again.");
@@ -450,7 +464,9 @@ export function pullRequestViewOf(store, runId) {
         return null;
     const grant = store.publicationGrantFor(store.refById(publication.taskRef)?.repo ?? "");
     const method = follow.mergeMethod ?? grant?.mergeMethod ?? "squash";
-    const base = { runId, prNumber: publication.prNumber, prUrl: publication.prUrl, mergeCommit: follow.mergeCommit || null, mergeMethod: method, canMerge: false, revisionTask: follow.revisionTask };
+    const gate = fullCheckGate(store, runId, new Date());
+    const fullCheck = gate.state === "clear" ? null : gate;
+    const base = { runId, prNumber: publication.prNumber, prUrl: publication.prUrl, mergeCommit: follow.mergeCommit || null, mergeMethod: method, canMerge: false, revisionTask: follow.revisionTask, fullCheck };
     const error = follow.mergeError === null ? "" : ` Last merge attempt: ${follow.mergeError}`;
     if (follow.mergeCommit !== null) {
         return { ...base, state: "merged", label: "Merged", detail: follow.mergedBy === null || follow.mergedBy === "GitHub" ? "Merged on GitHub." : `Merged by ${follow.mergedBy}${follow.mergeMethod === null ? "" : ` (${follow.mergeMethod})`}. Branch deleted.` };
@@ -464,6 +480,8 @@ export function pullRequestViewOf(store, runId) {
         return { ...base, state: "closed", label: "Closed", detail: "The pull request was closed on GitHub without merging." };
     switch (publication.lastCheckState) {
         case "passing":
+            if (fullCheck !== null)
+                return { ...base, state: "waiting", label: fullCheck.state === "failed" ? "Full checks failed" : "Waiting for full checks", detail: `CI passed on GitHub. ${fullCheck.message}${error}`, canMerge: grant !== null };
             return { ...base, state: "ready", label: "Ready to merge", detail: `CI passed on GitHub.${grant?.mergeWhenGreen === true ? " It merges by itself." : ""}${error}`, canMerge: grant !== null };
         case "failing":
             return { ...base, state: "failing", label: "Checks failed", detail: follow.revisionTask !== null && follow.askedHead !== follow.redHead ? `Revision ${follow.revisionTask} was filed with the failure.` : follow.askedHead !== null ? "Toolroll stopped filing revisions. Decide what to do next." : "Reading the failure." };

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

@@ -0,0 +1,101 @@
+import type { Runner } from "./backend.js";
+import type { Store, VerifyCommand } from "./store.js";
+import { type CheckLevel } from "./check-levels.js";
+export declare const CHECKS_REQUESTED = "checks requested";
+export declare const CHECKS_STARTED = "checks started";
+export declare const CHECKS_FINISHED = "checks finished";
+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">;
+export type FollowUpCheck = {
+    request: number;
+    runId: number;
+    level: RunLevel;
+    head: string;
+    actor: string;
+    at: string;
+    why: "person" | "pull-request";
+    /** 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;
+};
+type Refusal = {
+    ok: false;
+    reason: string;
+    message: string;
+};
+/** Every follow-up check a result has had, oldest first, as the ledger and its sealed receipts say. */
+export declare function followUpChecksOf(store: Store, runId: number, now?: Date, root?: string): FollowUpCheck[];
+/** Ask for checks on a result's exact commit. Asking twice while one is waiting
+ * or running returns the same request; a worker runs it once. */
+export declare function requestFollowUpChecks(store: Store, input: {
+    runId: number;
+    level: RunLevel;
+    actor: string;
+    why?: "person" | "pull-request";
+}, now: Date): {
+    ok: true;
+    request: number;
+    level: RunLevel;
+    existing: boolean;
+} | Refusal;
+/** Requests nobody has started yet, oldest first. */
+export declare function waitingCheckRequests(store: Store, now: Date): FollowUpCheck[];
+export type CheckRunDeps = {
+    runner?: Runner;
+    git?: Runner;
+    now?: () => Date;
+    scratch?: string;
+};
+/** Run one waiting request: claim it, check out its commit, run the approved
+ * setup (when the project has one) and the check, seal the log and receipt. */
+export declare function runFollowUpCheck(store: Store, root: string, request: number, deps?: CheckRunDeps): Promise<FollowUpCheck | null>;
+/** The worker's pass: run every waiting request, one at a time. */
+export declare function runWaitingChecks(store: Store, root: string, deps?: CheckRunDeps & {
+    shouldStop?: () => boolean;
+}): Promise<number>;
+export type CheckReading = {
+    status: "passed" | "failed" | "not-run" | "unavailable";
+    level: CheckLevel | null;
+    exitCode: number | null;
+    head: string | null;
+};
+/** The build's own check, then each finished follow-up in order on the same
+ * commit: a pass upgrades (a quick pass never replaces a full one), a failure
+ * is shown as it is. A follow-up that couldn't run changes nothing. */
+export declare function withFollowUps(original: CheckReading, followUps: readonly Pick<FollowUpCheck, "level" | "state" | "head" | "exitCode">[]): CheckReading & {
+    running: RunLevel | null;
+};
+/** The level a result's checks stand at now: the build's own level, raised by
+ * a follow-up that passed on the same commit. null for results from before levels. */
+export declare function resultCheckLevel(store: Store, runId: number, now: Date): CheckLevel | null;
+/** Whether this result's commit has passed the project's full check, here or in a follow-up. */
+export declare function fullCheckPassed(reading: CheckReading): boolean;
+/** Before a Quick or Off result merges: the project's full check on its exact
+ * commit. Clear when the build already ran the full check, when the project has
+ * no full command (its CI covers it), or when a follow-up full check passed. */
+export type FullCheckGate = {
+    state: "clear";
+} | {
+    state: "not-requested" | "waiting" | "failed" | "not-run";
+    message: string;
+};
+export declare function fullCheckGate(store: Store, runId: number, now: Date): FullCheckGate;
+export declare const isQuickCommand: (command: VerifyCommand | null, repo: string) => boolean;
+/** File a small task to write tests for a result's change. It is filed like any
+ * other task: nothing runs until a person approves it. */
+export declare function fileAddTestsTask(store: Store, root: string | null, input: {
+    runId: number;
+    actor: string;
+    filedVia: string;
+    admittedRepos?: readonly string[];
+}, now: Date): {
+    ok: true;
+    id: string;
+    existing: boolean;
+} | Refusal;
+export {};