toolroll 0.9.93 → 0.9.95

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,9 @@ 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";
+import { V155_STEPS } from "./fleet-schema.js";
+import { V156_STEPS } from "./fallback-schema.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 +19,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 +33,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 +42,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";
@@ -243,7 +248,7 @@ export type SealedLedgerEntry = LedgerEntry & {
         hash: string;
     } | null;
 };
-export declare const SCHEMA_VERSION = 149;
+export declare const SCHEMA_VERSION = 156;
 /** 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>>;
 /**
@@ -435,7 +440,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] | (typeof V149_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] | (typeof V156_STEPS)[number] | (typeof V155_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
@@ -494,6 +499,35 @@ export declare const V149_TABLES: readonly ["check_result", "check_fact", "local
 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"];
+export { V155_STEPS };
+export { V156_STEPS };
 /**
  * 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
@@ -2537,8 +2571,10 @@ export declare class Store {
         modeDigest: string;
         /** A chat seal of a deploy gate: the release card it came from (chat-management.md §0a.5). A chat seal of a task
          * filed from outside text: `terms`, and the digest of every word the card showed (chat-terms.ts). */
-        card?: "release" | "terms";
+        card?: "release" | "terms" | "shown";
         cardDigest?: string;
+        /** `shown`: the exact words a card showed whole, whose digest (kept when it was made) is `cardDigest`. */
+        shownTerms?: string;
     }, approverKind?: ApproverKind): boolean;
     /** Whether this task's scope carries a LIVE seal: approved, and the
      * approved digest is the current one (a rewritten scope unseals). The
@@ -4200,7 +4236,8 @@ export declare class Store {
      *     phase's exact leg. A planner may also run under the working
      *     proposed route, or — with no scope yet — the live recommendation,
      *     re-derived here from durable state. Nothing else.
-     *   fallback — never (fallback chains were removed in v115).
+     *   fallback — the walk's current entry of the sealed chain, exactly
+     *     (fallback.ts), and nothing else.
      *   legacy — only a row proven to predate routing or a task with no
      *     scope; never a routed row.
      */
@@ -7425,7 +7462,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
@@ -8291,6 +8329,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 = {
@@ -8310,7 +8354,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;
@@ -8439,3 +8484,40 @@ export declare function settleRunStopByObservation(store: Store, args: {
     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;