toolroll 0.9.85 → 0.9.87

package/dist/surface.js

@@ -165,13 +165,17 @@ const GUIDE_ROWS = [
         positionals: [{ name: "task", required: true, meaning: "any version of the task" }],
         flags: [jsonFlag, dbFlag, { name: "level", takesValue: true, meaning: "quick (default) or full" }],
         notableReasons: ["no-result", "no-check", "checks-failed"] },
+    { invocation: "task ship", synopsis: "the task's pull request checks as last observed for its head: each check's state and how long it took",
+        audience: "agent", agentMayInvoke: true, mutation: "none",
+        positionals: [{ name: "task", required: true, meaning: "any version of the task" }], flags: [jsonFlag, dbFlag],
+        notableReasons: ["unknown-task", "no-pull-request"] },
     { invocation: "task add-tests", synopsis: "file a small task to write tests for the task's latest change; it waits for approval like any task",
         audience: "agent", agentMayInvoke: true, mutation: "identity-idempotent",
         positionals: [{ name: "task", required: true, meaning: "any version of the task" }], flags: [jsonFlag, dbFlag],
         notableReasons: ["no-result"] },
     { invocation: "task list", synopsis: "a page of saved task status", audience: "agent", agentMayInvoke: true, mutation: "none",
         flags: [jsonFlag, dbFlag, { name: "state", takesValue: true, meaning: "queued|running|done|failed|cancelled" },
-            { name: "view", takesValue: true, meaning: "all|needs-you|running|completed" },
+            { name: "view", takesValue: true, meaning: "all|needs-you|running|completed|archived" },
             { name: "limit", takesValue: true, meaning: "page size, 1–100; default 40" },
             { name: "cursor", takesValue: true, meaning: "nextCursor from the previous response" },
             { name: "repo", takesValue: true, meaning: "filter to one project" }] },
@@ -299,6 +303,18 @@ const GUIDE_ROWS = [
     operator("task route", "which configured agents plan, build and repair this task; phase and size changes require renewed approval"),
     operator("task reopen", "resume external work its tracker closed and has been SEEN open again"),
     operator("task stop", "stop ONE exact live attempt (--run <id>): durable before any process is signalled, answers 'stopping' until its own processes are established gone; work, branch, and evidence preserved; no strike, no retry"),
+    { ...operator("task archive", "put tasks away (a person's act): out of every list, count and nudge, history and approvals kept; nothing claims, approves or dispatches them until restored"),
+        positionals: [{ name: "id", required: true, meaning: "one or more tasks (any version: the whole family goes)" }],
+        flags: [jsonFlag, dbFlag, { name: "reason", takesValue: true, meaning: "why, shown on the task page" }], notableReasons: ["unknown-task", "not-an-approver"] },
+    { ...operator("task restore", "bring put-away tasks back exactly as they were (a person's act)"),
+        positionals: [{ name: "id", required: true, meaning: "one or more put-away tasks" }], flags: [jsonFlag, dbFlag], notableReasons: ["unknown-task", "not-an-approver"] },
+    { ...operator("task tidy", "Put away old tasks: --preview lists what would go and why (read-only), --apply --digest <d> puts away exactly that list (a person's act)"),
+        flags: [jsonFlag, dbFlag, { name: "preview", takesValue: false, meaning: "show the list and the digest; changes nothing" },
+            { name: "apply", takesValue: false, meaning: "put away exactly the previewed list (needs --digest)" },
+            { name: "digest", takesValue: true, meaning: "the digest --preview printed" },
+            { name: "days", takesValue: true, meaning: "also finished tasks untouched this many days (1–365, default 14)" },
+            { name: "except", takesValue: true, meaning: "comma-separated tasks from the list to leave out" }],
+        notableReasons: ["usage", "not-an-approver", "empty"] },
     operator("run settle", "last resort for a finished run whose process witness can't be proven either way: records your --why in the ledger; refuses while any of the run's processes is alive"),
     operator("task resume", "resume the exact stopped attempt (--run <id>): refuses until it is quiescent, lifts only that stop's hold, approves nothing — the next pass re-proves the scope and inherits the draft with fresh proof"),
     // ---- leases (runner surface) ----
@@ -443,11 +459,15 @@ const REMOTE_NO = [
     "enroll", "revoke",
     // Flow steps that fetch addresses or run checks and scripts here.
     "flows import", "flows trigger check", "flows script save",
+    // Lets a flow script on this machine start Chromium in its sandbox: a person here, with their own password.
+    "flows browser",
     // Reads this machine owner's own Claude and Codex session files (~/.claude, ~/.codex).
     "memory propose",
 ];
 const REMOTE_STEP_UP = [
-    "proposals", "decide", "task regate", "task approve", "task accept", "task merge", "run settle", "knowledge apply", "memory apply",
+    "proposals", "decide", "task regate", "task approve", "task accept", "task merge", "run settle",
+    // Putting tasks away and restoring them: a person's act, in the console or on the server's machine.
+    "task archive", "task restore", "task tidy", "knowledge apply", "memory apply",
     "flows card approve", "flows card send-back", "flows script approve", "flows unattended",
     "approver list", "approver add", "people list", "people invite", "people projects", "people revoke",
     // A person's own API tokens: a password step-up on the server's machine, or the console. Never with a token.
@@ -457,7 +477,7 @@ const REMOTE_STEP_UP = [
 ];
 const REMOTE_YES = [
     "status", "integrations", "ready", "gaps", "grants", "sync", "audit",
-    "task add", "task ask", "task checks", "task add-tests", "task list", "task show", "check-progress", "task wait", "task complete", "task revise",
+    "task add", "task ask", "task checks", "task ship", "task add-tests", "task list", "task show", "check-progress", "task wait", "task complete", "task revise",
     "task state", "task block", "task unblock", "task next", "task steer", "task pause", "task continue", "task assign", "task scope", "task plan", "task hold", "task unhold", "task require",
     "task requeue", "task review", "task repair", "task route", "task reopen", "task stop", "task resume",
     "runner list", "coordinator list", "cap list", "cap add", "outbox list", "incident list", "incident resolve",

package/dist/task-archive.d.ts

@@ -0,0 +1,10 @@
+/** Put-away checks (v145, docs/plans/task-tidy.md), in a leaf module so every door can ask without loading the store. */
+import type { Store } from "./store.js";
+/** Whether this task version is put away. Every door that dispatches, claims or approves asks this (fail closed: a
+ * row means no). */
+export declare function refArchived(store: Store, taskRef: number): boolean;
+/** Whether the built-in task with this id is put away. */
+export declare function taskArchived(store: Store, taskId: string): boolean;
+/** Whether a flow card's work is put away: its current task or its first build task (a later stage keeps the first
+ * and may clear the current one). Read from the card's own row now, so a put away that committed first holds it. */
+export declare function cardTaskArchived(store: Store, cardId: number): boolean;

package/dist/task-archive.js

@@ -0,0 +1,16 @@
+/** Whether this task version is put away. Every door that dispatches, claims or approves asks this (fail closed: a
+ * row means no). */
+export function refArchived(store, taskRef) {
+    return store.handle.prepare("SELECT 1 FROM task_archive WHERE task_ref = ?").get(taskRef) !== undefined;
+}
+/** Whether the built-in task with this id is put away. */
+export function taskArchived(store, taskId) {
+    return store.handle.prepare(`SELECT 1 FROM task_archive a JOIN task_ref r ON r.id = a.task_ref
+    WHERE r.backend = 'built-in' AND r.external_id = ?`).get(taskId) !== undefined;
+}
+/** Whether a flow card's work is put away: its current task or its first build task (a later stage keeps the first
+ * and may clear the current one). Read from the card's own row now, so a put away that committed first holds it. */
+export function cardTaskArchived(store, cardId) {
+    return store.handle.prepare(`SELECT 1 FROM flow_card c JOIN task_ref r ON r.backend = 'built-in' AND r.external_id IN (c.task, c.primary_task)
+    JOIN task_archive a ON a.task_ref = r.id WHERE c.id = ?`).get(cardId) !== undefined;
+}

package/dist/task-control.d.ts

@@ -102,7 +102,7 @@ export type ResumeOutcome = {
     gate: DispatchDiagnosis | null;
 } | {
     ok: false;
-    reason: "no-task" | "no-stop" | "wrong-task" | "stopping" | "already-resumed" | "superseded" | "busy" | "review" | "occupied";
+    reason: "no-task" | "no-stop" | "wrong-task" | "stopping" | "already-resumed" | "superseded" | "busy" | "review" | "occupied" | "archived";
     detail: string;
 };
 /**

package/dist/teams-settings.d.ts

@@ -1,7 +1,8 @@
 /** Settings → Teams: connect the Entra app once (operator), then each
  * teammate pairs their own Teams account. The messaging endpoint the bot
  * registration must point at is shown here; it has to be reachable from the
- * internet, which a tailnet-only address is not. */
+ * internet, which a tailnet-only address is not. One page with Slack and
+ * Discord (chat-settings-page.ts). */
 import type { Store } from "./store.js";
 import { type Html } from "./html.js";
 export declare function teamsSettingsHtml(store: Store, dir: string, options?: {

package/dist/teams-settings.js

@@ -1,46 +1,29 @@
-import { html, joinHtml, postForm } from "./html.js";
-import { ChatState } from "./chat-delivery-state.js";
+import { html, joinHtml } from "./html.js";
 import { loadTeamsCredentials } from "./teams-api.js";
-import { loadPrimary } from "./webhooks.js";
 import { TEAMS_MESSAGES_PATH } from "./teams.js";
+import { formRow, input } from "./server/kit.js";
+import { chatSecretRow, chatSettingsHtml } from "./chat-settings-page.js";
 export function teamsSettingsHtml(store, dir, options = {}) {
-    const credentials = loadTeamsCredentials(dir), state = new ChatState(store, "teams");
-    const bindings = credentials ? state.bindings(credentials.installation).filter(one => state.live(one)) : [];
-    const binding = options.who === undefined ? null : bindings.find(one => one.approver === options.who) ?? null;
-    const others = bindings.length - (binding === null ? 0 : 1);
-    const runtime = credentials ? state.runtime(credentials.installation) : null;
-    const now = options.now ?? new Date();
-    const live = runtime && runtime.leaseUntil !== null && runtime.leaseUntil > now.toISOString() && runtime.connected;
-    const password = html `<label>Your Toolroll password<input style="min-height:44px" type="password" name="password" autocomplete="current-password" required></label>`;
-    const post = (action, content) => postForm(`/settings/teams/${action}`, content, { attrs: { class: "card" } });
     const endpoint = options.publicUrl ? `${options.publicUrl.replace(/\/$/, "")}${TEAMS_MESSAGES_PATH}` : null;
-    const parts = [];
-    if (!credentials) {
-        parts.push(html `<p>Manage projects and review results in a Teams chat, and let a channel follow a team conversation.</p>`, html `<details open><summary>Register the bot</summary><ol><li>In <a href="https://portal.azure.com" target="_blank" rel="noopener noreferrer">Azure</a>, create an <em>Azure Bot</em> with a new single-tenant app registration; note the app (client) id and the directory (tenant) id, and create a client secret.</li>`, html `<li>Set its messaging endpoint to <code>${endpoint === null ? "https://your-public-address" + TEAMS_MESSAGES_PATH : endpoint}</code>. Microsoft must reach it from the internet: a tailnet-only address needs Tailscale Funnel (or another public tunnel) on that path.</li>`, html `<li>Enable the Microsoft Teams channel on the bot, then add the app to Teams (personal scope; team scope for channels).</li></ol></details>`, post("connect", joinHtml([
-            html `<label>App (client) id<input style="min-height:44px" type="text" name="app-id" autocomplete="off" required></label>`,
-            html `<label>Directory (tenant) id<input style="min-height:44px" type="text" name="tenant" autocomplete="off" required></label>`,
-            html `<label>Client secret<input style="min-height:44px" type="password" name="secret" autocomplete="off" required></label>`,
-            html `${password}<p class="meta">The secret stays on this installation. Next, pair your own Teams account.</p><button type="submit">Connect Teams</button>`
-        ])));
-    }
-    else {
-        parts.push(html `<p><strong>Microsoft Teams</strong> · ${live ? "Signed in" : "Waiting for sign-in"}</p>`);
-        if (endpoint !== null)
-            parts.push(html `<p class="meta">Messaging endpoint: <code>${endpoint}</code> — must be reachable from the internet.</p>`);
-        if (runtime?.problem)
-            parts.push(html `<p role="status">${String(runtime.problem)}</p>`);
-        if (!live && !runtime?.problem)
-            parts.push(html `<p>Keep the Toolroll worker running to answer Teams messages.</p>`);
-        if (options.code) {
-            parts.push(html `<h2>Pair your account</h2><p>Send this to the Toolroll bot in a personal Teams chat. It expires in 10 minutes.</p>`, html `<label>Pairing message<input type="text" readonly value="pair ${options.code}" autocomplete="off" style="width:100%;max-width:100%;font-size:14px;min-height:44px"></label>`, html `<a class="button-link" style="min-height:44px;white-space:nowrap" href="/settings/teams">Check connection</a>`);
-        }
-        else if (binding && state.live(binding)) {
-            parts.push(html `<p>Your Teams account is paired.${others ? ` ${others} teammate${others === 1 ? " is" : "s are"} paired too.` : ""}</p>`, html `<p>Try “What needs my attention?” or send <code>status</code>. In a channel, mention the bot with <code>team</code> to follow a conversation.</p>`, html `<p><a href="/chat">Open saved chat</a></p>`, loadPrimary(process.env, dir) === "teams" ? html `<p>Task updates are sent here.</p>` : post("alerts", html `<button type="submit">Send task updates here</button>`), post("unpair", html `${password}<p class="meta">Unpairing ends every open button in your chat. Teammates are unaffected.</p><button type="submit">Unpair my account</button>`));
-        }
-        else {
-            parts.push(post("pair", html `<h2>Pair your account</h2><p>Your paired Teams account can read your connected projects and confirm proposed changes. Password approvals still open in Toolroll.${others ? ` ${others} teammate${others === 1 ? " is" : "s are"} already paired.` : ""}</p>${password}<button type="submit">Create pairing code</button>`));
-        }
-        parts.push(html `<details><summary>Connection settings</summary>${post("disconnect", html `${password}<button type="submit">Disconnect Teams</button>`)}</details>`);
-    }
-    return html `<section style="max-width:42rem;overflow-wrap:anywhere"><p><a href="/settings">Settings</a></p><h1>Teams</h1>${options.problem ? html `<p class="problem" role="alert">${options.problem}</p>` : ""}${parts}</section>`;
+    const text = (id, name, label) => formRow(label, null, input({ id, name, attrs: { autocomplete: "off", spellcheck: "false", required: true, "aria-label": label } }));
+    const { code, problem, now, who } = options;
+    return chatSettingsHtml(store, dir, { ...(code === undefined ? {} : { code }), ...(problem === undefined ? {} : { problem }), ...(now === undefined ? {} : { now }), ...(who === undefined ? {} : { who }) }, {
+        provider: "teams",
+        label: "Teams",
+        credentials: loadTeamsCredentials(dir),
+        intro: "Manage projects and review results in a Teams chat, and let a channel follow a team conversation.",
+        steps: html `<ol class="k-note"><li>In <a class="k-link" href="https://portal.azure.com" target="_blank" rel="noopener noreferrer">Azure</a>, create an <em>Azure Bot</em> with a new single-tenant app registration; note the app (client) id and the directory (tenant) id, and create a client secret.</li>\
+<li>Set its messaging endpoint to <code class="k-mono">${endpoint === null ? "https://your-public-address" + TEAMS_MESSAGES_PATH : endpoint}</code>. Microsoft must reach it from the internet: a tailnet-only address needs Tailscale Funnel (or another public tunnel) on that path.</li>\
+<li>Enable the Microsoft Teams channel on the bot, then add the app to Teams (personal scope; team scope for channels).</li></ol>`,
+        fields: joinHtml([
+            text("teams-app-id", "app-id", "App (client) id"),
+            text("teams-tenant", "tenant", "Directory (tenant) id"),
+            chatSecretRow({ id: "teams-secret", name: "secret", label: "Client secret" }),
+        ]),
+        fieldsNote: "The secret stays on this installation. Next, pair your own Teams account.",
+        pairWhere: "to the Toolroll bot in a personal Teams chat",
+        tryLine: html `Try “What needs my attention?” or send <code class="k-mono">status</code>. In a channel, mention the bot with <code class="k-mono">team</code> to follow a conversation.`,
+        liveWords: ["Signed in", "Waiting for sign-in"],
+        ...(endpoint === null ? {} : { connection: html `<p class="k-note">Messaging endpoint, reachable from the internet: <code class="k-mono">${endpoint}</code></p>` }),
+    });
 }

package/dist/telegram-settings.d.ts

@@ -1,7 +1,3 @@
-/** The person's own Telegram pairing, from the console: one private chat per
- * teammate with the installation's bot (v72). The bot token itself stays on
- * the settings page; this card only mints or revokes the signed-in person's
- * pairing, never anyone else's. */
 import type { Store } from "./store.js";
 import { type Html } from "./html.js";
 /** How long a written reply may wait to be sent before it shows here with a Retry. */

package/dist/telegram-settings.js

@@ -1,36 +1,63 @@
+/** The person's own Telegram pairing, from the console: one private chat per
+ * teammate with the installation's bot (v72). The bot token itself stays on
+ * Chat apps and alerts; this page only mints or revokes the signed-in person's
+ * pairing, never anyone else's. Laid out as three steps: token, pair, check. */
+import { settingsSubPage } from "./settings-groups-ui.js";
 import { html, joinHtml, postForm } from "./html.js";
+import { acts, btn, codeLine, note, notice, settingsRecord, settingsSection } from "./server/kit.js";
+import { kitSectionForm } from "./settings-kit.js";
 /** How long a written reply may wait to be sent before it shows here with a Retry. */
 export const UNSENT_REPLY_MS = 2 * 60_000;
 export function telegramSettingsHtml(store, botId, who, options = {}) {
-    const password = html `<label>Your Toolroll password<input style="min-height:44px" type="password" name="password" autocomplete="current-password" required></label>`;
-    const post = (action, content) => postForm(`/settings/telegram/${action}`, content, { attrs: { class: "card" } });
-    let content;
+    const problem = options.problem === undefined ? "" : notice(options.problem);
+    const group = note(html `Each teammate pairs their own private chat. To connect a group, a conversation manager sends <code class="k-mono">/team</code> there and chooses a conversation. Everyone in the group can read its replies.`);
     if (botId === null) {
-        content = html `<p>No Telegram bot is connected yet. An installation approver saves the bot token on the <a href="/settings">settings page</a> first.</p>`;
+        return settingsSubPage("alerts", "Telegram", joinHtml([
+            problem,
+            settingsSection({ id: "telegram-bot", title: "1. Bot token", state: " · Not saved",
+                lead: "No Telegram bot is connected yet. An approver saves the bot token first.",
+                body: acts(btn("Open Chat apps and alerts", { sm: true, href: "/settings/alerts#telegram-token" })) }),
+            settingsSection({ id: "telegram-pair", title: "2. Pair your phone", body: note("Once the bot token is saved, pair your phone here.") }),
+            group,
+        ]));
+    }
+    const bindings = store.liveTelegramBindings(botId);
+    const mine = bindings.filter(binding => binding.approver === who);
+    const others = bindings.length - mine.length;
+    const paired = mine.length > 0;
+    const teammates = others === 0 ? "No teammates are paired yet." : `${others} teammate${others === 1 ? " is" : "s are"} paired.`;
+    const bot = settingsSection({ id: "telegram-bot", title: "1. Bot token", state: " · Saved",
+        body: note(html `Saved on <a class="k-link" href="/settings/alerts#telegram-token">Chat apps and alerts</a>.`) });
+    let pair;
+    let check;
+    if (options.code !== undefined) {
+        // The code shows once, on this page only: selectable text, never in a link or an address.
+        pair = settingsSection({ id: "telegram-pair", title: "2. Pair your phone", state: " · Code ready",
+            lead: "Send this to the bot in a private Telegram chat within 10 minutes:",
+            body: joinHtml([codeLine(`/pair ${options.code}`), note("The code works once. That chat then answers as you, so treat it like your sign-in.")]) });
+        check = settingsSection({ id: "telegram-check", title: "3. Check it works",
+            lead: "Once you've sent it, this page says your phone is paired.",
+            body: acts(btn("Check connection", { sm: true, href: "/settings/telegram" })) });
     }
     else {
-        const bindings = store.liveTelegramBindings(botId);
-        const mine = bindings.filter(binding => binding.approver === who);
-        const others = bindings.length - mine.length;
-        const parts = [html `<p><strong>${mine.length > 0 ? "Your phone is paired." : "Your phone is not paired."}</strong> ${others === 0 ? "No teammates are paired yet." : `${others} teammate${others === 1 ? " is" : "s are"} paired.`}</p>`];
+        pair = settingsSection({ id: "telegram-pair", title: "2. Pair your phone", state: paired ? " · Paired" : " · Not paired",
+            lead: `${paired ? "Your phone is paired." : "Your phone is not paired."} ${teammates}`,
+            body: paired
+                ? kitSectionForm({ proof: "telegram-unpair", action: "/settings/telegram/unpair", id: "telegram-unpair-form", save: { label: "Unpair my phone", variant: "danger" },
+                    confirm: "Unpair your phone from Telegram", body: note("This phone will lose access. Its existing Telegram buttons will stop working.") })
+                : kitSectionForm({ proof: "telegram-pair", action: "/settings/telegram/pair", id: "telegram-pair-form", native: true, save: { label: "Pair my phone" },
+                    confirm: "Pair your phone with Telegram", body: note("You get a one-time code to send to the bot.") }) });
         // A reply the assistant wrote that has not reached this person's phone for two minutes.
         const unsent = store.unsentTelegramReplies(botId, who, new Date((options.now ?? new Date()).getTime() - UNSENT_REPLY_MS));
-        if (unsent.length > 0) {
-            const oldest = unsent[0];
-            parts.push(html `<div class="card" role="status" data-unsent-replies><p><strong>${unsent.length === 1 ? html `A reply hasn't reached your phone` : html `${unsent.length} replies haven't reached your phone`}</strong></p><p class="meta">Trying since ${oldest.since.slice(11, 16)} UTC${oldest.error === null ? "" : `: ${oldest.error}`}</p>${postForm("/settings/telegram/retry", html `<button type="submit">Retry</button>`)}</div>`);
-        }
-        if (options.code !== undefined) {
-            parts.push(html `<h2>Pair your phone</h2><p>Send this to the bot in a private Telegram chat within 10 minutes:</p><pre class="pairing-code">/pair ${options.code}</pre><p class="meta">The code works once. That chat then answers as you, so treat it like your sign-in.</p>`);
-        }
-        else if (mine.length === 0) {
-            parts.push(post("pair", html `${password}<button type="submit">Pair my phone</button>`));
-        }
-        else {
-            parts.push(post("unpair", html `${password}<p class="meta">This phone will lose access. Its existing Telegram buttons will stop working.</p><button type="submit" class="danger">Unpair my phone</button>`));
-        }
-        content = joinHtml(parts);
+        const oldest = unsent[0];
+        check = settingsSection({ id: "telegram-check", title: "3. Check it works",
+            lead: paired ? html `In your private chat with the bot, send <code class="k-mono">/status</code>. It answers without an AI model.` : "Pair your phone first.",
+            body: oldest === undefined ? "" : settingsRecord({
+                title: unsent.length === 1 ? html `A reply hasn't reached your phone` : html `${unsent.length} replies haven't reached your phone`,
+                sub: `Trying since ${oldest.since.slice(11, 16)} UTC${oldest.error === null ? "" : `: ${oldest.error}`}`,
+                action: postForm("/settings/telegram/retry", btn("Retry", { sm: true, type: "submit" })),
+                attrs: { role: "status", "data-unsent-replies": true },
+            }) });
     }
-    if (options.problem !== undefined)
-        content = html `<p role="status">${options.problem}</p>${content}`;
-    return html `<h1>Telegram</h1>${content}<p class="meta">Each teammate pairs their own private chat. To connect a group, a conversation manager sends <code>/team</code> there and chooses a conversation. Everyone in the group can read its replies.</p>`;
+    return settingsSubPage("alerts", "Telegram", joinHtml([problem, bot, pair, check, group]));
 }

package/dist/tidy.d.ts

@@ -0,0 +1,130 @@
+import { type Store } from "./store.js";
+import type { WorkSummaryAccess } from "./work-summary.js";
+export type TidyRule = "release" | "routine" | "ci" | "finished";
+/** The preview's groups, in order. "finished" is a person's own choice only; tidy never applies it on its own. */
+export declare const TIDY_GROUPS: readonly {
+    rule: TidyRule;
+    label: string;
+}[];
+export declare const TIDY_DEFAULT_DAYS = 14;
+/** At most this many tasks are put away automatically per pass. */
+export declare const TIDY_PASS_LIMIT = 25;
+/** One task tidy would put away: its family's current task, every version that goes with it (`members`, task_ref ids),
+ * why, and under which rule. */
+export type TidyItem = {
+    rule: TidyRule;
+    taskId: string;
+    title: string;
+    repo: string | null;
+    reason: string;
+    updatedAt: string;
+    members: number[];
+};
+/** What the release journals say about one release task (release.ts writes them; read only). */
+export type ReleaseFact = {
+    taskId: string;
+    version: string;
+    product: string;
+    candidate: string;
+    superseded: boolean;
+    done: boolean;
+    published: boolean;
+    stopped: boolean;
+};
+/** Every release journal's facts, or why they can't be trusted: one unreadable journal leaves the release rule out. */
+export type ReleaseFacts = {
+    facts: ReleaseFact[];
+    problem: string | null;
+};
+/** Reads `releases/*.json` under the plane's state folder (the database's folder), written only by `toolroll release`.
+ * A symlink, a non-file, an oversized or unreadable journal makes the whole answer untrusted (`problem`), so the
+ * release rule then puts nothing away: a journal it can't read might be the one that says a release is in flight. */
+export declare function readReleaseFacts(stateDir: string): ReleaseFacts;
+/** The release journals beside this database (its folder is the plane's state folder). An in-memory or relative
+ * database has no state folder, so the release rule stays off rather than reading whatever folder it runs in. */
+export declare function releaseFactsFor(databaseFile: string): ReleaseFacts;
+/** -1, 0 or 1: numeric parts first, then a release above any of its pre-releases. */
+export declare function compareVersions(a: string, b: string): number;
+/** The failing runs older "Checks failed" cards of this trigger name (their own GitHub run links) that aren't on record
+ * yet, newest first, at most `limit`: the checks trigger reads each from GitHub so tidy can tell where it ran. */
+export declare function unprovenNoticeRuns(store: Store, trigger: number, repo: string, limit?: number): number[];
+/** A completed workflow run on the watched branch, as the checks trigger read it from GitHub (its poll through the
+ * person's own gh login, or its signed webhook): kept once per run. Only a push to the watched branch of the watched
+ * repository counts (a pull request from a fork whose branch is also called main does not). */
+export declare function recordBranchCheckRun(store: Store, watched: {
+    repo: string;
+    branch: string;
+}, run: {
+    id?: number | undefined;
+    name?: string | undefined;
+    head_sha?: string | undefined;
+    head_branch?: string | undefined;
+    conclusion?: string | undefined;
+    created_at?: string | undefined;
+    event?: string | undefined;
+    head_repository?: {
+        full_name?: string | undefined;
+    } | undefined;
+}, now: Date): boolean;
+/** What tidy would put away now, in group order, oldest first within a group. `days`: also offer finished tasks
+ * untouched that long (a person's preview only); null is tidy's own automatic rules. `access`: whose lists. */
+export declare function tidyPreview(store: Store, now: Date, input: {
+    releases: ReleaseFacts;
+    days: number | null;
+    access?: WorkSummaryAccess;
+}): TidyItem[];
+/** The preview's identity: exactly which tasks under which rules, for how many days. A person's confirmation names it. */
+export declare function tidyDigest(items: readonly TidyItem[], days: number | null): string;
+/** The preview in its groups (empty ones left out), with each group's label. */
+export declare function tidyGroups(items: readonly TidyItem[], days: number): {
+    rule: TidyRule;
+    label: string;
+    items: TidyItem[];
+}[];
+/** A day count from a person (1–365), or the default. */
+export declare function tidyDays(raw: string | null | undefined): number | null;
+export type TidyApply = {
+    ok: true;
+    archived: TidyItem[];
+    skipped: {
+        taskId: string;
+        message: string;
+    }[];
+} | {
+    ok: false;
+    reason: "changed" | "outside" | "empty";
+    message: string;
+    items: TidyItem[];
+    digest: string;
+};
+/** A person puts away exactly what they previewed (or the ticked part of it), in one write transaction that recomputes
+ * the preview and refuses when its digest moved or a ticked task isn't in it. */
+export declare function applyTidy(store: Store, now: Date, input: {
+    by: string;
+    days: number;
+    digest: string;
+    only: readonly string[] | null;
+    releases: ReleaseFacts;
+    access?: WorkSummaryAccess;
+}): TidyApply;
+/** Tidy on its own (the worker's reconcile pass): its automatic rules only, at most `limit` tasks, in one write
+ * transaction. Idempotent: what is put away is skipped next time, and a restored task is never put away again. */
+export declare function runTidy(store: Store, now: Date, releases: ReleaseFacts, limit?: number, access?: WorkSummaryAccess): TidyItem[];
+/** Whether this person may still put away or restore work in this project, read under the write lock (check and write
+ * together): an active approver who can see it. Null when they may; otherwise why not. */
+export declare function approverStandsNow(store: Store, name: string, repo: string | null): string | null;
+/** The repository of a task's family, from its first version (all versions share it). */
+export declare function familyRepoOf(store: Store, refs: readonly number[]): string | null;
+/** "Archived by tidy: <reason>" or "Archived by <person>: <reason>": the one sentence every surface shows. */
+export declare function archivedWords(archived: {
+    by: string;
+    byKind: "person" | "tidy";
+    reason: string;
+}): string;
+/** The release journals beside the store's own database file (none for an in-memory one). */
+export declare function releaseFactsOf(store: Store): ReleaseFacts;
+/** The lists one person sees, for tidy: every project for an unrestricted account, otherwise exactly theirs. The CLI's
+ * preview (`--as <name>`) and its apply read the same scope, so the same records give the same digest. */
+export declare function accessOf(store: Store, name: string): WorkSummaryAccess;
+/** Narrows `access` to the caller's own lens (a remote person's project limit): never wider. No lens: unchanged. */
+export declare function withinLens(access: WorkSummaryAccess, lens: readonly string[] | null): WorkSummaryAccess;