toolroll 0.8.1 → 0.9.0

package/dist/setup-guide.d.ts

@@ -15,10 +15,10 @@ export declare function detectPreparation(repo: string): {
 } | null;
 /** Browser installation may write only this known file inside its project. */
 export declare function previewProjectInstructions(repo: string): {
-    content?: never;
     ok: false;
     message: string;
     plan?: never;
+    content?: never;
     fingerprint?: never;
     installed?: never;
 } | {
@@ -30,10 +30,10 @@ export declare function previewProjectInstructions(repo: string): {
     installed: boolean;
 };
 export declare function addProjectInstructions(repo: string, fingerprint: string): {
-    content?: never;
     ok: false;
     message: string;
     plan?: never;
+    content?: never;
     fingerprint?: never;
     installed?: never;
 } | import("./skills.js").InstallResult;

package/dist/storage-ui.d.ts

@@ -0,0 +1,10 @@
+import { type CheckoutPlan } from "./checkout-cleanup.js";
+export declare const STORAGE_CSS: string;
+export type StorageView = {
+    plan: CheckoutPlan;
+    csrf: string;
+};
+export declare function storageHtml(view: StorageView, notice: {
+    said?: string | null;
+    problem?: string | null;
+}): string;

package/dist/storage-ui.js

@@ -0,0 +1,67 @@
+/**
+ * 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, and when a finished task's clean
+ * checkout goes by itself. An instance operator's page.
+ */
+import { homedir } from "node:os";
+import { basename } from "node:path";
+import { previewDigest, whyWords } from "./checkout-cleanup.js";
+import { CLEANUP_CHOICES, bytesWords } from "./storage.js";
+const e = (value) => String(value ?? "").replace(/[&<>"']/g, c => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
+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}` +
+    `@media (max-width:900px){.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%}}`;
+function item(one, csrf) {
+    const discard = one.why === "has changes"
+        ? `<details class="discard"><summary>Discard</summary><form method="post" action="/settings/storage/discard"><input type="hidden" name="csrf" value="${e(csrf)}"><input type="hidden" name="path" value="${e(one.path)}">` +
+            `<p class="meta">Throws away this checkout and its uncommitted changes. Its branch stays.</p>` +
+            `<label>Your Toolroll password<input type="password" name="password" autocomplete="current-password" required></label><button type="submit" class="danger">Discard changes</button></form></details>`
+        : "";
+    // 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 `<li data-checkout="${e(one.path)}"><span class="name">${e(one.taskId ?? basename(one.path))}</span><span class="size">${e(bytesWords(one.bytes))}</span>` +
+        `<span class="path">${e(where)}</span>` +
+        (one.why === null ? "" : `<span class="why">${e(whyWords(one)[0].toUpperCase() + whyWords(one).slice(1))}</span>`) + discard + `</li>`;
+}
+export function storageHtml(view, notice) {
+    const { plan, csrf } = view;
+    const note = notice.problem ? `<p class="problem" role="alert">${e(notice.problem)}</p>` : notice.said ? `<p role="status">${e(notice.said)}</p>` : "";
+    const hidden = `<input type="hidden" name="csrf" value="${e(csrf)}">`;
+    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 ? "" :
+        `<form method="post" action="/settings/storage/clean" class="remove">${hidden}<input type="hidden" name="preview" value="${e(previewDigest(plan))}">` +
+            `<label>Your Toolroll password<input type="password" name="password" autocomplete="current-password" required></label>` +
+            `<button type="submit">Remove ${plural(plan.go.length, "checkout")}</button></form>`;
+    const preview = `<details class="clean-up" data-clean-up${notice.problem?.startsWith("Enter your Toolroll password to clean") ? " open" : ""}><summary>Clean up</summary><div class="preview">` +
+        (plan.go.length === 0 ? `<p>Nothing to remove now.</p>` :
+            `<h3>Removes ${plural(plan.go.length, "checkout")}, about ${e(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, csrf)).join("")}</ul>`) +
+        (plan.stay.length === 0 ? "" : `<h3>Stays (${plan.stay.length})</h3><ul class="checkouts" data-stays>${plan.stay.map(one => item(one, csrf)).join("")}</ul>`) +
+        remove + `</div></details>`;
+    const options = CLEANUP_CHOICES.map(one => `<option value="${one.value}"${one.value === plan.cleanup ? " selected" : ""}>${e(one.label)}</option>`).join("");
+    return `<section class="storage">${note}` +
+        `<div class="card storage-state"><h2 data-checkout-bytes="${plan.totalBytes}">Checkouts use ${e(bytesWords(plan.totalBytes))}</h2><p class="meta">${e(facts)}</p>` +
+        `<p data-clean-bytes="${plan.freeBytes}">${e(frees)}</p>${preview}</div>` +
+        `<h2>Automatic cleanup</h2>` +
+        `<form method="post" action="/settings/storage" class="setting">${hidden}` +
+        `<label>Remove a finished task's clean checkout<select name="cleanup">${options}</select></label>` +
+        `<p class="meta">Its branch always stays. Checkouts with changes, commits on no branch, in use, or waiting for review are kept.</p>` +
+        `<label>Your Toolroll password<input type="password" name="password" autocomplete="current-password" required></label><button type="submit">Save</button></form></section>`;
+}

package/dist/storage.d.ts

@@ -1,4 +1,18 @@
 import type { Store } from "./store.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";
+export type CheckoutCleanup = "finished" | "2d" | "7d" | "never";
+export declare const DEFAULT_CLEANUP: CheckoutCleanup;
+export declare const CLEANUP_CHOICES: readonly {
+    value: CheckoutCleanup;
+    label: string;
+    days: number | null;
+}[];
+/** `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;
+/** 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 = {
     what: string;
     bytes: number;
@@ -7,7 +21,7 @@ export type StorageLine = {
 };
 /** Bytes a tree holds on disk (allocated blocks; links not followed). */
 export declare function treeBytes(path: string): number;
-export declare function storageReport(store: Store, databaseFile: string, now: Date, keepMs: number): {
+export declare function storageReport(store: Store, databaseFile: string, checkoutNote?: string): {
     folder: string;
     total: number;
     lines: StorageLine[];

package/dist/storage.js

@@ -2,11 +2,67 @@
  * Where Toolroll's disk goes (`toolroll storage`): the folder
  * beside the database, by kind, and what storage retention takes care of.
  * Build checkouts and staged releases are the big ones; the worker removes a
- * finished task's clean checkout two days after it was let go, and a deploy
- * keeps its last few releases.
+ * finished task's clean checkout as the checkout cleanup setting says
+ * (checkout-cleanup.ts), and a deploy keeps its last few releases.
  */
+import { spawnSync } from "node:child_process";
 import { lstatSync, readdirSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
+/** 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 (
+  id         INTEGER PRIMARY KEY CHECK (id = 1),
+  cleanup    TEXT NOT NULL CHECK (cleanup IN ('finished', '2d', '7d', 'never')),
+  updated_by TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+`;
+export const DEFAULT_CLEANUP = "finished";
+export const CLEANUP_CHOICES = [
+    { value: "finished", label: "When its task is complete or cancelled", days: 0 },
+    { value: "2d", label: "2 days after that", days: 2 },
+    { value: "7d", label: "A week after that", days: 7 },
+    { value: "never", label: "Never (only when you clean up)", days: null },
+];
+/** `finished` (or complete, cancelled), `2d`, `7d` (or week, 1w), `never` (or off); undefined when it's none of those. */
+export function parseCleanup(text) {
+    const value = text.trim().toLowerCase().replace(/\s+/g, " ");
+    if (["finished", "complete", "completed", "cancelled", "done", "0", "0d"].includes(value))
+        return "finished";
+    if (["2d", "2", "2 days", "2days"].includes(value))
+        return "2d";
+    if (["7d", "7", "7 days", "7days", "week", "a week", "1w"].includes(value))
+        return "7d";
+    if (["never", "off"].includes(value))
+        return "never";
+    return undefined;
+}
+export function cleanupWords(cleanup) {
+    return cleanup === "finished" ? "when its task is complete or cancelled"
+        : cleanup === "never" ? "never (only when you clean up)"
+            : `${cleanup === "2d" ? "2 days" : "a week"} after its task is complete or cancelled`;
+}
+/** 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();
+    if (paths.length === 0)
+        return sizes;
+    if (process.platform !== "win32") {
+        for (let at = 0; at < paths.length; at += 200) {
+            const batch = paths.slice(at, at + 200);
+            const du = spawnSync("du", ["-sk", ...batch], { encoding: "utf8", maxBuffer: 16 * 1024 * 1024 });
+            for (const line of (du.stdout ?? "").split("\n")) {
+                const match = /^(\d+)\t(.+)$/.exec(line);
+                if (match !== null && batch.includes(match[2]))
+                    sizes.set(match[2], Number(match[1]) * 1024);
+            }
+        }
+    }
+    for (const path of paths)
+        if (!sizes.has(path))
+            sizes.set(path, treeBytes(path));
+    return sizes;
+}
 /** Bytes a tree holds on disk (allocated blocks; links not followed). */
 export function treeBytes(path) {
     let total = 0;
@@ -35,7 +91,7 @@ export function treeBytes(path) {
     }
     return total;
 }
-export function storageReport(store, databaseFile, now, keepMs) {
+export function storageReport(store, databaseFile, checkoutNote) {
     const folder = dirname(databaseFile);
     const base = basename(databaseFile);
     let names = [];
@@ -45,7 +101,8 @@ export function storageReport(store, databaseFile, now, keepMs) {
     catch {
         names = [];
     }
-    const sizes = new Map(names.map(name => [name, treeBytes(join(folder, name))]));
+    const measured = diskBytes(names.map(name => join(folder, name)));
+    const sizes = new Map(names.map(name => [name, measured.get(join(folder, name)) ?? 0]));
     const take = (match) => {
         let bytes = 0;
         for (const [name, size] of sizes)
@@ -56,7 +113,6 @@ export function storageReport(store, databaseFile, now, keepMs) {
         return bytes;
     };
     const checkouts = store.listWorktrees();
-    const due = checkouts.filter(row => row.releasedAt !== null && row.runner === null && now.getTime() - Date.parse(row.releasedAt) >= keepMs).length;
     let staged = 0;
     try {
         staged = readdirSync(join(folder, "staged-upgrades")).length;
@@ -66,8 +122,7 @@ export function storageReport(store, databaseFile, now, keepMs) {
     }
     const lines = [
         { what: "Database", bytes: take(name => name.startsWith(base)) },
-        { what: "Build checkouts", bytes: take(name => name === "worktrees"), count: checkouts.length,
-            note: due === 0 ? "none due for removal" : `${due} let go over ${Math.round(keepMs / 86_400_000)} days ago: removed on the next pass if their task is finished and they're clean` },
+        { what: "Build checkouts", bytes: take(name => name === "worktrees"), count: checkouts.length, ...(checkoutNote === undefined ? {} : { note: checkoutNote }) },
         { what: "Staged releases", bytes: take(name => name === "staged-upgrades"), count: staged, note: "a deploy keeps the release it installed, the one before and the newest few" },
         { what: "Evidence", bytes: take(name => name === "evidence"), note: "the audit record of every run; kept" },
         { what: "Backups", bytes: take(name => name === "backups") },

package/dist/store.d.ts

@@ -16,8 +16,13 @@ import type { LimitReading, LimitWindow } from "./provider-limits.js";
 import { underCeiling, type OrgPolicy, type SavedPolicy } from "./policy.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 LedgerChainReport } from "./ledger-chain.js";
 import { type ApprovalGate, type ApprovalRules, type ApproverKind, type Filer } from "./approval-policy.js";
+/** Settings → Integrations (no version bump): each integration's last check. `outcome` is ok, failed, or absent (the check found
+ * nothing set up, such as no `gh` sign-in). `ok_at` and `error`/`error_at` keep the last success and the last
+ * failure across checks, so a row can say both. `account` is a display name only, never a credential. */
+export declare const INTEGRATIONS_SCHEMA = "\nCREATE TABLE IF NOT EXISTS integration_check (\n  key         TEXT PRIMARY KEY,\n  outcome     TEXT NOT NULL CHECK (outcome IN ('ok', 'failed', 'absent')),\n  account     TEXT,\n  detail      TEXT,\n  problem     TEXT,\n  checked_at  TEXT NOT NULL,\n  ok_at       TEXT,\n  error       TEXT,\n  error_at    TEXT\n);\n";
 export type BackupSettings = {
     enabled: boolean;
     everyHours: number;
@@ -943,6 +948,26 @@ export type TelegramDelivery = Notification & {
     destination: string;
     claimGeneration: number;
 };
+/** How chats reach one person (quiet chat): only when they are needed, or every step. */
+export type NotificationMode = "quiet" | "all";
+export type NotificationPreference = {
+    mode: NotificationMode;
+    digestAt: string | null;
+    digestOn: string | null;
+    updatedAt: string | null;
+};
+/** Tasks filed this close together share one chat message. */
+export declare const QUIET_GROUP_MS = 60000;
+export declare function isDigestTime(value: string): boolean;
+/** The one chat message a destination keeps for a task, or for several tasks filed together. */
+export type ChatCard = {
+    id: number;
+    destination: string;
+    anchorAt: string;
+    message: string | null;
+    digest: string | null;
+    tasks: number[];
+};
 /**
  * What one recovery walk over a gone runner's work settled (P0.1a): the run
  * ids it finished as failed/interrupted and the built-in task ids it returned
@@ -1543,6 +1568,11 @@ export type PublicationGrant = {
     merge?: boolean;
     mergeMethod?: "squash" | "merge" | "rebase" | null;
     mergeDeleteBranch?: boolean;
+    /** When a pull request is owed: every finished build ("build", the original grant), or only when a person
+     * chooses "Complete and open a pull request" ("complete", the one-step project setup). */
+    publishOn?: "build" | "complete";
+    /** The project's optional "Merge when checks pass", off by default (complete-mode grants only). */
+    mergeWhenGreen?: boolean;
 };
 /** One run's road to a PR, durable at every phase. */
 export type Publication = {
@@ -2645,11 +2675,6 @@ export declare class Store {
     getWorktree(path: string): WorktreeRow | null;
     /** Drop a row whose directory is gone; a lease over nothing only refuses work. */
     forgetWorktree(path: string): void;
-    /** The branches storage retention keeps a repository's checkouts of: every task not done or cancelled (a failed
-     * one included: it can be requeued), and unplaced ones (they're dispatched anywhere); and a done task whose result
-     * was marked complete (the completion names its family's root; its run names the version), or a release candidate
-     * done, within `resultMs` (a deploy installs the build in its checkout). Each task's own branch and every branch its runs used. */
-    keptBranches(repo: string, now: Date, resultMs: number): string[];
     /**
      * Approve one repo's setup, revoking any predecessor in the same
      * transaction — exactly one live setup per repo, enforced by the partial
@@ -5068,6 +5093,10 @@ export declare class Store {
     retentionPeriods(): RetentionPeriods;
     /** Set how long one kind is kept (null: forever); the ledger keeps before → after. */
     setRetentionPeriod(kind: RetentionKind, days: number | null, by: string, now: Date): RetentionPeriods;
+    /** Settings → Storage: when a finished task's clean checkout is removed (the default until someone chooses). */
+    checkoutCleanup(): CheckoutCleanup;
+    /** Choose when a finished task's clean checkout is removed; the ledger keeps before → after. */
+    setCheckoutCleanup(cleanup: CheckoutCleanup, by: string, now: Date): CheckoutCleanup;
     /** v105: keep a provider's latest reading of its plan's usage windows (a window it no longer reports is dropped). */
     recordProviderLimits(reading: LimitReading, now: Date): void;
     /** The latest reading of every provider's plan windows, shortest window first. */
@@ -5876,6 +5905,8 @@ export declare class Store {
         merge?: boolean;
         mergeMethod?: "squash" | "merge" | "rebase" | null;
         mergeDeleteBranch?: boolean;
+        publishOn?: "build" | "complete";
+        mergeWhenGreen?: boolean;
     }, now: Date): void;
     /**
      * Reserve the next observation generation for a PR BEFORE the network
@@ -7256,6 +7287,8 @@ export declare class Store {
     /** A confirmed network message remains history even if authority changed
      * while it was in flight. It only binds the OLD destination, never new work. */
     recordTelegramMessage(row: TelegramDelivery, binding: TelegramBinding, messageId: string, now: Date): void;
+    /** The newest confirmed message this notification became at one destination, if any. */
+    telegramMessageOf(notification: number, destination: string): string | null;
     finalizeTelegramDelivery(row: TelegramDelivery, binding: TelegramBinding, owner: string, outcome: {
         ok: true;
         receipt: string | null;
@@ -7287,6 +7320,34 @@ export declare class Store {
     /** Set (or clear, with null) the cadence. Turning it on starts the
      * window NOW — nothing held before the choice is dumped at once. */
     setTelegramDigest(everyMs: number | null, by: string, now: Date): void;
+    /** How chats reach this person: only when they are needed unless they chose every step. */
+    notificationPreference(account: string): NotificationPreference;
+    /** Change one person's choice; a digest time is a local HH:MM, or null for no evening digest. */
+    setNotificationPreference(account: string, change: {
+        mode?: NotificationMode;
+        digestAt?: string | null;
+    }, by: string, now: Date): NotificationPreference;
+    /** Everyone who asked for an evening digest, with the local day theirs was last considered. */
+    eveningDigestPeople(): {
+        account: string;
+        digestAt: string;
+        digestOn: string | null;
+    }[];
+    /** Claim one local day's digest for one person: true once, false if it was already considered. */
+    claimEveningDigestDay(account: string, day: string): boolean;
+    /** The card a destination keeps for this task. A task with none joins a card whose first task was filed within
+     * a minute of it (up to eight tasks), or starts its own. */
+    chatCardFor(destination: string, taskRef: number, filedAt: string, now: Date): ChatCard;
+    chatCard(id: number): ChatCard | null;
+    /** The newest lifecycle fact a task has recorded — what its card says before any attempt starts. */
+    latestTaskFact(taskRef: number): {
+        kind: string;
+        createdAt: string;
+    } | null;
+    /** Task-bound facts recorded since an instant, newest last (bounded): what an evening digest reads. */
+    taskFactsSince(since: string, limit?: number): Notification[];
+    /** The message now showing this card, and what it shows. */
+    setChatCardMessage(id: number, message: string, digest: string): void;
     markTelegramDigestSent(now: Date): void;
     /** Every batched row finalized delivered AND the anchor moved, in ONE
      * transaction (v4 review, finding 5): a digest is either recorded whole

package/dist/store.js

@@ -67,9 +67,11 @@ import { POLICY_SCHEMA, agentRefusal, approvalRefusal, attendedRefusal, policyPa
 import { PROVIDER_AUTH_SCHEMA } from "./provider-auth.js";
 import { SPEND_SCHEMA, billingOf, budgetStates, canPrice, claudeMachineBilling, countsToward, filersOf, monthOf, priceWork, seenBilling as seenBillingOf, spendItems, teammateFilers, usd } from "./spend.js";
 import { FOREVER, RETENTION_SCHEMA, periodWords } from "./retention.js";
+import { CHECKOUT_CLEANUP_SCHEMA, DEFAULT_CLEANUP, cleanupWords } from "./storage.js";
 import { IN_RANGE, LEDGER_CHAIN_SCHEMA, safeWhole, sealLedger, verifyLedgerChain } from "./ledger-chain.js";
 import { NO_RULES, filerFor, isProtectedWork, protectedChanges, rulesWords } from "./approval-policy.js";
-import { BRANCH_PREFIXES, configBase, envValue, namedPath } from "./names.js";
+import { configBase, envValue, namedPath } from "./names.js";
+import { PULL_REQUEST_SCHEMA } from "./pull-request-schema.js";
 // v60 fenced older readers before the chat action cards; v61 adds notification
 // provenance and Telegram destination receipts, and readers below v61 refuse it.
 // v62 adds the durable Telegram conversation queue and proposal-card tokens,
@@ -130,6 +132,54 @@ CREATE TABLE IF NOT EXISTS monitoring_status (
   held_until  TEXT
 );
 `;
+/** Quiet chat: each person's choice of how chats reach them — only when they are needed (the default, no row),
+ * every step, and an optional evening digest at a local HH:MM. `digest_on` is the local day the last evening
+ * digest was considered, so each day is judged once. A task's card is the one chat message a destination keeps
+ * for it (or for several tasks filed within a minute): `message` is the Telegram message id or the chat app's
+ * part id, `digest` the text last shown, so an unchanged card is never re-sent. */
+const QUIET_CHAT_SCHEMA = `
+CREATE TABLE IF NOT EXISTS notification_preference (
+  account    TEXT PRIMARY KEY,
+  mode       TEXT NOT NULL DEFAULT 'quiet' CHECK (mode IN ('quiet', 'all')),
+  digest_at  TEXT CHECK (digest_at IS NULL OR (length(digest_at) = 5 AND digest_at GLOB '[0-2][0-9]:[0-5][0-9]')),
+  digest_on  TEXT,
+  updated_at TEXT NOT NULL,
+  updated_by TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS chat_card (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  destination TEXT NOT NULL,
+  anchor_at   TEXT NOT NULL,
+  message     TEXT,
+  digest      TEXT,
+  created_at  TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS chat_card_destination ON chat_card(destination, anchor_at);
+CREATE TABLE IF NOT EXISTS chat_card_task (
+  destination TEXT NOT NULL,
+  task_ref    INTEGER NOT NULL,
+  card        INTEGER NOT NULL REFERENCES chat_card(id),
+  joined_at   TEXT NOT NULL,
+  PRIMARY KEY (destination, task_ref)
+);
+CREATE INDEX IF NOT EXISTS chat_card_task_card ON chat_card_task(card);
+`;
+/** Settings → Integrations (no version bump): each integration's last check. `outcome` is ok, failed, or absent (the check found
+ * nothing set up, such as no `gh` sign-in). `ok_at` and `error`/`error_at` keep the last success and the last
+ * failure across checks, so a row can say both. `account` is a display name only, never a credential. */
+export const INTEGRATIONS_SCHEMA = `
+CREATE TABLE IF NOT EXISTS integration_check (
+  key         TEXT PRIMARY KEY,
+  outcome     TEXT NOT NULL CHECK (outcome IN ('ok', 'failed', 'absent')),
+  account     TEXT,
+  detail      TEXT,
+  problem     TEXT,
+  checked_at  TEXT NOT NULL,
+  ok_at       TEXT,
+  error       TEXT,
+  error_at    TEXT
+);
+`;
 /** Sprint 8: database backups. One settings row (off, or every so many hours, keeping the newest N in a folder; no
  * folder means `backups` beside the database), every backup's outcome, and a lease the console's backup loop holds
  * and renews while it runs: one process backs up at a time, and a restore sees that the console is running. */
@@ -581,6 +631,11 @@ const LIFECYCLE_HOLD_WORDS = {
     revision: "a plan revision awaiting approval",
     stop: "a stopped attempt that has not been resumed",
 };
+/** Tasks filed this close together share one chat message. */
+export const QUIET_GROUP_MS = 60_000;
+export function isDigestTime(value) {
+    return /^(?:[01][0-9]|2[0-3]):[0-5][0-9]$/.test(value);
+}
 /** The bounded activity vocabulary. Machine-authored — a model's prose never becomes one of these. */
 export const RUN_PHASES = [
     "agent-running",
@@ -3689,16 +3744,19 @@ function initializeStore(db, file) {
     db.exec(APPROVAL_SCHEMA);
     db.exec(LEDGER_CHAIN_SCHEMA);
     db.exec(MONITORING_SCHEMA);
+    db.exec(INTEGRATIONS_SCHEMA);
     db.exec(SPEND_SCHEMA);
     // Sign-in pauses: one row per incident of a provider's sign-in no longer working.
     db.exec(PROVIDER_AUTH_SCHEMA);
     // The sign-in pause the dispatch gate last left this task waiting on (null: none), for the work index.
     addColumn(db, "task_ref", "auth_wait_pause", "INTEGER REFERENCES provider_auth_pause(id)");
     db.exec(RETENTION_SCHEMA);
+    db.exec(CHECKOUT_CLEANUP_SCHEMA);
     db.exec(BACKUP_SCHEMA);
     // Sprint 8: the organisation policy (one row, or none: nothing restricted).
     db.exec(POLICY_SCHEMA);
     db.exec(RUN_CHECK_SCHEMA);
+    db.exec(QUIET_CHAT_SCHEMA);
     mergeCheckTables(db);
     addColumn(db, "monitoring_status", "target", "TEXT");
     // v105: how a teammate's turn was billed (this computer's Claude sign-in, as last seen).
@@ -3707,6 +3765,11 @@ function initializeStore(db, file) {
     addColumn(db, "run_spend", "billing", "TEXT NOT NULL DEFAULT 'subscription' CHECK (billing IN ('subscription', 'api-key'))");
     addColumn(db, "run_spend", "billing_fixed", "INTEGER NOT NULL DEFAULT 0");
     migrate(db, preflight === null ? null : Math.abs(preflight));
+    // Complete → pull request → merge: when a grant publishes, the project's "Merge when checks pass", and each
+    // followed pull request's CI revisions and merge record (no version bump: additive only).
+    addColumn(db, "publication_grant", "publish_on", "TEXT NOT NULL DEFAULT 'build' CHECK (publish_on IN ('build', 'complete'))");
+    addColumn(db, "publication_grant", "merge_when_green", "INTEGER NOT NULL DEFAULT 0 CHECK (merge_when_green IN (0, 1))");
+    db.exec(PULL_REQUEST_SCHEMA);
     addColumn(db, "flow_card", "source_json", "TEXT");
     addColumn(db, "flow_card", "owner", "TEXT");
     addColumn(db, "flow", "owner", "TEXT");
@@ -9805,21 +9868,6 @@ export class Store {
     forgetWorktree(path) {
         this.db.prepare("DELETE FROM worktree WHERE path = ?").run(path);
     }
-    /** The branches storage retention keeps a repository's checkouts of: every task not done or cancelled (a failed
-     * one included: it can be requeued), and unplaced ones (they're dispatched anywhere); and a done task whose result
-     * was marked complete (the completion names its family's root; its run names the version), or a release candidate
-     * done, within `resultMs` (a deploy installs the build in its checkout). Each task's own branch and every branch its runs used. */
-    keptBranches(repo, now, resultMs) {
-        const since = new Date(now.getTime() - resultMs).toISOString();
-        const tasks = `SELECT r.id AS ref, r.external_id AS id FROM task_ref r JOIN task t ON t.id = r.external_id LEFT JOIN task_scope s ON s.task_id = t.id
-      WHERE (r.repo = ? OR r.repo IS NULL) AND (t.state NOT IN ('done', 'cancelled') OR (t.state = 'done' AND (
-        (s.candidate IS NOT NULL AND t.updated_at >= ?) OR EXISTS (SELECT 1 FROM action_ledger l JOIN run ON run.id = l.run_id
-          WHERE run.task_ref = r.id AND l.action = 'assignment handoff checked' AND l.at >= ?))))`;
-        const own = this.db.prepare(tasks).all(repo, since, since).flatMap(row => BRANCH_PREFIXES.map(prefix => `${prefix}${String(row["id"])}`));
-        const used = this.db.prepare(`SELECT DISTINCT run.branch AS branch FROM run WHERE run.branch IS NOT NULL AND run.task_ref IN (SELECT ref FROM (${tasks}))`).all(repo, since, since)
-            .map(row => String(row["branch"]));
-        return [...new Set([...own, ...used])];
-    }
     // ---- worktree setup (M5.7) ---------------------------------------------
     /**
      * Approve one repo's setup, revoking any predecessor in the same
@@ -16243,6 +16291,21 @@ export class Store {
             return this.retentionPeriods();
         });
     }
+    /** Settings → Storage: when a finished task's clean checkout is removed (the default until someone chooses). */
+    checkoutCleanup() {
+        const row = this.db.prepare("SELECT cleanup FROM checkout_cleanup_setting WHERE id = 1").get();
+        return row === undefined ? DEFAULT_CLEANUP : String(row["cleanup"]);
+    }
+    /** Choose when a finished task's clean checkout is removed; the ledger keeps before → after. */
+    setCheckoutCleanup(cleanup, by, now) {
+        return this.transact(() => {
+            const before = this.checkoutCleanup();
+            this.db.prepare("INSERT INTO checkout_cleanup_setting (id, cleanup, updated_by, updated_at) VALUES (1, ?, ?, ?) ON CONFLICT(id) DO UPDATE SET cleanup = excluded.cleanup, updated_by = excluded.updated_by, updated_at = excluded.updated_at")
+                .run(cleanup, by, now.toISOString());
+            this.recordPolicy(by, null, "checkout cleanup changed", cleanupWords(before), cleanupWords(cleanup), now);
+            return this.checkoutCleanup();
+        });
+    }
     /** v105: keep a provider's latest reading of its plan's usage windows (a window it no longer reports is dropped). */
     recordProviderLimits(reading, now) {
         this.transact(() => {
@@ -18106,9 +18169,9 @@ export class Store {
             this.db
                 .prepare(`INSERT INTO publication_grant
              (repo, github_repo, remote, head_prefix, base, capabilities, selector, draft, granted_by, granted_at,
-              merge, merge_method, merge_delete_branch)
-           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-                .run(grant.repo, grant.githubRepo, grant.remote, grant.headPrefix, grant.base, JSON.stringify(grant.capabilities), grant.selector, grant.draft ? 1 : 0, grant.grantedBy, now.toISOString(), grant.merge === true ? 1 : 0, grant.mergeMethod ?? null, grant.mergeDeleteBranch === true ? 1 : 0);
+              merge, merge_method, merge_delete_branch, publish_on, merge_when_green)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(grant.repo, grant.githubRepo, grant.remote, grant.headPrefix, grant.base, JSON.stringify(grant.capabilities), grant.selector, grant.draft ? 1 : 0, grant.grantedBy, now.toISOString(), grant.merge === true ? 1 : 0, grant.mergeMethod ?? null, grant.mergeDeleteBranch === true ? 1 : 0, grant.publishOn ?? "build", grant.mergeWhenGreen === true ? 1 : 0);
         });
     }
     // ---- the merge grant's machinery (v21) ----------------------------------
@@ -21520,6 +21583,11 @@ export class Store {
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
             .run(binding.id, binding.botId, binding.chatId, messageId, row.id, row.destination, row.project, row.taskRef, row.taskId, row.run, now.toISOString());
     }
+    /** The newest confirmed message this notification became at one destination, if any. */
+    telegramMessageOf(notification, destination) {
+        const row = this.db.prepare("SELECT message_id FROM telegram_outbound_message WHERE notification = ? AND destination = ? ORDER BY CAST(message_id AS INTEGER) DESC LIMIT 1").get(notification, destination);
+        return row === undefined ? null : String(row["message_id"]);
+    }
     finalizeTelegramDelivery(row, binding, owner, outcome, now) {
         return this.transact(() => {
             if (!this.telegramClaimHeld(row, owner, now) || row.destination !== this.telegramDestination(binding))
@@ -21613,6 +21681,77 @@ export class Store {
             .prepare("UPDATE telegram_digest SET every_ms = ?, set_by = ?, set_at = ?, last_sent_at = CASE WHEN ? IS NULL THEN NULL ELSE COALESCE(last_sent_at, ?) END WHERE id = 1")
             .run(everyMs, by, now.toISOString(), everyMs, now.toISOString());
     }
+    // ---- quiet chat: each person's notification choice and each task's one message ----
+    /** How chats reach this person: only when they are needed unless they chose every step. */
+    notificationPreference(account) {
+        const row = this.db.prepare("SELECT mode, digest_at, digest_on, updated_at FROM notification_preference WHERE account = ?").get(account);
+        return row === undefined ? { mode: "quiet", digestAt: null, digestOn: null, updatedAt: null }
+            : { mode: row["mode"] === "all" ? "all" : "quiet", digestAt: row["digest_at"] == null ? null : String(row["digest_at"]),
+                digestOn: row["digest_on"] == null ? null : String(row["digest_on"]), updatedAt: String(row["updated_at"]) };
+    }
+    /** Change one person's choice; a digest time is a local HH:MM, or null for no evening digest. */
+    setNotificationPreference(account, change, by, now) {
+        if (change.digestAt != null && !isDigestTime(change.digestAt))
+            throw new Error("digest time must be HH:MM");
+        const current = this.notificationPreference(account);
+        const mode = change.mode ?? current.mode;
+        const digestAt = change.digestAt === undefined ? current.digestAt : change.digestAt;
+        this.db.prepare(`INSERT INTO notification_preference (account, mode, digest_at, digest_on, updated_at, updated_by) VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT (account) DO UPDATE SET mode = excluded.mode, digest_at = excluded.digest_at, updated_at = excluded.updated_at, updated_by = excluded.updated_by`)
+            .run(account, mode, digestAt, current.digestOn, now.toISOString(), by);
+        return this.notificationPreference(account);
+    }
+    /** Everyone who asked for an evening digest, with the local day theirs was last considered. */
+    eveningDigestPeople() {
+        return this.db.prepare("SELECT account, digest_at, digest_on FROM notification_preference WHERE digest_at IS NOT NULL ORDER BY account").all()
+            .map(row => ({ account: String(row["account"]), digestAt: String(row["digest_at"]), digestOn: row["digest_on"] == null ? null : String(row["digest_on"]) }));
+    }
+    /** Claim one local day's digest for one person: true once, false if it was already considered. */
+    claimEveningDigestDay(account, day) {
+        return Number(this.db.prepare("UPDATE notification_preference SET digest_on = ? WHERE account = ? AND digest_at IS NOT NULL AND (digest_on IS NULL OR digest_on < ?)")
+            .run(day, account, day).changes) === 1;
+    }
+    /** The card a destination keeps for this task. A task with none joins a card whose first task was filed within
+     * a minute of it (up to eight tasks), or starts its own. */
+    chatCardFor(destination, taskRef, filedAt, now) {
+        return this.transact(() => {
+            const known = this.db.prepare("SELECT card FROM chat_card_task WHERE destination = ? AND task_ref = ?").get(destination, taskRef);
+            if (known !== undefined)
+                return this.chatCard(Number(known["card"]));
+            const at = Date.parse(filedAt);
+            const low = new Date(at - QUIET_GROUP_MS).toISOString(), high = new Date(at + QUIET_GROUP_MS).toISOString();
+            const together = Number.isFinite(at) ? this.db.prepare(`SELECT id FROM chat_card c WHERE destination = ? AND anchor_at BETWEEN ? AND ?
+        AND (SELECT COUNT(*) FROM chat_card_task t WHERE t.card = c.id) < 8 ORDER BY id DESC LIMIT 1`).get(destination, low, high) : undefined;
+            const card = together !== undefined ? Number(together["id"])
+                : Number(this.db.prepare("INSERT INTO chat_card (destination, anchor_at, created_at) VALUES (?, ?, ?)")
+                    .run(destination, Number.isFinite(at) ? new Date(at).toISOString() : now.toISOString(), now.toISOString()).lastInsertRowid);
+            this.db.prepare("INSERT INTO chat_card_task (destination, task_ref, card, joined_at) VALUES (?, ?, ?, ?)").run(destination, taskRef, card, now.toISOString());
+            return this.chatCard(card);
+        });
+    }
+    chatCard(id) {
+        const row = this.db.prepare("SELECT * FROM chat_card WHERE id = ?").get(id);
+        if (row === undefined)
+            return null;
+        const tasks = this.db.prepare("SELECT task_ref FROM chat_card_task WHERE card = ? ORDER BY joined_at, task_ref").all(id).map(one => Number(one["task_ref"]));
+        return { id, destination: String(row["destination"]), anchorAt: String(row["anchor_at"]), message: row["message"] == null ? null : String(row["message"]),
+            digest: row["digest"] == null ? null : String(row["digest"]), tasks };
+    }
+    /** The newest lifecycle fact a task has recorded — what its card says before any attempt starts. */
+    latestTaskFact(taskRef) {
+        const row = this.db.prepare("SELECT kind, created_at FROM notification WHERE task_ref = ? AND substr(dedupe_key, 1, ?) = ? ORDER BY id DESC LIMIT 1")
+            .get(taskRef, LIFECYCLE_KEY_PREFIX.length, LIFECYCLE_KEY_PREFIX);
+        return row === undefined ? null : { kind: String(row["kind"]), createdAt: String(row["created_at"]) };
+    }
+    /** Task-bound facts recorded since an instant, newest last (bounded): what an evening digest reads. */
+    taskFactsSince(since, limit = 2000) {
+        return this.db.prepare("SELECT * FROM notification WHERE created_at >= ? AND task_ref IS NOT NULL AND project IS NOT NULL ORDER BY id DESC LIMIT ?")
+            .all(since, limit).map(readNotification).reverse();
+    }
+    /** The message now showing this card, and what it shows. */
+    setChatCardMessage(id, message, digest) {
+        this.db.prepare("UPDATE chat_card SET message = ?, digest = ? WHERE id = ?").run(message, digest, id);
+    }
     markTelegramDigestSent(now) {
         this.db.prepare("UPDATE telegram_digest SET last_sent_at = ? WHERE id = 1").run(now.toISOString());
     }
@@ -22428,6 +22567,8 @@ function readPublicationGrant(row) {
             ? null
             : String(row["merge_method"]),
         mergeDeleteBranch: Number(row["merge_delete_branch"] ?? 0) === 1,
+        publishOn: row["publish_on"] === "complete" ? "complete" : "build",
+        mergeWhenGreen: Number(row["merge_when_green"] ?? 0) === 1,
     };
 }
 function readPublication(row) {