toolroll 0.9.85 → 0.9.87

package/dist/storage-ui.js

@@ -1,42 +1,28 @@
 /**
- * Settings → Storage: how much space task checkouts use, what a clean-up would free now, a Clean up button whose
- * preview (what goes, what stays and why, with paths) sits 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.
+ * Settings → Storage: how much space task checkouts use, what a clean-up would free now, 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.
  */
 import { homedir } from "node:os";
 import { basename } from "node:path";
-import { html, postForm, reauth } from "./html.js";
+import { html, joinHtml } from "./html.js";
 import { previewDigest, whyWords } from "./checkout-cleanup.js";
 import { CLEANUP_CHOICES, bytesWords } 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";
+import { kitSectionForm } from "./settings-kit.js";
 const plural = (count, one, many = `${one}s`) => `${count} ${count === 1 ? one : many}`;
-export const STORAGE_CSS = `.storage{max-width:720px;min-width:0;overflow-wrap:anywhere}.storage h2{font-size:1.0625rem;margin:24px 0 4px}` +
-    `.storage .storage-state{display:grid;gap:12px}.storage .storage-state h2{margin:0}.storage .storage-state p{margin:0}` +
-    `.storage details.clean-up,.storage details.discard{border:0;padding:0;margin:0;background:transparent}` +
-    `.storage details.clean-up>summary{list-style:none;display:inline-flex;align-items:center;min-height:2.125rem;padding:.35rem .75rem;border-radius:calc(var(--radius) - 3px);` +
-    `background:var(--primary);color:var(--primary-foreground);font-weight:600;font-size:.8125rem;cursor:pointer;white-space:nowrap}` +
-    `.storage details.clean-up>summary::-webkit-details-marker{display:none}.storage details.clean-up[open]>summary{background:var(--card);color:var(--foreground);border:1px solid var(--input)}` +
-    `.storage .preview{display:grid;gap:12px;margin-top:12px;padding-top:12px;border-top:1px solid var(--border)}.storage .preview h3{font-size:.875rem;margin:0}` +
-    `.storage ul.checkouts{list-style:none;padding:0;margin:0}` +
-    `.storage ul.checkouts li{display:grid;grid-template-columns:minmax(0,1fr) auto;gap:2px 12px;padding:8px 0;border-top:1px solid var(--border);font-size:.8125rem}` +
-    `.storage ul.checkouts .name{font-weight:500;min-width:0}.storage ul.checkouts .size{font-variant-numeric:tabular-nums;white-space:nowrap}` +
-    `.storage ul.checkouts .path{grid-column:1/-1;font-family:var(--font-mono, ui-monospace, monospace);font-size:.6875rem;color:var(--muted-foreground);word-break:break-all}` +
-    `.storage ul.checkouts .why{grid-column:1/-1}` +
-    `.storage details.discard{grid-column:1/-1}.storage details.discard>summary{cursor:pointer;color:var(--destructive);min-height:2.25rem;display:inline-flex;align-items:center}` +
-    `.storage form{display:grid;gap:10px;margin:0}.storage label{display:grid;gap:4px;font-size:.8125rem;font-weight:500;max-width:20rem}` +
-    `.storage select,.storage input[type=password]{width:100%;box-sizing:border-box;min-height:2.125rem}.storage form button{justify-self:start;white-space:nowrap}` +
-    `.storage form.setting button[type=submit],.storage .preview form.remove button[type=submit]{background:var(--primary);color:var(--primary-foreground);border-color:var(--primary);font-weight:600}` +
-    `.storage .sweep{display:grid;gap:4px}.storage .sweep p{margin:0}.storage .sweep .problem{color:var(--destructive)}` +
-    `.storage details.sweep-details>summary{cursor:pointer;min-height:2.25rem;display:inline-flex;align-items:center;font-size:.8125rem;color:var(--muted-foreground)}` +
-    `.storage details.landed>summary{cursor:pointer;min-height:2.25rem;display:inline-flex;align-items:center;font-size:.8125rem;color:var(--muted-foreground)}` +
-    `.storage details.landed .landed-body{display:grid;gap:6px;margin-top:4px;font-size:.8125rem}.storage details.landed p{margin:0}` +
-    `.storage details.landed ul{margin:0;padding-left:18px;overflow-wrap:anywhere}.storage details.landed .target{font-family:var(--font-mono, ui-monospace, monospace);font-size:.6875rem}` +
-    `.storage details.landed code{font-family:var(--font-mono, ui-monospace, monospace);font-size:.75rem;overflow-wrap:anywhere}` +
-    `.storage details.sweep-details ul{margin:4px 0 0;padding-left:18px;font-family:var(--font-mono, ui-monospace, monospace);font-size:.6875rem;color:var(--muted-foreground);overflow-wrap:anywhere}` +
-    `@media (max-width:900px){.storage details.sweep-details>summary,.storage details.landed>summary{min-height:44px}.storage details.clean-up>summary,.storage form button{min-height:44px}.storage label{max-width:none}.storage select,.storage input[type=password]{min-height:44px;font-size:16px}.storage .preview form.remove button{width:100%}}`;
-/** Paths under the home folder as ~/…, as the checkout list shows them. */
+/** The page is kit pieces now; nothing of the old look is left. Kept as an export for the shared stylesheet. */
+export const STORAGE_CSS = "";
+/** A path under the home folder as ~/…. */
+function tilde(path) {
+    const home = homedir();
+    return home !== "" && home !== "/" && path.startsWith(`${home}/`) ? `~${path.slice(home.length)}` : path;
+}
+/** Paths under the home folder as ~/… anywhere in a line, as the checkout list shows them. */
 function homeAsTilde(line) {
     const home = homedir();
     return home === "" || home === "/" ? line : line.split(`${home}/`).join("~/");
@@ -49,41 +35,61 @@ function whenWords(at) {
 /** When the last sweep ran and what it did, then why the next one waits or when it is due; paths and problems behind Details. */
 function sweepHtml(sweep) {
     const last = sweep.last;
-    const schedule = sweep.schedule === undefined ? (sweep.off ? html `<p class="meta" data-sweep-state="off">Automatic sweep: off.</p>` : "")
-        : html `<p class="meta" data-sweep-state="${sweep.schedule.state}">Automatic sweep: ${sweepScheduleWords(sweep.schedule, whenWords)}</p>`;
+    const schedule = sweep.schedule === undefined ? (sweep.off ? html `<p class="k-note" data-sweep-state="off">Automatic sweep: off.</p>` : "")
+        : html `<p class="k-note" data-sweep-state="${sweep.schedule.state}">Automatic sweep: ${sweepScheduleWords(sweep.schedule, whenWords)}</p>`;
     if (last === null)
-        return html `<div class="sweep" data-last-sweep=""><p>Not swept yet.</p>${schedule}</div>`;
+        return html `<div data-last-sweep="">${note("Not swept yet.")}${schedule}</div>`;
     const who = last.source === "manual" ? `Cleaned up by ${last.actor}` : "Swept";
     const details = sweepDetails(last.parts);
     const problem = last.parts.some(one => one.failed > 0 || one.problem !== undefined);
-    return html `<div class="sweep" data-last-sweep="${last.at}"><p${problem ? html ` class="problem"` : ""}>${who} <time datetime="${last.at}">${whenWords(last.at)}</time>. ${sweepWords(last.parts)}</p>${schedule}${details.length === 0 ? "" : html `<details class="sweep-details"><summary>Details</summary><ul>${details.map(line => html `<li>${homeAsTilde(line)}</li>`)}</ul></details>`}</div>`;
+    const said = html `${who} <time datetime="${last.at}">${whenWords(last.at)}</time>. ${sweepWords(last.parts)}`;
+    return html `<div data-last-sweep="${last.at}">${problem ? html `<p class="k-notice" role="alert">${icon("alert", true)}<span>${said}</span></p>` : note(said)}${schedule}${details.length === 0 ? "" : disclose("Details", joinHtml(details.map(line => codeLine(homeAsTilde(line)))))}</div>`;
 }
 /** 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 home = homedir();
     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.`;
-    const waiting = landed.waiting.length === 0 ? "" : html `<p>Waiting (${landed.waiting.length}):</p><ul data-landed-waiting>${landed.waiting.map(one => html `<li><span class="target">${home !== "" && one.target.startsWith(`${home}/`) ? `~${one.target.slice(home.length)}` : one.target}</span>${one.why === null ? "" : html `: ${one.why}`}</li>`)}</ul>`;
-    return html `<details class="landed" data-landed><summary>Landed work</summary><div class="landed-body"><p>${done}</p>${waiting}<p class="meta">For work that landed before this: <code>toolroll storage clean --landed</code> shows what would go; add <code>--yes</code> to do it.</p></div></details>`;
+    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. */
 function item(one) {
+    const why = one.why === null ? "" : `${whyWords(one)[0].toUpperCase()}${whyWords(one).slice(1)}`;
     const discard = one.why === "has changes"
-        ? html `<details class="discard"><summary>Discard</summary>${postForm("/settings/storage/discard", html `<p class="meta">Throws away this checkout and its uncommitted changes. Its branch stays.</p>${reauth(html `<label>Your Toolroll password<input type="password" name="password" autocomplete="current-password" required></label>`)}<button type="submit" class="danger">Discard changes</button>`, { hidden: { path: one.path } })}</details>`
+        ? 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.") }))
         : "";
-    // The task it was for, then where it is (the home folder as ~), then why it stays.
-    const home = homedir();
-    const where = home !== "" && one.path.startsWith(`${home}/`) ? `~${one.path.slice(home.length)}` : one.path;
-    return html `<li data-checkout="${one.path}"><span class="name">${one.taskId ?? basename(one.path)}</span><span class="size">${bytesWords(one.bytes)}</span><span class="path">${where}</span>${one.why === null ? "" : html `<span class="why">${whyWords(one)[0].toUpperCase() + whyWords(one).slice(1)}</span>`}${discard}</li>`;
+    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 });
 }
-export function storageHtml(view, notice) {
+/** A short id for a checkout's form, from its path. */
+const previewId = (path) => path.replace(/[^a-z0-9]+/gi, "-").replace(/^-|-$/g, "").slice(-48) || "checkout";
+export function storageHtml(view, said) {
     const { plan } = view;
-    const note = notice.problem ? html `<p class="problem" role="alert">${notice.problem}</p>` : notice.said ? html `<p role="status">${notice.said}</p>` : "";
     const facts = [plural(plan.count, "checkout"), `${plan.waitingReview} waiting for review`, `${plan.withChanges} kept for their changes`].join(" · ");
     const frees = plan.go.length === 0 ? "Nothing to clean up now." : `Cleaning up now frees about ${bytesWords(plan.freeBytes)}.`;
-    const remove = plan.go.length === 0 ? "" :
-        postForm("/settings/storage/clean", html `${reauth(html `<label>Your Toolroll password<input type="password" name="password" autocomplete="current-password" required></label>`)}<button type="submit">Remove ${plural(plan.go.length, "checkout")}</button>`, { attrs: { class: "remove" }, hidden: { preview: previewDigest(plan) } });
-    const preview = html `<details class="clean-up" data-clean-up${notice.problem?.startsWith("Enter your Toolroll password to clean") ? html ` open` : ""}><summary>Clean up</summary><div class="preview">${plan.go.length === 0 ? html `<p>Nothing to remove now.</p>` :
-        html `<h3>Removes ${plural(plan.go.length, "checkout")}, about ${bytesWords(plan.freeBytes)}</h3><p class="meta">Their branches stay, so nothing committed is lost.</p><ul class="checkouts" data-goes>${plan.go.map(one => item(one))}</ul>`}${plan.stay.length === 0 ? "" : html `<h3>Stays (${plan.stay.length})</h3><ul class="checkouts" data-stays>${plan.stay.map(one => item(one))}</ul>`}${remove}</div></details>`;
-    const options = CLEANUP_CHOICES.map(one => html `<option value="${one.value}"${one.value === plan.cleanup ? html ` selected` : ""}>${one.label}</option>`);
-    return html `<section class="storage">${note}<div class="card storage-state"><h2 data-checkout-bytes="${plan.totalBytes}">Checkouts use ${bytesWords(plan.totalBytes)}</h2><p class="meta">${facts}</p>${view.measured ?? ""}<p data-clean-bytes="${plan.freeBytes}">${frees}</p>${view.sweep === undefined ? "" : sweepHtml(view.sweep)}${view.landed === undefined ? "" : landedHtml(view.landed)}${preview}</div><h2>Automatic cleanup</h2>${postForm("/settings/storage", html `<label>Remove a finished task's clean checkout<select name="cleanup">${options}</select></label><p class="meta">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.</p>${reauth(html `<label>Your Toolroll password<input type="password" name="password" autocomplete="current-password" required></label>`)}<button type="submit">Save</button>`, { attrs: { class: "setting" } })}</section>`;
+    const checkouts = settingsSection({ id: "checkouts", title: `Checkouts 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>`,
+            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 `` });
+    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 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.`,
+        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.",
+        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]);
 }

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";
+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";
 import { isLifecycleNotification, isTelegramProgressNotification, LIFECYCLE_KEY_PREFIX, LIFECYCLE_KINDS, proposalTaskOf, type LifecycleKind } from "./notification-rows.js";
@@ -232,7 +233,7 @@ export type SealedLedgerEntry = LedgerEntry & {
         hash: string;
     } | null;
 };
-export declare const SCHEMA_VERSION = 143;
+export declare const SCHEMA_VERSION = 146;
 /** 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>>;
 /**
@@ -394,6 +395,22 @@ export declare const V143_ADDED_COLUMNS: Readonly<Record<string, Readonly<Record
     definition: string;
     saved: string;
 }>>>>;
+/** v145 (docs/plans/task-tidy.md): `task_archive` is a put-away task version. A row hides it from every list and count
+ * and refuses every door that would dispatch, claim or approve it; restore deletes the row. Its history, results,
+ * approvals and ledger stay exactly as they were. `merge_in_flight` is a direct merge between its last check and GitHub's
+ * answer, owned by its token: a task can't be put away under it (a row older than 15 minutes is a crash, and no
+ * longer counts). `deploy_in_flight` is a deployment whose candidate passed its gate (30 minutes, refreshed by every
+ * phase that proves it again). `flow_step_task` is the tasks a flow step was admitted for, kept whatever the card does
+ * next, so a step still running holds them. `branch_check_run` keeps each completed GitHub workflow run (pushed to
+ * the watched branch of the watched repository) the "checks failed" trigger saw, green or red, so tidy can tell a
+ * failure notice was fixed by a later commit. */
+export declare const V145_SCHEMA = "\nCREATE TABLE IF NOT EXISTS task_archive (\n  task_ref INTEGER PRIMARY KEY REFERENCES task_ref(id),\n  by       TEXT NOT NULL,\n  by_kind  TEXT NOT NULL CHECK (by_kind IN ('person','tidy')),\n  rule     TEXT,\n  reason   TEXT NOT NULL,\n  at       TEXT NOT NULL\n);\nCREATE TABLE IF NOT EXISTS branch_check_run (\n  repo           TEXT NOT NULL,\n  run_id         INTEGER NOT NULL,\n  branch         TEXT NOT NULL,\n  workflow       TEXT NOT NULL,\n  head_sha       TEXT NOT NULL,\n  conclusion     TEXT NOT NULL CHECK (conclusion IN ('success','failure')),\n  run_created_at TEXT NOT NULL,\n  observed_at    TEXT NOT NULL,\n  PRIMARY KEY (repo, run_id)\n);\nCREATE INDEX IF NOT EXISTS branch_check_run_by_workflow ON branch_check_run (repo, branch, workflow, run_created_at);\nCREATE TABLE IF NOT EXISTS merge_in_flight (\n  publication INTEGER PRIMARY KEY REFERENCES publication(id),\n  task_ref    INTEGER NOT NULL REFERENCES task_ref(id),\n  token       TEXT NOT NULL,\n  by          TEXT NOT NULL,\n  at          TEXT NOT NULL\n);\nCREATE TABLE IF NOT EXISTS deploy_in_flight (\n  task_ref INTEGER PRIMARY KEY REFERENCES task_ref(id),\n  run      INTEGER NOT NULL,\n  at       TEXT NOT NULL\n);\nCREATE TABLE IF NOT EXISTS flow_step_task (\n  card    INTEGER NOT NULL,\n  entry   INTEGER NOT NULL,\n  task_id TEXT NOT NULL,\n  PRIMARY KEY (card, entry, task_id)\n);\n";
+/** v146: `ci_check` is one pull request check (a GitHub check run or commit status) as the plane's winning observation of
+ * that head read it: written only with the observation that won its generation, replacing that head's rows wholesale.
+ * `release_step` is one step of a release (release.ts RELEASE_STEPS) as `toolroll release` moved through it: when it
+ * started, when it ended and how; recording it never changes the release. Both are read-only history for the Ship and
+ * Release views and their CLI twins. */
+export declare const V146_SCHEMA = "\nCREATE TABLE IF NOT EXISTS ci_check (\n  github_repo  TEXT NOT NULL,\n  pr_number    INTEGER NOT NULL,\n  head_sha     TEXT NOT NULL,\n  -- A check's identity: its kind (check run or commit status), its workflow and its name, so two workflows' checks\n  -- with the same name stay two rows (a failing one never hides behind a passing namesake).\n  ident        TEXT NOT NULL,\n  name         TEXT NOT NULL,\n  workflow     TEXT,\n  state        TEXT NOT NULL CHECK (state IN ('queued','running','passed','failed','skipped','cancelled','neutral')),\n  started_at   TEXT,\n  completed_at TEXT,\n  url          TEXT,\n  observed_at  TEXT NOT NULL,\n  PRIMARY KEY (github_repo, pr_number, head_sha, ident)\n);\nCREATE TABLE IF NOT EXISTS release_step (\n  task_id    TEXT NOT NULL,\n  tag        TEXT NOT NULL,\n  version    TEXT NOT NULL,\n  pr         INTEGER,\n  step       TEXT NOT NULL,\n  state      TEXT NOT NULL CHECK (state IN ('running','done','failed','waiting')),\n  started_at TEXT NOT NULL,\n  ended_at   TEXT,\n  detail     TEXT,\n  updated_at TEXT NOT NULL,\n  PRIMARY KEY (task_id, tag, step)\n);\nCREATE INDEX IF NOT EXISTS release_step_by_task ON release_step (task_id, updated_at);\n";
 /**
  * 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
@@ -3745,7 +3762,7 @@ export declare class Store {
         rejectedRun: number | null;
     } | {
         ok: false;
-        reason: "unknown-task" | "not-stalled" | "claimed" | "accepted-result" | "published" | "moved";
+        reason: "unknown-task" | "not-stalled" | "claimed" | "accepted-result" | "published" | "moved" | "archived";
     };
     /**
      * Cancel, aware of who might be building right now. A live claim wins:
@@ -6072,8 +6089,13 @@ export declare class Store {
         file?: string | null;
         held?: string | null;
     }, now: Date): number;
-    /** A person approves a held script (one an imported flow brought): from now on it runs. False when it wasn't held. */
-    approveFlowScript(repo: string, name: string): boolean;
+    /** A person approves a held script (one an imported flow brought): from now on it runs. The approval covers exactly
+     * the version and content the person read (`seen`): the check and the release of the hold are one statement in one
+     * transaction, so a script removed and brought back under the same name is never approved unseen. */
+    approveFlowScript(repo: string, name: string, seen: {
+        version: number;
+        digest: string;
+    }): "approved" | "changed" | "not-held";
     removeFlowScript(repo: string, name: string, by?: string, now?: Date): boolean;
     /** Claim a card's visit to a step zone. False when another pass holds it or it already finished. */
     claimFlowStep(step: {
@@ -6892,7 +6914,7 @@ export declare class Store {
         stop: RunStop;
     } | {
         ok: false;
-        reason: "no-stop" | "wrong-task" | "stopping" | "already-resumed" | "superseded" | "busy" | "review";
+        reason: "no-stop" | "wrong-task" | "stopping" | "already-resumed" | "superseded" | "busy" | "review" | "archived";
         detail: string;
     };
     /** Every stop recorded on a task, newest request first. */
@@ -8064,3 +8086,158 @@ export declare function dropFeedbackImage(store: Store, runId: number, commentId
     ok: false;
     reason: "not-found" | "image-usable" | "not-authorized";
 };
+/** A put-away task version (v145, docs/plans/task-tidy.md). */
+export type TaskArchive = {
+    taskRef: number;
+    taskId: string;
+    by: string;
+    byKind: "person" | "tidy";
+    rule: string | null;
+    reason: string;
+    at: string;
+};
+/** Who put a task away, and why: a person by name, or tidy by its rule. */
+export type ArchiveBy = {
+    by: string;
+    byKind: "person" | "tidy";
+    rule: string | null;
+    reason: string;
+};
+export type ArchiveRefusal = "unknown-task" | "live" | "archived" | "not-archived" | "blocked";
+/** The put-away record of this task, or null when it is not put away. */
+export declare function archiveOf(store: Store, taskId: string): TaskArchive | null;
+/** Every version of a task's family, by the same proven lineage the task page reads (`taskFamilyOf`: same project, each
+ * revision bound to its parent's own run by its brief). A family whose lineage doesn't prove is just this task. */
+export declare function taskFamilyRefs(store: Store, taskId: string): {
+    id: number;
+    taskId: string;
+}[];
+/** The first family version with something still going on, or null: running, a live newest claim, an unfinished run,
+ * a process Toolroll hasn't seen exit, a build whose processes were never recorded, a stop still settling, a follow-up
+ * check asked for and not finished, a flow step running for its card, a release in flight (a live release approval
+ * that names it, or a deploy or merge reserved, running or unknown), or a pull request merging (an intent claimed or
+ * firing, or a person's merge between its last check and GitHub's answer). */
+export declare function liveFamilyAttempt(store: Store, refs: readonly number[], now: Date): string | null;
+/** Puts a task away (v145): every version of its family, in one write transaction that re-checks it has no live
+ * attempt, that its versions are exactly `expect` when the caller showed a person a family (a preview), and that
+ * `guard` (the caller's own rule, re-read under the lock) still allows it. Its state, history, results, approvals and
+ * ledger are untouched; its open notifications are resolved; one ledger row records who and why. */
+export declare function archiveTaskFamily(store: Store, taskId: string, by: ArchiveBy, now: Date, options?: {
+    expect?: readonly number[];
+    guard?: (refs: readonly number[]) => string | null;
+}): {
+    ok: true;
+    refs: number[];
+} | {
+    ok: false;
+    reason: ArchiveRefusal;
+    message: string;
+};
+/** Brings a put-away task back (v145): every version of its family, with a ledger row. Tidy never puts a restored
+ * task away again (tidy.ts reads the `task restored` row). */
+export declare function restoreTaskFamily(store: Store, taskId: string, by: string, now: Date, guard?: (refs: readonly number[]) => string | null): {
+    ok: true;
+    refs: number[];
+} | {
+    ok: false;
+    reason: ArchiveRefusal;
+    message: string;
+};
+/**
+ * What a LIVE invite grants, for its own join page (Wave E, "Your access"): the role, who invited, the projects and
+ * when it expires. Read without spending an attempt and under exactly inviteIsLive's predicate, so every dead shape
+ * reads as null and still gets the one indistinguishable page (D6). Only a holder of the live token sees it.
+ */
+export declare function liveInviteTerms(store: Store, tokenValue: string, now: Date): {
+    role: "approver" | "viewer";
+    mintedBy: string;
+    expiresAt: string;
+    projects: ProjectAccess;
+} | null;
+/** One pull request check as GitHub last reported it for the observed head (v146 ci_check). */
+/** `kind`: a check run or a commit status (part of the check's identity); a row built without it reads as a run when it
+ * names a workflow, else as a status. */
+export type CiCheckRow = {
+    name: string;
+    workflow: string | null;
+    state: "queued" | "running" | "passed" | "failed" | "skipped" | "cancelled" | "neutral";
+    startedAt: string | null;
+    completedAt: string | null;
+    url: string | null;
+    kind?: "run" | "status";
+};
+/** `observed`: the authoritative state of the same winning observation (ci_observation), which the overall status
+ * always comes from; the rows only show each check's own timing. */
+export type ShipChecks = {
+    githubRepo: string;
+    prNumber: number;
+    headSha: string;
+    observedAt: string;
+    observed: "passing" | "failing" | "running" | "none";
+    checks: CiCheckRow[];
+};
+/** At most this many checks are kept for one head; GitHub's rollup is far smaller in practice. */
+export declare const CI_CHECKS_MAX = 200;
+/**
+ * GitHub's statusCheckRollup (gh pr view --json statusCheckRollup) as check rows: CheckRun items (name, workflowName,
+ * status, conclusion, startedAt, completedAt, detailsUrl) and StatusContext items (context, state, startedAt, targetUrl).
+ * Strict: an item that is not one of those shapes, has no usable name, or names a state it doesn't know is dropped; one
+ * row per identity (kind, workflow and name), and when one identity appears twice (a re-run) the worse state stands;
+ * at most CI_CHECKS_MAX.
+ */
+export declare function parseCiRollup(rollup: unknown): CiCheckRow[];
+/**
+ * Replace one head's checks wholesale (v146). Call ONLY with an observation that won its generation (publish.ts settles
+ * and records in one transaction): a losing, stale answer never writes here.
+ */
+export declare function recordCiChecks(store: Store, githubRepo: string, prNumber: number, headSha: string, rows: readonly CiCheckRow[], now: Date): void;
+/** A pull request's checks for the head the plane's last winning observation recorded, or null when none was. */
+export declare function ciChecksFor(store: Store, githubRepo: string, prNumber: number): ShipChecks | null;
+/** A task's pull request checks: its family's newest publication that has a pull request number, and that pull
+ * request's checks (ciChecksFor). Null: no pull request, or none observed yet. */
+export declare function shipChecksForTask(store: Store, taskId: string): ShipChecks | null;
+/** One release step as `toolroll release` moved through it (v146 release_step). */
+export type ReleaseStepRow = {
+    step: string;
+    state: "running" | "done" | "failed" | "waiting";
+    startedAt: string;
+    endedAt: string | null;
+    detail: string | null;
+};
+export type ReleaseProgress = {
+    tag: string;
+    version: string;
+    pr: number | null;
+    startedAt: string;
+    updatedAt: string;
+    steps: ReleaseStepRow[];
+    stopped: {
+        step: string;
+        message: string;
+        at: string;
+    } | null;
+};
+/** What a release coordinator says about one step. */
+export type ReleaseStepEntry = {
+    taskId: string;
+    tag: string;
+    version: string;
+    pr: number | null;
+    step: string;
+    state: ReleaseStepRow["state"];
+    at: Date;
+    detail?: string | null;
+};
+/**
+ * Record a release step (v146): `running` or `waiting` opens it (its first start is kept), `done` or `failed` ends it.
+ * A step that runs again after a stop starts its row again. A failed write throws here; the release's adapter swallows
+ * it, so recording never changes a release.
+ */
+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. */
+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;
+/** Seconds a step or check took (to its end, or to `now` while it runs); null without a start. */
+export declare function elapsedSeconds(startedAt: string | null, endedAt: string | null, now: Date): number | null;