toolroll 0.9.92 → 0.9.94

package/dist/storage-ui.js

@@ -1,15 +1,16 @@
 /**
- * Settings → Storage: how much space task checkouts use, what a clean-up would free now, the clean-up's preview (what
+ * Settings → Storage: how much space task folders (checkouts) use, what a clean-up would free now, what the next sweep's
+ * idle cleanup takes and when, the folders with uncommitted changes a person decides about, the clean-up's preview (what
  * goes, what stays and why, with paths) and its Remove behind the password, what the last storage sweep removed and
  * when (its paths in a disclosure) and why the next one waits, what landed work's teardown did and still waits on (in a
- * disclosure, with the one-time command for older work), and when a finished task's clean checkout goes by itself. An
- * instance operator's page, built from the revamp kit; the Settings frame adds the title.
+ * disclosure, with the one-time command for older work), and when a task's clean folder goes by itself. An instance
+ * operator's page, built from the revamp kit; the Settings frame adds the title.
  */
 import { homedir } from "node:os";
 import { basename } from "node:path";
 import { html, joinHtml } from "./html.js";
 import { previewDigest, whyWords } from "./checkout-cleanup.js";
-import { CLEANUP_CHOICES, bytesWords } from "./storage.js";
+import { CLEANUP_CHOICES, IDLE_CHOICES, bytesWords, idleCleanupWords } from "./storage.js";
 import { sweepDetails, sweepWords } from "./storage-sweep.js";
 import { sweepScheduleWords } from "./storage-sweep-schedule.js";
 import { codeLine, disclose, formRow, icon, infoLine, note, notice, select, settingsRecord, settingsSection } from "./server/kit.js";
@@ -48,17 +49,18 @@ function sweepHtml(sweep) {
 /** Landed work, on demand: what its teardown did, what it waits on and why, and the one-time command for older work. */
 function landedHtml(landed) {
     const done = landed.completed + landed.checkouts + landed.branches === 0 ? "No landed work cleaned up yet."
-        : `${plural(landed.completed, "task")} marked complete; ${plural(landed.checkouts, "checkout")} and ${plural(landed.branches, "local branch", "local branches")} removed.`;
+        : `${plural(landed.completed, "task")} marked complete; ${plural(landed.checkouts, "task folder")} and ${plural(landed.branches, "local branch", "local branches")} removed.`;
     const waiting = landed.waiting.length === 0 ? "" : html `<div data-landed-waiting>${note(`Waiting (${landed.waiting.length}):`)}${landed.waiting.map(one => settingsRecord({ title: html `<span class="k-mono">${tilde(one.target)}</span>`, sub: one.why ?? "" }))}</div>`;
     return html `<div data-landed>${disclose("Landed work", joinHtml([note(done), waiting,
         note(html `For work that landed before this: <code class="k-mono">toolroll storage clean --landed</code> shows what would go; add <code class="k-mono">--yes</code> to do it.`)]))}</div>`;
 }
-/** One checkout: the task it was for, its size, where it is (the home folder as ~), why it stays, and Discard when it has changes. */
+/** One task folder: the task it was for, its size, where it is (the home folder as ~), why it stays, and Discard when it has changes. */
 function item(one) {
-    const why = one.why === null ? "" : `${whyWords(one)[0].toUpperCase()}${whyWords(one).slice(1)}`;
+    // Under "Uncommitted changes" the heading already says why it stays.
+    const why = one.why === null || one.why === "has changes" ? "" : `${whyWords(one)[0].toUpperCase()}${whyWords(one).slice(1)}`;
     const discard = one.why === "has changes"
         ? disclose("Discard", kitSectionForm({ proof: "storage-discard", action: "/settings/storage/discard", id: `discard-${previewId(one.path)}`, hidden: { path: one.path },
-            save: { label: "Discard changes", variant: "danger" }, body: note("Throws away this checkout and its uncommitted changes. Its branch stays.") }))
+            save: { label: "Discard changes", variant: "danger" }, body: note("Throws away this folder and its uncommitted changes. Its branch stays.") }))
         : "";
     return settingsRecord({ title: one.taskId ?? basename(one.path), attrs: { "data-checkout": one.path }, when: bytesWords(one.bytes),
         sub: html `<span class="k-mono">${tilde(one.path)}</span>${why === "" ? "" : ` · ${why}`}`, more: discard });
@@ -67,29 +69,38 @@ function item(one) {
 const previewId = (path) => path.replace(/[^a-z0-9]+/gi, "-").replace(/^-|-$/g, "").slice(-48) || "checkout";
 export function storageHtml(view, said) {
     const { plan } = view;
-    const facts = [plural(plan.count, "checkout"), `${plan.waitingReview} waiting for review`, `${plan.withChanges} kept for their changes`].join(" · ");
+    const facts = [plural(plan.count, "task folder"), `${plan.waitingReview} waiting for review`, `${plan.withChanges} with uncommitted changes`].join(" · ");
     const frees = plan.go.length === 0 ? "Nothing to clean up now." : `Cleaning up now frees about ${bytesWords(plan.freeBytes)}.`;
-    const checkouts = settingsSection({ id: "checkouts", title: `Checkouts use ${bytesWords(plan.totalBytes)}`,
+    const checkouts = settingsSection({ id: "checkouts", title: `Task folders use ${bytesWords(plan.totalBytes)}`,
         body: joinHtml([
             said.problem ? notice(said.problem) : said.said ? infoLine(said.said) : "",
             html `<p class="k-note" data-checkout-bytes="${plan.totalBytes}">${facts}</p>`,
             view.measured ?? "",
             html `<p class="k-note" data-clean-bytes="${plan.freeBytes}">${frees}</p>`,
+            html `<p class="k-note" data-idle-bytes="${plan.idleBytes}">${idleCleanupWords(plan)}</p>`,
             view.sweep === undefined ? "" : sweepHtml(view.sweep),
             view.landed === undefined ? "" : landedHtml(view.landed),
         ]) });
     const remove = plan.go.length === 0 ? "" : kitSectionForm({ proof: "storage-clean", action: "/settings/storage/clean", id: "clean-form", hidden: { preview: previewDigest(plan) },
-        save: { label: `Remove ${plural(plan.go.length, "checkout")}`, variant: "danger" }, body: html `` });
+        save: { label: `Remove ${plural(plan.go.length, "task folder")}`, variant: "danger" }, body: html `` });
     const goes = plan.go.length === 0 ? note("Nothing to remove now.")
         : html `<div data-goes>${plan.go.map(one => item(one))}</div>`;
-    const stays = plan.stay.length === 0 ? "" : disclose(`Stays (${plan.stay.length})`, html `<div data-stays>${plan.stay.map(one => item(one))}</div>`);
+    const changed = plan.stay.filter(one => one.why === "has changes");
+    const others = plan.stay.filter(one => one.why !== "has changes");
+    const stays = others.length === 0 ? "" : disclose(`Stays (${others.length})`, html `<div data-stays>${others.map(one => item(one))}</div>`);
+    // Never removed by itself: a person looks at each and keeps it or discards it.
+    const changes = changed.length === 0 ? "" : settingsSection({ id: "uncommitted", title: `Uncommitted changes (${changed.length})`,
+        lead: `${changed.length === 1 ? "This folder has" : "These folders have"} work that isn't on any branch, about ${bytesWords(changed.reduce((sum, one) => sum + one.bytes, 0))}. Toolroll never removes ${changed.length === 1 ? "it" : "them"} by itself.`,
+        body: html `<div data-uncommitted>${changed.map(one => item(one))}</div>` });
     const cleanUp = settingsSection({ id: "clean-up", title: "Clean up now",
-        lead: plan.go.length === 0 ? "Nothing to remove now." : `Removes ${plural(plan.go.length, "checkout")}, about ${bytesWords(plan.freeBytes)}. Their branches stay, so nothing committed is lost.`,
+        lead: plan.go.length === 0 ? "Nothing to remove now." : `Removes ${plural(plan.go.length, "task folder")}, about ${bytesWords(plan.freeBytes)}. Their branches stay, so nothing committed is lost.`,
         body: html `<div data-clean-up>${joinHtml([plan.go.length === 0 ? "" : goes, remove, stays])}</div>` });
     const automatic = settingsSection({ id: "automatic-cleanup", title: "Automatic cleanup",
-        lead: "Its branch stays. Checkouts with changes, commits on no branch, in use, or waiting for review are kept. When a task's work is already in main, Toolroll marks it complete and removes its checkout and local branches.",
+        lead: "Branches stay, so a later run, revision or retry makes a new folder. Folders with uncommitted changes, commits on no branch, or in use are kept. When a task's work is already in main, Toolroll marks it complete and removes its folder and local branches.",
         body: kitSectionForm({ proof: "storage-cleanup", action: "/settings/storage", id: "cleanup-form", gate: true,
-            body: formRow("Remove a finished task's clean checkout", null, select({ id: "storage-cleanup", name: "cleanup", label: "Remove a finished task's clean checkout", current: plan.cleanup,
-                items: CLEANUP_CHOICES.map(one => [one.value, one.label]) }), "inline") }) });
-    return joinHtml([checkouts, cleanUp, automatic]);
+            body: joinHtml([formRow("Remove a finished task's clean folder", null, select({ id: "storage-cleanup", name: "cleanup", label: "Remove a finished task's clean folder", current: plan.cleanup,
+                    items: CLEANUP_CHOICES.map(one => [one.value, one.label]) }), "inline"),
+                formRow("Remove an idle task's clean folder", "Even with its result waiting for review or the task unfinished. Idle means no run, no one acting on it and no open lease.", select({ id: "storage-idle", name: "idle", label: "Remove an idle task's clean folder", current: plan.idle,
+                    items: IDLE_CHOICES.map(one => [one.value, one.label]) }), "inline")]) }) });
+    return joinHtml([checkouts, changes, cleanUp, automatic]);
 }

package/dist/storage.d.ts

@@ -1,5 +1,5 @@
 import type { Store } from "./store.js";
-import { type CheckoutCleanup } from "./contracts/storage.js";
+import { type CheckoutCleanup, type CheckoutIdle } from "./contracts/storage.js";
 /** Settings → Storage: when a finished task's clean checkout is removed. One row, or none (the default). */
 export declare const CHECKOUT_CLEANUP_SCHEMA = "\nCREATE TABLE IF NOT EXISTS checkout_cleanup_setting (\n  id         INTEGER PRIMARY KEY CHECK (id = 1),\n  cleanup    TEXT NOT NULL CHECK (cleanup IN ('finished', '2d', '7d', 'never')),\n  updated_by TEXT NOT NULL,\n  updated_at TEXT NOT NULL\n);\n";
 /**
@@ -10,7 +10,7 @@ export declare const CHECKOUT_CLEANUP_SCHEMA = "\nCREATE TABLE IF NOT EXISTS che
 export declare const LANDED_CLEANUP_SCHEMA = "\nCREATE TABLE IF NOT EXISTS landed_cleanup (\n  id          INTEGER PRIMARY KEY,\n  repo        TEXT NOT NULL,\n  task_id     TEXT,\n  run_id      INTEGER,\n  receipt     TEXT,\n  head        TEXT NOT NULL,\n  how         TEXT NOT NULL CHECK (how IN ('merged', 'in-main', 'content-in-main')),\n  reason      TEXT NOT NULL,\n  completed   INTEGER NOT NULL DEFAULT 0 CHECK (completed IN (0, 1)),\n  actor       TEXT NOT NULL,\n  created_at  TEXT NOT NULL,\n  finished_at TEXT\n);\nCREATE UNIQUE INDEX IF NOT EXISTS landed_cleanup_result ON landed_cleanup(run_id) WHERE run_id IS NOT NULL;\nCREATE TABLE IF NOT EXISTS landed_cleanup_item (\n  id      INTEGER PRIMARY KEY,\n  cleanup INTEGER NOT NULL REFERENCES landed_cleanup(id) ON DELETE CASCADE,\n  kind    TEXT NOT NULL CHECK (kind IN ('checkout', 'branch')),\n  repo    TEXT NOT NULL,\n  target  TEXT NOT NULL,\n  expect  TEXT NOT NULL,\n  state   TEXT NOT NULL DEFAULT 'pending' CHECK (state IN ('pending', 'done', 'kept')),\n  why     TEXT,\n  done_at TEXT\n);\nCREATE UNIQUE INDEX IF NOT EXISTS landed_cleanup_pending ON landed_cleanup_item(kind, repo, target) WHERE state = 'pending';\nCREATE INDEX IF NOT EXISTS landed_cleanup_item_of ON landed_cleanup_item(cleanup, state);\n";
 /** What each storage sweep or clean-up by hand did (storage-sweep.ts): the latest few. */
 export declare const STORAGE_SWEEP_SCHEMA = "\nCREATE TABLE IF NOT EXISTS storage_sweep (\n  id     INTEGER PRIMARY KEY,\n  at     TEXT NOT NULL,\n  source TEXT NOT NULL CHECK (source IN ('automatic', 'manual')),\n  actor  TEXT NOT NULL,\n  result TEXT NOT NULL\n);\n";
-export type { CheckoutCleanup } from "./contracts/storage.js";
+export type { CheckoutCleanup, CheckoutIdle } from "./contracts/storage.js";
 export declare const DEFAULT_CLEANUP: CheckoutCleanup;
 export declare const CLEANUP_CHOICES: readonly {
     value: CheckoutCleanup;
@@ -20,6 +20,31 @@ export declare const CLEANUP_CHOICES: readonly {
 /** `finished` (or complete, cancelled), `2d`, `7d` (or week, 1w), `never` (or off); undefined when it's none of those. */
 export declare function parseCleanup(text: string): CheckoutCleanup | undefined;
 export declare function cleanupWords(cleanup: CheckoutCleanup): string;
+/**
+ * v151: how long a task stays idle (no run, no person's act, no open lease) before its clean folder goes, even with its
+ * result waiting for review or the task unfinished (checkout-cleanup.ts). Saved rows read NULL: the default.
+ */
+export declare const V151_ADDED_COLUMNS: Readonly<Record<string, Readonly<Record<string, {
+    definition: string;
+    saved: string;
+}>>>>;
+export declare const DEFAULT_IDLE: CheckoutIdle;
+export declare const IDLE_CHOICES: readonly {
+    value: CheckoutIdle;
+    label: string;
+    days: number | null;
+}[];
+/** `7`, `14d`, `30 days`, `never` (or off); undefined when it's none of those. */
+export declare function parseIdle(text: string): CheckoutIdle | undefined;
+/** After "A task's clean folder is removed ". */
+export declare function idleWords(idle: CheckoutIdle): string;
+/** What the next sweep's idle cleanup takes, for `toolroll storage` and Settings → Storage. The sweep's own line says when. */
+export declare function idleCleanupWords(plan: {
+    cleanup: CheckoutCleanup;
+    idle: CheckoutIdle;
+    idleCount: number;
+    idleBytes: number;
+}): string;
 /** Bytes each path holds on disk: one `du` for them all (fast on a 300 MB checkout), a walk where it can't answer. */
 export declare function diskBytes(paths: readonly string[]): Map<string, number>;
 export type StorageLine = {

package/dist/storage.js

@@ -4,14 +4,14 @@
  * Build checkouts and staged releases are the big ones; the worker removes a
  * finished task's clean checkout as the checkout cleanup setting says
  * (checkout-cleanup.ts), and the daily storage sweep (storage-sweep.ts) takes
- * what slips through: stale test temp folders, leftover processes, extra
+ * idle tasks' clean checkouts and what slips through: stale test temp folders, leftover processes, extra
  * staged runtimes and dependency installs unused for a week.
  */
 import { execFile, spawnSync } from "node:child_process";
 import { lstatSync, readdirSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { DEPS_FOLDER, sharedCopies } from "./shared-deps.js";
-import { checkoutCleanupSchema } from "./contracts/storage.js";
+import { checkoutCleanupSchema, checkoutIdleSchema } from "./contracts/storage.js";
 /** Settings → Storage: when a finished task's clean checkout is removed. One row, or none (the default). */
 export const CHECKOUT_CLEANUP_SCHEMA = `
 CREATE TABLE IF NOT EXISTS checkout_cleanup_setting (
@@ -93,6 +93,43 @@ export function cleanupWords(cleanup) {
         : cleanup === "never" ? "never (only when you clean up)"
             : `${cleanup === "2d" ? "2 days" : "a week"} after its task is complete or cancelled`;
 }
+/**
+ * v151: how long a task stays idle (no run, no person's act, no open lease) before its clean folder goes, even with its
+ * result waiting for review or the task unfinished (checkout-cleanup.ts). Saved rows read NULL: the default.
+ */
+export const V151_ADDED_COLUMNS = Object.freeze({
+    checkout_cleanup_setting: { idle: { definition: "TEXT CHECK (idle IN ('7d', '14d', '30d', 'never'))", saved: "NULL" } },
+});
+export const DEFAULT_IDLE = "14d";
+export const IDLE_CHOICES = [
+    { value: "7d", label: "After 7 days idle", days: 7 },
+    { value: "14d", label: "After 14 days idle", days: 14 },
+    { value: "30d", label: "After 30 days idle", days: 30 },
+    { value: "never", label: "Never", days: null },
+];
+/** `7`, `14d`, `30 days`, `never` (or off); undefined when it's none of those. */
+export function parseIdle(text) {
+    const value = text.trim().toLowerCase().replace(/\s+/g, " ");
+    if (value === "off")
+        return "never";
+    const days = /^(\d+)( ?d| days?)?$/.exec(value)?.[1];
+    const parsed = checkoutIdleSchema.safeParse(days === undefined ? value : `${days}d`);
+    return parsed.success ? parsed.data : undefined;
+}
+/** After "A task's clean folder is removed ". */
+export function idleWords(idle) {
+    const days = IDLE_CHOICES.find(one => one.value === idle).days;
+    return days === null ? "never for being idle" : `after ${days} days idle`;
+}
+/** What the next sweep's idle cleanup takes, for `toolroll storage` and Settings → Storage. The sweep's own line says when. */
+export function idleCleanupWords(plan) {
+    if (plan.cleanup === "never" || plan.idle === "never")
+        return "Idle cleanup is off.";
+    const limit = `${idleWords(plan.idle)[0].toUpperCase()}${idleWords(plan.idle).slice(1)}`;
+    if (plan.idleCount === 0)
+        return `${limit}, a task's clean folder goes. None are due.`;
+    return `${limit}, a task's clean folder goes: the next sweep frees about ${bytesWords(plan.idleBytes)} (${plan.idleCount} folder${plan.idleCount === 1 ? "" : "s"}).`;
+}
 /** Bytes each path holds on disk: one `du` for them all (fast on a 300 MB checkout), a walk where it can't answer. */
 export function diskBytes(paths) {
     const sizes = new Map();

package/dist/store.d.ts

@@ -5,6 +5,7 @@ import { type ProjectSandbox } from "./project-sandbox.js";
 import type { FencePolicy } from "./agent-fence.js";
 import { type NetworkProfile, type ProjectNetwork, type RunNetworkRecord } from "./egress.js";
 import { type AcpLaunch } from "./acp-attest.js";
+import { type CheckStamp, type StampReading } from "./check-stamp.js";
 export { refArchived, taskArchived } from "./task-archive.js";
 import { type ChatBinding } from "./chat-core.js";
 import { ChatMessages, TELEGRAM_HOLD_REASONS, TELEGRAM_SKIPPED_ELSEWHERE, TELEGRAM_SKIPPED_OTHER_CHAT, TELEGRAM_SKIPPED_QUIET } from "./chat-messages.js";
@@ -16,6 +17,7 @@ import type { FlowCardChange, FlowCardFields } from "./contracts/flow-card.js";
 import { type Actor } from "./actor.js";
 import { type LiveActivityKind } from "./live.js";
 import { type CredentialKind, type TokenPurpose } from "./api-tokens.js";
+import { type ThisMachine } from "./machine-identity.js";
 import { type CriterionMatrixRow, type CriterionJudgementWord } from "./proof.js";
 import { type Authority, type LocalMode } from "./local-owner.js";
 import { type ScopeAuthor, type ExecutionProfile, type UnattendedPermissionMode, type AcceptanceCriterion } from "./scope.js";
@@ -29,6 +31,7 @@ import type { Scope } from "./scope.js";
 import type { QualityMode } from "./quality.js";
 import type { ProgressSnapshot } from "./plan.js";
 import { type CheckProgressSnapshot } from "./check-progress.js";
+export { V153_ADDED_COLUMNS } from "./plain-schema.js";
 import { type ReleaseCheckPurpose, type ReleaseTerms } from "./contracts/release-terms.js";
 import { type ProjectAccess } from "./project-access.js";
 import { type LedgerEntry } from "./action-ledger.js";
@@ -37,7 +40,7 @@ import { underCeiling, type OrgPolicy, type SavedPolicy } from "./policy.js";
 import { type ReviewSwitch } from "./review-switch.js";
 import { type Billing, type Budget, type BudgetAgent, type BudgetHold, type BudgetScope, type BudgetState, type SpendItem } from "./spend.js";
 import { type RetentionKind, type RetentionPeriods } from "./retention.js";
-import { type CheckoutCleanup } from "./storage.js";
+import { type CheckoutCleanup, type CheckoutIdle } from "./storage.js";
 import { type LedgerChainReport } from "./ledger-chain.js";
 import { type ApprovalGate, type ApprovalRules, type ApproverKind, type Filer } from "./approval-policy.js";
 import { type ReportedAmount } from "./reported-usage.js";
@@ -59,6 +62,15 @@ export declare const LEAD_SWEEP_SCHEMA = "\nCREATE TABLE IF NOT EXISTS lead_swee
 export declare const LEAD_COMMITMENT_SCHEMA = "\nCREATE TABLE IF NOT EXISTS lead_commitment (\n  id             INTEGER PRIMARY KEY AUTOINCREMENT,\n  owner          TEXT NOT NULL,\n  repo           TEXT,\n  thread         INTEGER NOT NULL,\n  turn           INTEGER,\n  channel        TEXT NOT NULL DEFAULT 'chat',\n  what           TEXT NOT NULL,\n  condition_json TEXT NOT NULL,\n  check_at       TEXT NOT NULL,\n  expires_at     TEXT NOT NULL,\n  state          TEXT NOT NULL DEFAULT 'open' CHECK (state IN ('open', 'done', 'cancelled', 'expired')),\n  created_at     TEXT NOT NULL,\n  checked_at     TEXT,\n  closed_at      TEXT,\n  closed_by      TEXT,\n  outcome        TEXT\n);\nCREATE INDEX IF NOT EXISTS lead_commitment_due ON lead_commitment (state, check_at);\nCREATE INDEX IF NOT EXISTS lead_commitment_owner ON lead_commitment (owner, state, id);\n";
 /** What stops a finished run reading stopped (Store.stopQuiescenceFact). */
 export type StopFactKind = "open" | "alive" | "elsewhere" | "unprovable" | "unknown" | "settling";
+/** Why a finished run's stop is unproven where Toolroll's own process check (stop-proof.ts) can prove it: a run that
+ * started its agent with no process witness, a spawn witness with no pid, or a workspace note that can't be read. */
+export type StopProofCause = "no-witness" | "incomplete-spawn" | "workspace-unreadable";
+export type StopFact = {
+    run: number;
+    kind: StopFactKind;
+    problem: string;
+    cause?: StopProofCause;
+};
 export type TaskAct = "filed" | "approved" | "cancelled" | "completed" | "asked";
 /** Store.stopQuiescenceFact, read safely: a deploy proves completion with this code over the INSTALLED runtime's store,
  * which may predate the method. There the older stopQuiescenceProblem decides, and its words give the kind. */
@@ -234,7 +246,7 @@ export type SealedLedgerEntry = LedgerEntry & {
         hash: string;
     } | null;
 };
-export declare const SCHEMA_VERSION = 148;
+export declare const SCHEMA_VERSION = 154;
 /** v118: the tables merged into `credential`, in the order they move (a person's API tokens keep their ids first). */
 export declare const V118_MERGED_TABLES: Readonly<Record<string, CredentialKind>>;
 /**
@@ -426,7 +438,7 @@ export declare const V147_ADDED_COLUMNS: Readonly<Record<string, Readonly<Record
 }>>>>;
 /** The v147 migration's steps after the epoch, in order: a test seam (OpenOptions.migrationStep) may stop after each. */
 export declare const V147_STEPS: readonly ["epoch", "local-mode", "password-set", "web-session", "console-instance"];
-export type MigrationStep = (typeof V147_STEPS)[number] | (typeof V148_STEPS)[number];
+export type MigrationStep = (typeof V147_STEPS)[number] | (typeof V148_STEPS)[number] | (typeof V149_STEPS)[number] | (typeof V150_STEPS)[number] | (typeof V151_STEPS)[number] | (typeof V152_STEPS)[number] | (typeof V153_STEPS)[number] | (typeof V154_STEPS)[number];
 /**
  * v148 (docs/plans/results-routing.md): every table the results-routing arc uses, landed at once because a current
  * store runs no DDL. Slice 1 writes run_cohort, route_record and models_generation; route_rule, route_exposure* and
@@ -458,6 +470,60 @@ export declare const V148_ADDED_COLUMNS: Readonly<Record<string, Readonly<Record
 }>>>>;
 /** The v148 migration's steps after v147's, in order (OpenOptions.migrationStep may stop after each). */
 export declare const V148_STEPS: readonly ["results-tables", "exec-class", "revision-origin", "suggest-models"];
+/**
+ * v149 (docs/plans/learning-loops.md): every table the learning-loops arc uses, landed at once because a current store
+ * runs no DDL. Slice 1 writes check_fact, check_result and learning_watch; the rest are written from later slices.
+ * Each table has one writer module (the migration aside), which release-auto's learning scan (eval-hooks.ts
+ * learningWriteProblem) holds a release to: check_fact and check_result → check-facts.ts; local_observation → flaky.ts;
+ * ci_flaky_observation and ci_pairing_rejected → flaky-ci.ts; learning_watch → flaky.ts and lesson-notes.ts;
+ * lesson_note and lesson_note_tally → lesson-notes.ts; memory_use → memory-use.ts; memory_tidy_proposal and
+ * decision_merge → memory-tidy.ts.
+ *
+ * Nothing here is ever read for authority: a check's outcome, a verdict and an approval never change because of it.
+ *
+ * Deletion follows today's semantics (runs are never deleted by ordinary work; removing a project keeps its results).
+ * The tables are keyed by repo path with no foreign key to `project`; their run keys are plain REFERENCES with no ON
+ * DELETE action. check_fact, learning_watch, lesson_note, lesson_note_tally, memory_use, memory_tidy_proposal and
+ * decision_merge are kept and never deleted (their triggers allow only the columns their one writer sets: a watch's
+ * `until`, a tally's counters, a proposal's decision, a merge's undo). check_result, local_observation,
+ * ci_flaky_observation and ci_pairing_rejected are pruned after 180 days by the storage sweep's own step (a later
+ * slice), the only DELETE on them; their rows never change. The whole-project deletion (project-delete.ts), which
+ * lifts every guard for its one transaction, takes them with the project as it takes everything else.
+ */
+export declare const V149_SCHEMA = "\nCREATE TABLE IF NOT EXISTS check_fact (\n  run               INTEGER PRIMARY KEY REFERENCES run(id),\n  repo              TEXT,\n  task_ref          INTEGER NOT NULL,\n  head              TEXT,\n  tree              TEXT,\n  command_digest    TEXT,\n  access            TEXT,\n  harness_digest    TEXT,\n  lockfile          TEXT,\n  conditions_digest TEXT,\n  conditions_class  TEXT,\n  purpose           TEXT NOT NULL CHECK (purpose IN ('ordinary','release','nightly')),\n  learn_state       TEXT NOT NULL CHECK (learn_state IN ('recorded','not-recorded','not-asked')),\n  learn_why         TEXT,\n  recorded_at       TEXT NOT NULL,\n  CHECK ((learn_state = 'not-recorded') = (learn_why IS NOT NULL)),\n  CHECK ((conditions_digest IS NULL) = (conditions_class IS NULL)),\n  CHECK (conditions_digest IS NULL OR tree IS NOT NULL)\n);\nCREATE INDEX IF NOT EXISTS check_fact_by_repo ON check_fact (repo, recorded_at);\nCREATE INDEX IF NOT EXISTS check_fact_by_tree ON check_fact (tree, conditions_digest);\nCREATE TABLE IF NOT EXISTS check_result (\n  run         INTEGER NOT NULL REFERENCES check_fact(run),\n  identity    TEXT NOT NULL CHECK (length(identity) BETWEEN 1 AND 2600),\n  state       TEXT NOT NULL CHECK (state IN ('failed','passed','skipped','passed-on-retry')),\n  source      TEXT NOT NULL CHECK (source IN ('receipt','report','log','learn')),\n  recorded_at TEXT NOT NULL,\n  PRIMARY KEY (run, identity, source)\n);\nCREATE INDEX IF NOT EXISTS check_result_by_identity ON check_result (identity, run);\nCREATE TABLE IF NOT EXISTS local_observation (\n  id                INTEGER PRIMARY KEY AUTOINCREMENT,\n  repo              TEXT NOT NULL,\n  identity          TEXT NOT NULL,\n  failed_run        INTEGER NOT NULL REFERENCES run(id),\n  passed_run        INTEGER NOT NULL REFERENCES run(id),\n  tree              TEXT NOT NULL,\n  conditions_digest TEXT NOT NULL,\n  kind              TEXT NOT NULL CHECK (kind IN ('regate','same-tree','in-check-retry')),\n  observed_at       TEXT NOT NULL,\n  UNIQUE (identity, failed_run, passed_run),\n  CHECK ((kind = 'in-check-retry') = (failed_run = passed_run))\n);\nCREATE INDEX IF NOT EXISTS local_observation_by_repo ON local_observation (repo, identity, observed_at);\nCREATE TABLE IF NOT EXISTS ci_flaky_observation (\n  id                INTEGER PRIMARY KEY AUTOINCREMENT,\n  repo              TEXT NOT NULL,\n  provider          TEXT NOT NULL CHECK (provider = 'github'),\n  repository        TEXT NOT NULL,\n  workflow          TEXT NOT NULL,\n  lane_id           TEXT NOT NULL,\n  lane_name         TEXT NOT NULL,\n  workflow_run_id   INTEGER NOT NULL CHECK (workflow_run_id >= 1),\n  head_sha          TEXT NOT NULL,\n  failed_attempt    INTEGER NOT NULL CHECK (failed_attempt >= 1),\n  failed_job_id     INTEGER NOT NULL,\n  failed_conclusion TEXT NOT NULL,\n  passed_attempt    INTEGER NOT NULL,\n  passed_job_id     INTEGER NOT NULL,\n  passed_conclusion TEXT NOT NULL,\n  observed_at       TEXT NOT NULL,\n  UNIQUE (provider, repository, workflow_run_id, lane_id, failed_attempt, passed_attempt),\n  CHECK (passed_attempt > failed_attempt)\n);\nCREATE INDEX IF NOT EXISTS ci_flaky_observation_by_repo ON ci_flaky_observation (repo, lane_id, observed_at);\nCREATE TABLE IF NOT EXISTS ci_pairing_rejected (\n  provider        TEXT NOT NULL CHECK (provider = 'github'),\n  repository      TEXT NOT NULL,\n  workflow_run_id INTEGER NOT NULL CHECK (workflow_run_id >= 1),\n  attempt         INTEGER NOT NULL CHECK (attempt >= 1),\n  lane_id         TEXT,\n  why             TEXT NOT NULL,\n  at              TEXT NOT NULL,\n  PRIMARY KEY (provider, repository, workflow_run_id, attempt, why)\n);\nCREATE TABLE IF NOT EXISTS learning_watch (\n  repo       TEXT NOT NULL,\n  identity   TEXT NOT NULL CHECK (length(identity) BETWEEN 1 AND 2600),\n  reason     TEXT NOT NULL CHECK (reason IN ('note','observation')),\n  source_ref TEXT NOT NULL,\n  since      TEXT NOT NULL,\n  until      TEXT,\n  PRIMARY KEY (repo, identity, reason, source_ref),\n  CHECK (until IS NULL OR until >= since)\n);\nCREATE INDEX IF NOT EXISTS learning_watch_open ON learning_watch (repo, since) WHERE until IS NULL;\nCREATE TABLE IF NOT EXISTS lesson_note (\n  proposal                INTEGER PRIMARY KEY REFERENCES memory_proposal(id),\n  repo                    TEXT NOT NULL,\n  failed_run              INTEGER NOT NULL REFERENCES run(id),\n  passing_run             INTEGER NOT NULL REFERENCES run(id),\n  repair_chain            INTEGER REFERENCES repair_chain(id),\n  revision_origin         TEXT CHECK (revision_origin IS NULL OR revision_origin IN ('person','automatic-review','flow','lead','machine')),\n  identities_json         TEXT NOT NULL,\n  changed_paths_json      TEXT NOT NULL,\n  test_files_changed_json TEXT NOT NULL,\n  facts_digest            TEXT NOT NULL,\n  created_at              TEXT NOT NULL,\n  CHECK (failed_run <> passing_run)\n);\nCREATE INDEX IF NOT EXISTS lesson_note_by_repo ON lesson_note (repo, created_at);\nCREATE TABLE IF NOT EXISTS lesson_note_tally (\n  note                INTEGER NOT NULL REFERENCES lesson_note(proposal),\n  month               TEXT NOT NULL CHECK (month GLOB '[0-9][0-9][0-9][0-9]-[0-1][0-9]'),\n  executions          INTEGER NOT NULL DEFAULT 0 CHECK (executions >= 0),\n  failures            INTEGER NOT NULL DEFAULT 0 CHECK (failures >= 0 AND failures <= executions),\n  mixed_failures      INTEGER NOT NULL DEFAULT 0 CHECK (mixed_failures >= 0),\n  received_executions INTEGER NOT NULL DEFAULT 0 CHECK (received_executions >= 0 AND received_executions <= executions),\n  received_failures   INTEGER NOT NULL DEFAULT 0 CHECK (received_failures >= 0 AND received_failures <= received_executions AND received_failures <= failures),\n  unreported_checks   INTEGER NOT NULL DEFAULT 0 CHECK (unreported_checks >= 0),\n  sources_json        TEXT NOT NULL DEFAULT '[]',\n  partial             INTEGER NOT NULL DEFAULT 0 CHECK (partial IN (0,1)),\n  PRIMARY KEY (note, month)\n);\nCREATE TABLE IF NOT EXISTS memory_use (\n  run         INTEGER NOT NULL REFERENCES run(id),\n  repo        TEXT,\n  kind        TEXT NOT NULL CHECK (kind IN ('lesson','reference','decision')),\n  item        TEXT NOT NULL,\n  version     INTEGER,\n  phase       TEXT NOT NULL,\n  included_at TEXT,\n  PRIMARY KEY (run, kind, item)\n);\nCREATE INDEX IF NOT EXISTS memory_use_by_item ON memory_use (repo, kind, item, run);\nCREATE TABLE IF NOT EXISTS memory_tidy_proposal (\n  id            INTEGER PRIMARY KEY AUTOINCREMENT,\n  repo          TEXT NOT NULL,\n  kind          TEXT NOT NULL CHECK (kind IN ('retire','merge','contradiction','note-failing','restore','unmerge')),\n  items_json    TEXT NOT NULL,\n  after_text    TEXT,\n  rationale     TEXT NOT NULL,\n  evidence_json TEXT NOT NULL,\n  source        TEXT NOT NULL CHECK (source IN ('usage','duplicate','model','note','person')),\n  status        TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending','accepted','rejected','stale')),\n  created_at    TEXT NOT NULL,\n  decided_by    TEXT,\n  decided_proof TEXT,\n  decided_at    TEXT,\n  CHECK ((status = 'pending') = (decided_at IS NULL)),\n  CHECK (status IN ('accepted','rejected') OR (decided_by IS NULL AND decided_proof IS NULL)),\n  CHECK (status NOT IN ('accepted','rejected') OR decided_by IS NOT NULL)\n);\nCREATE INDEX IF NOT EXISTS memory_tidy_proposal_pending ON memory_tidy_proposal (repo, status, kind);\nCREATE TABLE IF NOT EXISTS decision_merge (\n  merge                INTEGER NOT NULL,\n  successor            INTEGER NOT NULL REFERENCES project_decision(id),\n  successor_revision   INTEGER NOT NULL CHECK (successor_revision >= 1),\n  predecessor          INTEGER NOT NULL REFERENCES project_decision(id),\n  predecessor_revision INTEGER NOT NULL CHECK (predecessor_revision >= 1),\n  at                   TEXT NOT NULL,\n  by                   TEXT NOT NULL,\n  undone_at            TEXT,\n  undone_by            TEXT,\n  PRIMARY KEY (merge, predecessor),\n  CHECK (successor <> predecessor),\n  CHECK ((undone_at IS NULL) = (undone_by IS NULL))\n);\nCREATE INDEX IF NOT EXISTS decision_merge_by_successor ON decision_merge (successor);\nCREATE INDEX IF NOT EXISTS decision_merge_by_predecessor ON decision_merge (predecessor);\nCREATE TRIGGER IF NOT EXISTS check_fact_no_update BEFORE UPDATE ON check_fact BEGIN SELECT RAISE(ABORT,'check facts are recorded once'); END;\nCREATE TRIGGER IF NOT EXISTS check_fact_no_delete BEFORE DELETE ON check_fact BEGIN SELECT RAISE(ABORT,'check facts are kept'); END;\nCREATE TRIGGER IF NOT EXISTS check_result_no_update BEFORE UPDATE ON check_result BEGIN SELECT RAISE(ABORT,'check results are recorded once'); END;\nCREATE TRIGGER IF NOT EXISTS local_observation_no_update BEFORE UPDATE ON local_observation BEGIN SELECT RAISE(ABORT,'observations are recorded once'); END;\nCREATE TRIGGER IF NOT EXISTS ci_flaky_observation_no_update BEFORE UPDATE ON ci_flaky_observation BEGIN SELECT RAISE(ABORT,'observations are recorded once'); END;\nCREATE TRIGGER IF NOT EXISTS ci_pairing_rejected_no_update BEFORE UPDATE ON ci_pairing_rejected BEGIN SELECT RAISE(ABORT,'rejected pairings are recorded once'); END;\nCREATE TRIGGER IF NOT EXISTS learning_watch_only_ends BEFORE UPDATE ON learning_watch\n  WHEN NEW.repo IS NOT OLD.repo OR NEW.identity IS NOT OLD.identity OR NEW.reason IS NOT OLD.reason OR NEW.source_ref IS NOT OLD.source_ref\n    OR NEW.since IS NOT OLD.since OR OLD.until IS NOT NULL OR NEW.until IS NULL\n  BEGIN SELECT RAISE(ABORT,'a tracked identity only ends, once'); END;\nCREATE TRIGGER IF NOT EXISTS learning_watch_no_delete BEFORE DELETE ON learning_watch BEGIN SELECT RAISE(ABORT,'tracked identities are kept'); END;\nCREATE TRIGGER IF NOT EXISTS lesson_note_no_update BEFORE UPDATE ON lesson_note BEGIN SELECT RAISE(ABORT,'lesson note facts are recorded once'); END;\nCREATE TRIGGER IF NOT EXISTS lesson_note_no_delete BEFORE DELETE ON lesson_note BEGIN SELECT RAISE(ABORT,'lesson notes are kept'); END;\nCREATE TRIGGER IF NOT EXISTS lesson_note_tally_only_counts BEFORE UPDATE ON lesson_note_tally\n  WHEN NEW.note IS NOT OLD.note OR NEW.month IS NOT OLD.month OR NEW.executions < OLD.executions OR NEW.failures < OLD.failures\n    OR NEW.mixed_failures < OLD.mixed_failures OR NEW.received_executions < OLD.received_executions OR NEW.received_failures < OLD.received_failures\n    OR NEW.unreported_checks < OLD.unreported_checks OR NEW.partial < OLD.partial\n  BEGIN SELECT RAISE(ABORT,'a tally only counts up'); END;\nCREATE TRIGGER IF NOT EXISTS lesson_note_tally_no_delete BEFORE DELETE ON lesson_note_tally BEGIN SELECT RAISE(ABORT,'tallies are never pruned'); END;\nCREATE TRIGGER IF NOT EXISTS memory_use_no_update BEFORE UPDATE ON memory_use BEGIN SELECT RAISE(ABORT,'memory use is recorded once'); END;\nCREATE TRIGGER IF NOT EXISTS memory_use_no_delete BEFORE DELETE ON memory_use BEGIN SELECT RAISE(ABORT,'memory use is kept'); END;\nCREATE TRIGGER IF NOT EXISTS memory_tidy_proposal_only_decides BEFORE UPDATE ON memory_tidy_proposal\n  WHEN NEW.id IS NOT OLD.id OR NEW.repo IS NOT OLD.repo OR NEW.kind IS NOT OLD.kind OR NEW.items_json IS NOT OLD.items_json\n    OR NEW.after_text IS NOT OLD.after_text OR NEW.rationale IS NOT OLD.rationale OR NEW.evidence_json IS NOT OLD.evidence_json\n    OR NEW.source IS NOT OLD.source OR NEW.created_at IS NOT OLD.created_at OR OLD.status <> 'pending'\n  BEGIN SELECT RAISE(ABORT,'a tidy-up proposal is decided once'); END;\nCREATE TRIGGER IF NOT EXISTS memory_tidy_proposal_no_delete BEFORE DELETE ON memory_tidy_proposal BEGIN SELECT RAISE(ABORT,'tidy-up proposals are kept'); END;\nCREATE TRIGGER IF NOT EXISTS decision_merge_only_undone BEFORE UPDATE ON decision_merge\n  WHEN NEW.merge IS NOT OLD.merge OR NEW.successor IS NOT OLD.successor OR NEW.successor_revision IS NOT OLD.successor_revision\n    OR NEW.predecessor IS NOT OLD.predecessor OR NEW.predecessor_revision IS NOT OLD.predecessor_revision OR NEW.at IS NOT OLD.at\n    OR NEW.by IS NOT OLD.by OR OLD.undone_at IS NOT NULL\n  BEGIN SELECT RAISE(ABORT,'a merge is undone once, never rewritten'); END;\nCREATE TRIGGER IF NOT EXISTS decision_merge_no_delete BEFORE DELETE ON decision_merge BEGIN SELECT RAISE(ABORT,'merges are kept'); END;\n";
+/** The tables V149_SCHEMA adds, in the order a test drops them to make the v148 shape (dependents first). */
+export declare const V149_TABLES: readonly ["check_result", "check_fact", "local_observation", "ci_flaky_observation", "ci_pairing_rejected", "learning_watch", "lesson_note_tally", "lesson_note", "memory_use", "memory_tidy_proposal", "decision_merge"];
+/** The v149 tables a whole-project deletion clears by repo (the rest hang off these or a deleted run or decision). */
+export declare const V149_REPO_TABLES: readonly ["check_fact", "local_observation", "ci_flaky_observation", "learning_watch", "lesson_note", "memory_use", "memory_tidy_proposal"];
+/** The v149 migration's steps after v148's, in order (OpenOptions.migrationStep may stop after each). */
+export declare const V149_STEPS: readonly ["learning-tables"];
+/**
+ * v150 (machine-identity.ts): which computer a process witness belongs to, by the machine's stable id rather than its
+ * network hostname (which follows the network on a Mac with no HostName set). machine_host_alias records each
+ * hostname this machine read while it knew its own id, written only by a process on that machine, beside the id it
+ * read; a witness with no id (every saved one) is this machine's when its host is one of them. Never read for any
+ * other machine's id.
+ */
+export declare const V150_SCHEMA = "\nCREATE TABLE IF NOT EXISTS machine_host_alias (\n  machine_id    TEXT NOT NULL CHECK (length(machine_id) = 32),\n  host          TEXT NOT NULL CHECK (host <> ''),\n  first_seen_at TEXT NOT NULL,\n  PRIMARY KEY (machine_id, host)\n);\n";
+/** The tables V150_SCHEMA adds. */
+export declare const V150_TABLES: readonly ["machine_host_alias"];
+/** v150: a process witness's machine id (saved witnesses read NULL: matched by host name, as before). */
+export declare const V150_ADDED_COLUMNS: Readonly<Record<string, Readonly<Record<string, {
+    definition: string;
+    saved: string;
+}>>>>;
+/** The v150 migration's steps after v149's, in order (OpenOptions.migrationStep may stop after each). */
+export declare const V150_STEPS: readonly ["machine-aliases", "witness-machine"];
+/** The v151 migration's steps after v150's, in order (OpenOptions.migrationStep may stop after each). */
+export declare const V151_STEPS: readonly ["checkout-idle"];
+/** The v152 migration's steps after v151's, in order (OpenOptions.migrationStep may stop after each). */
+export declare const V152_STEPS: readonly ["code-map-tables", "code-map-switch", "code-map-watermark"];
+/** v153 (plain-toolroll.md Phase 2): the tables each slice owns. */
+export declare const V153_SCHEMA: string;
+/** The v153 migration's steps after v152's, in order (OpenOptions.migrationStep may stop after each). */
+export declare const V153_STEPS: readonly ["plain-tables", "plain-columns"];
+/** The v154 migration's steps after v153's, in order (OpenOptions.migrationStep may stop after each). */
+export declare const V154_STEPS: readonly ["check-stamps"];
 /**
  * v135: one approval per release (docs/plans/release-once.md). `release_authority` is the single source of truth for a
  * release a person approved: one row per generation, changed only by compare-and-swap on `rev`, with a lease whose
@@ -6873,17 +6939,14 @@ export declare class Store {
      * what kind of answer it is (needs-you.ts reads it): `alive` while
      * something of the run may still be running, `elsewhere` when only
      * another computer can tell, `unprovable` when nothing is known to run
-     * but its exit was never recorded, `unknown` when this computer can't
-     * check at all (both are what `run settle` resolves; only the first may
-     * be called not running). `settling` already meets the automatic
-     * reconciliation proof, so no confirmation is needed. */
-    stopQuiescenceFact(runId: number): {
-        run: number;
-        kind: StopFactKind;
-        problem: string;
-    } | null;
-    /** `run settle` recorded an approver's word that a run whose workspace
-     * note couldn't be read has stopped. */
+     * but its exit was never recorded (Toolroll's own look, stop-proof.ts,
+     * settles it), `unknown` when this computer can't check, or that look
+     * was blocked. `settling` already meets the automatic reconciliation
+     * proof. Nobody is ever asked to confirm a build stopped. `cause` names
+     * what stop-proof.ts can prove. */
+    stopQuiescenceFact(runId: number): StopFact | null;
+    /** A run whose workspace note couldn't be read was proven free: by Toolroll's own look (stop-proof.ts), or, in
+     * ledgers from before it, by an approver's recorded word (still read, never written now). */
     private workspaceConfirmedByApprover;
     reserveRunProcess(runId: number, now: Date, group?: boolean): number;
     /** The run's process witnesses not yet proved exited — after first saving whatever exit evidence is available. */
@@ -6915,29 +6978,12 @@ export declare class Store {
      * here, every other witness of the run has exited and none of the run's
      * process groups is alive, it settles as never started, with a ledger
      * entry. A sole pid-less witness has no group to prove gone and stays for
-     * `run settle`. Native witnesses keep their OS-only road. */
+     * Toolroll's own look (stop-proof.ts). Native witnesses keep their OS-only road. */
     settleUnspawnedWitnesses(now: Date, onlyRun?: number): number;
     /** The existing automatic settlement proof, shared with its read-only
      * status. Unknown-only, foreign, native and still-running custody keep
      * their fences; only an observed single-process exit avoids a new probe. */
     private settleableUnspawnedWitnesses;
-    /** `run settle` (an approver's last resort): every witness of a finished
-     * run that cannot be proven either way is recorded settled under the
-     * approver's reason, in the ledger. Refuses while anything of the run is
-     * alive or could be checked only from another host. Never signals. */
-    settleRunWitnessesByApprover(args: {
-        runId: number;
-        by: string;
-        why: string;
-    }, now: Date): {
-        ok: true;
-        witnesses: number[];
-        repeated: boolean;
-    } | {
-        ok: false;
-        reason: "unknown-run" | "still-running" | "alive";
-        detail: string;
-    };
     recordRunProcess(runId: number, pid: number, now: Date, group?: boolean, witness?: number): void;
     /** The native OS object a witnessed spawn ran inside (v53) — recorded
      * with the spawn, before the target can execute. */
@@ -7409,7 +7455,8 @@ export declare class Store {
     stampRunCheckAccess(runId: number, level: CheckAccess, network?: NetworkProfile | null): void;
     /** The network a run's sign-ins checks ran under (null: none sealed; such a run's later checks run sandboxed). */
     runCheckNetwork(runId: number): NetworkProfile | null;
-    /** The level a run's checks ran at: missing or unreadable reads as sandboxed. */
+    /** The level a later check of this run may run at, at most: missing or unreadable reads as sandboxed, the narrowest.
+     * Never an account of how its checks DID run: that is runCheckStamp (check-stamp.ts). */
     runCheckAccess(runId: number): CheckAccess;
     /** A project's check access changed: saved, and in the ledger as before → after. `may` is what the caller proved:
      * "widen" only after an instance operator's password typed now; anything else may only narrow. The level is read again
@@ -8275,6 +8322,12 @@ export type ReleaseProgress = {
         message: string;
         at: string;
     } | null;
+    /** The release's task moved on since its last recorded failure: this build started after it and is running now, so
+     * the release isn't stopped there, even though `toolroll release` hasn't recorded a step since. */
+    building: {
+        run: number;
+        startedAt: string;
+    } | null;
 };
 /** What a release coordinator says about one step. */
 export type ReleaseStepEntry = {
@@ -8294,7 +8347,8 @@ export type ReleaseStepEntry = {
  */
 export declare function recordReleaseStep(store: Store, entry: ReleaseStepEntry): void;
 /** A release's steps, for the release task: the newest tag recorded for it, its steps in the order they ran, and the
- * step it stopped at when the last thing recorded was a failure. Null: no step recorded. */
+ * step it stopped at when the last thing recorded was a failure and no build of the task has started since. Null: no
+ * step recorded. */
 export declare function releaseProgressFor(store: Store, taskId: string): ReleaseProgress | null;
 /** The release task whose steps were recorded most recently (v146), or null when none was. */
 export declare function latestReleaseStepTask(store: Store): string | null;
@@ -8400,3 +8454,63 @@ export declare function recordLaptopPort(store: Store, port: number, now: Date):
  * results-routing rows go (route-store.ts forgetProjectRoutes). One of the routing scan's named phase_* writers
  * (route-hooks.ts). How many rows went. */
 export declare function forgetProjectModels(store: Store, repo: string, now: Date): number;
+/** The ledger words of Toolroll's own stop proof. Nobody is asked to vouch that a build stopped: Toolroll looks at
+ * this computer's processes itself, and a person's older recorded word (`run settle` before this) is still read. */
+export declare const STOP_PROOF_SETTLED = "run stop proven automatically";
+export declare const STOP_PROOF_BLOCKED = "automatic stop check blocked";
+export declare const STOP_PROOF_WORKSPACE_FREE = "workspace proven free automatically";
+/** Why Toolroll's own stop check is blocked for a run, in words that follow "run #N " (the stop fact's problem), or
+ * null when its newest word is not a block (never checked, or proven since). */
+export declare function stopProofVerdictOf(store: Store, runId: number): string | null;
+/** Record that Toolroll's own stop check could not prove a run stopped (`words` follow "run #N "; `detail` is the
+ * evidence). The same block twice in a row is recorded once. True when recorded. */
+export declare function recordStopProofBlocked(store: Store, runId: number, words: string, detail: string, now: Date): boolean;
+/**
+ * Settle a finished run's unproven stop on Toolroll's own observation of this computer (stop-proof.ts): the caller
+ * looked at every process here and found none of the run's. Applies only while the run's stop is still unproven for
+ * exactly `cause` (re-read in this transaction): a pid-less spawn witness is recorded ended, a run with no witness gets
+ * one ended witness, an unreadable workspace note is recorded proven free. The evidence goes in the ledger. Never
+ * signals. True when this call settled it.
+ */
+export declare function settleRunStopByObservation(store: Store, args: {
+    runId: number;
+    cause: StopProofCause;
+    evidence: string;
+}, now: Date): boolean;
+/**
+ * This machine as the store knows it (v150, machine-identity.ts): its stable id and every name it is known by, the
+ * hostnames recorded beside its own id included. Read fresh each time, so a name recorded by another process on this
+ * machine counts at once.
+ */
+export declare function storeMachine(db: Database): ThisMachine;
+/** Load this machine's recorded names for the checks that hold no store; a store that can't read them loads none. */
+export declare function rememberStoredHostAliases(db: Database): void;
+/** Record the names this machine is known by right now beside its own id, read here at this moment (never a name a
+ * witness, a note or another computer supplied). Nothing when this machine's id is unknown. */
+export declare function recordMachineHostAliases(db: Database, now: Date): void;
+/** Whether a run_process row is this machine's (machine-identity.ts isThisMachine). */
+export declare function witnessIsLocal(row: Record<string, unknown>, here: ThisMachine): boolean;
+/** The same rule as witnessIsLocal, as SQL over run_process (optionally aliased): its id is ours, or it has none and
+ * its host is one of our names. With our id unknown, `machine_id = NULL` matches nothing: an id-bearing witness is
+ * never taken for ours. */
+export declare function localWitnessSql(db: Database, alias?: string): {
+    sql: string;
+    params: (string | null)[];
+};
+/** Whether this database has v150's run_process.machine_id. An update settles leftover records on the database it is
+ * about to back up, still at the older schema (toolroll-update.ts drain), so no query it reaches may assume the column:
+ * there every witness has no id, and the host-name rule above is the whole rule. */
+export declare function witnessesCarryMachine(db: Database): boolean;
+/** Settings → Storage: how long a task stays idle before its clean folder goes (the default until someone chooses). */
+export declare function checkoutIdle(store: Store): CheckoutIdle;
+/** Choose how long a task stays idle before its clean folder goes; the ledger keeps before → after. */
+export declare function setCheckoutIdle(store: Store, idle: CheckoutIdle, by: string, now: Date): CheckoutIdle;
+/** A check launch's execution stamp (check-stamp.ts), written by the code that launched it. One row per distinct launch. */
+export declare function recordCheckStamp(store: Store, runId: number, stamp: CheckStamp, now: Date): void;
+/** How a run's checks actually ran, by every launch it stamped: `unknown` when none is there or one can't be read. */
+export declare function runCheckStamp(store: Store, runId: number): StampReading;
+/** The newest run of a task whose checks ran (it saved a check log), and how they ran; null when none has. */
+export declare function taskCheckStamp(store: Store, repo: string, taskId: string): {
+    runId: number;
+    reading: StampReading;
+} | null;