toolroll 0.8.2 → 0.9.1

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/skills-ui.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { whenUtc } from "./when-html.js";
 const e = (value) => String(value ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
 const hidden = (data) => Object.entries(data)
     .map(([k, v]) => `<input type="hidden" name="${e(k)}" value="${e(v)}">`)
@@ -41,7 +42,7 @@ export function skillsHtml(view, csrf, canManage, options = {}) {
         ? `<details class="card"${options.error && options.draft?.["method"] ? " open" : ""}><summary>Add skill</summary><form method="post" action="/settings/skills/import" data-skill-import>${hidden(base)}<label>Add from<select name="method" data-skill-method><option value="paste"${d["method"] === "paste" ? " selected" : ""}>Paste SKILL.md</option><option value="github"${d["method"] === "github" ? " selected" : ""}>GitHub folder</option><option value="folder"${d["method"] === "folder" ? " selected" : ""}>Local folder</option></select></label><div data-skill-input="paste"><label>SKILL.md<textarea name="content" rows="8" maxlength="24576" placeholder="---&#10;name: design-review&#10;description: Review interface copy and layout.&#10;---&#10;Write your instructions here.">${e(d["content"])}</textarea></label></div><div data-skill-input="github"><label>Public GitHub folder<input name="url" type="url" value="${e(d["url"])}" placeholder="https://github.com/owner/repo/tree/main/skills/review"></label></div><div data-skill-input="folder"><label>Skill folder<input type="file" webkitdirectory multiple data-skill-folder></label><input type="hidden" name="files" value=""><p class="meta">Choose the folder containing SKILL.md. Up to 64 files, 1 MB total.</p><noscript>Folder uploads require JavaScript. You can paste SKILL.md or use a GitHub folder.</noscript></div><p class="meta">Added to your library first. Review its source and requirements before enabling it.</p><p data-skill-error role="alert" hidden></p><button>Add to library</button></form></details>`
         : "";
     const history = view.history.length
-        ? `<details><summary>Change history</summary>${view.history.map((h) => `<div class="card"><p>Selection ${h.revision} · ${e(h.actor)} · ${e(h.at.slice(0, 16).replace("T", " "))} UTC</p><ul>${h.enabled.length ? h.enabled.map((s) => `<li>${e(s.name)} · ${e(s.version)}</li>`).join("") : "<li>No skills enabled</li>"}</ul>${manage && h.revision !== view.revision ? form("restore", "<button>Restore selection</button>", { restore: h.revision }) : '<span class="meta">Current selection</span>'}</div>`).join("")}</details>`
+        ? `<details><summary>Change history</summary>${view.history.map((h) => `<div class="card"><p>Selection ${h.revision} · ${e(h.actor)} · ${whenUtc(h.at)}</p><ul>${h.enabled.length ? h.enabled.map((s) => `<li>${e(s.name)} · ${e(s.version)}</li>`).join("") : "<li>No skills enabled</li>"}</ul>${manage && h.revision !== view.revision ? form("restore", "<button>Restore selection</button>", { restore: h.revision }) : '<span class="meta">Current selection</span>'}</div>`).join("")}</details>`
         : "";
     return `<section class="skills">${options.error ? `<p class="problem" role="alert">${e(options.error)}</p>` : ""}<p>${active ? `${active} skill${active === 1 ? "" : "s"} enabled for new tasks.` : "No skills enabled for this project."} Active tasks keep their saved versions.</p>${add}${search}${cards || "<p>Your library is empty. Add a skill to review and enable it here.</p>"}${history}</section>`;
 }

package/dist/store.d.ts

@@ -19,6 +19,10 @@ 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;
@@ -944,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
@@ -1544,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 = {
@@ -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

@@ -71,6 +71,7 @@ import { CHECKOUT_CLEANUP_SCHEMA, DEFAULT_CLEANUP, cleanupWords } from "./storag
 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 { 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,
@@ -131,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. */
@@ -582,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",
@@ -3690,6 +3744,7 @@ 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);
@@ -3701,6 +3756,7 @@ function initializeStore(db, file) {
     // 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).
@@ -3709,6 +3765,13 @@ 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);
+    // A pull request a flow's Pull request zone opened: the zone follows its CI, so Complete's follower leaves it alone.
+    addColumn(db, "pull_request_follow", "flow_card", "INTEGER REFERENCES flow_card(id)");
     addColumn(db, "flow_card", "source_json", "TEXT");
     addColumn(db, "flow_card", "owner", "TEXT");
     addColumn(db, "flow", "owner", "TEXT");
@@ -18108,9 +18171,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) ----------------------------------
@@ -21522,6 +21585,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))
@@ -21615,6 +21683,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());
     }
@@ -22430,6 +22569,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) {

package/dist/surface.js

@@ -118,6 +118,8 @@ export const COMMAND_GUIDE = [
     ...MODELS_DESCRIPTORS.map(spec => ({ invocation: `models ${spec.action}`, synopsis: spec.synopsis, audience: "agent", agentMayInvoke: true, mutation: spec.mutation, flags: spec.flags, ...(spec.takesQuery ? { positionals: [{ name: "target", required: true, meaning: "the CLI to update, or on/off" }] } : {}) })),
     // ---- the queue (agent surface) ----
     { invocation: "status", synopsis: "running work, queued reasons, results to review, the latest release check and plan windows", audience: "agent", agentMayInvoke: true, mutation: "none", flags: [jsonFlag, dbFlag] },
+    { invocation: "integrations", synopsis: "every integration as Connected, Not set up or Broken, with its last success and error, what uses it and what to do; --saved skips new checks; never a secret", audience: "agent", agentMayInvoke: true, mutation: "none",
+        flags: [jsonFlag, dbFlag, { name: "saved", takesValue: false, meaning: "show the last checks without checking again" }] },
     { invocation: "ready", synopsis: "what could be dispatched right now (rows carry reservedFor)", audience: "agent", agentMayInvoke: true, mutation: "none", flags: [jsonFlag, dbFlag] },
     { invocation: "brief", synopsis: "with a saved central profile, --lead <id> --conversation <id> reads messages, proposals and saved work; --request-id inspects your saved receipt without resending; --local uses local DB catch-up, where --history selects the older operational report", audience: "agent", agentMayInvoke: true, mutation: "none", flags: [jsonFlag, dbFlag] },
     { invocation: "gaps", synopsis: "requirement gaps blocking dispatch", audience: "agent", agentMayInvoke: true, mutation: "none", flags: [jsonFlag, dbFlag, repoFlag] },
@@ -349,6 +351,6 @@ export const COMMAND_GUIDE = [
     operator("serve", "the operations console (HTTP)"),
     operator("watch", "the unattended loop, kept running"),
     operator("up", "console + worker + browser, one command"),
-    operator("onboard", "add this repository, report signed-in agents, install or --remove the operator skill (--yes), and print the handoff"),
+    operator("onboard", "add this repository, report signed-in agents, install or --remove the operator skill (--yes), offer the starter flows (--starter <ids>), and print the handoff"),
     operator("daemon", "install the loop under the OS service manager"),
 ];

package/dist/telegram-progress.d.ts

@@ -11,4 +11,5 @@ export declare function telegramProgressCard(store: Store, run: Run, taskId: str
     text: string;
     entities: ProgressEntity[];
     link: PhoneTaskLink;
+    next: string;
 };

package/dist/telegram-progress.js

@@ -123,7 +123,7 @@ export function telegramProgressCard(store, run, taskId, project, now = new Date
         ...(next ? ["", next] : []),
         ...(acceptance === null ? [] : [acceptance]),
         ...(delivery === null ? [] : ["", delivery]), "", `${projectLabel(project)} · #${run.id}`].join("\n");
-    return { text, entities: [{ type: "bold", offset: 0, length: title.length }, { type: "bold", offset: title.length + 1, length: heading.length }],
+    return { text, next, entities: [{ type: "bold", offset: 0, length: title.length }, { type: "bold", offset: title.length + 1, length: heading.length }],
         link: { label, path: operatorHold || accessBlocked || (!built && run.outcome !== null)
                 ? chatControlHref("recovery", taskId) : built ? chatResultHref(taskId, run.id, checksFailed ? "checks" : "summary") : chatControlHref("task", taskId) } };
 }

package/dist/telegram.js

@@ -29,6 +29,7 @@ import { join } from "node:path";
 import { validateNote } from "./decision.js";
 import { isLifecycleNotification, isTelegramProgressNotification, TELEGRAM_HOLD_REASONS } from "./store.js";
 import { telegramProgressCard } from "./telegram-progress.js";
+import { enqueueEveningDigests, isTaskFact, needsPerson, quietCardView, readyPingView } from "./chat-quiet.js";
 import { applyTeamInbound, deliverTeamChats, teamCommand } from "./telegram-team.js";
 import { applyFlowReply, applyFlowTap, FLOW_DECIDE_KEY, flowButtons, flowDecisionAt } from "./telegram-flow.js";
 import { connectChannel, FLOW_WORDS, takeChannelMessage, watchedChannel } from "./chat-inbox.js";
@@ -519,6 +520,8 @@ async function processConversations(store, botId, transport, owner, clock, repor
 function factLinkLabel(path) {
     if (/^\/review\?result=[^&]+&run=\d+&tab=checks$/.test(path))
         return "Inspect result";
+    if (/^\/t\/[^?#]+#merge$/.test(path))
+        return "Merge";
     if (/^\/chat\?task=[^&]+&result=/.test(path))
         return "Open result";
     if (/^\/(?:chat\?task=|t\/)/.test(path))
@@ -563,6 +566,13 @@ async function deliverOutbox(store, botId, transport, owner, clock, report, read
     }
     const digest = store.telegramDigest();
     const now = clock();
+    // An evening digest someone asked for is due: record it as their own notification, delivered below.
+    try {
+        enqueueEveningDigests(store, now, evidenceRoot);
+    }
+    catch {
+        report.problems.push("evening digest could not be prepared");
+    }
     const digestDue = digest.everyMs === null || digest.lastSentAt === null || now.getTime() >= new Date(digest.lastSentAt).getTime() + digest.everyMs;
     // Every paired person is a destination of their own: each binding claims
     // and settles its own rows under its own ceiling, in turn.
@@ -571,13 +581,16 @@ async function deliverOutbox(store, botId, transport, owner, clock, report, read
 }
 async function deliverOutboxTo(store, botId, binding, transport, owner, clock, report, digest, digestDue, readProjects, canDeliver, phoneOrigin, evidenceRoot) {
     const now = clock();
-    const claimed = store.claimTelegramDeliveries(binding, owner, DELIVERY_CLAIM_MS, now, digestDue ? "all" : "urgent");
+    // Only when I'm needed (the default): a task's facts edit its one card and only what needs this person makes a
+    // new message, so the installation's routine-fact cadence does not apply. Every step keeps today's behaviour.
+    const quiet = store.notificationPreference(binding.approver).mode === "quiet";
+    const claimed = store.claimTelegramDeliveries(binding, owner, DELIVERY_CLAIM_MS, now, quiet || digestDue ? "all" : "urgent");
     // Preserve ID order, flushing earlier routine facts before an urgent task
     // update. An earlier failed/retrying row also fences later rows for that task.
     const groups = [];
     for (const row of claimed) {
         const last = groups[groups.length - 1];
-        if (digest.everyMs !== null && !isUrgent(row) && last !== undefined && !isUrgent(last[0]))
+        if (!quiet && digest.everyMs !== null && !isUrgent(row) && last !== undefined && !isUrgent(last[0]))
             last.push(row);
         else
             groups.push([row]);
@@ -638,12 +651,12 @@ async function deliverOutboxTo(store, botId, binding, transport, owner, clock, r
             }
             return null;
         };
-        const sender = async (text, keyboard, messageRows = rows, entities) => {
+        const sender = async (text, keyboard, messageRows = rows, entities, silent) => {
             // Finish every await before the synchronous fence and transport call.
             const problem = (await readAccess()) ?? fence();
             if (problem !== null)
                 return { ok: false, error: problem };
-            const sent = await send(transport, binding.chatId, text, keyboard, entities);
+            const sent = await send(transport, binding.chatId, text, keyboard, entities, silent);
             if (!sent.ok) {
                 if (sent.retryAfter !== undefined)
                     store.deferTelegram(botId, new Date(clock().getTime() + sent.retryAfter * 1_000).toISOString());
@@ -694,7 +707,7 @@ async function deliverOutboxTo(store, botId, binding, transport, owner, clock, r
             const after = (await readAccess()) ?? fence();
             return after === null ? { ok: true, receipt: receiptFor(botId, binding.chatId, String(messageId)) } : { ok: false, error: after };
         };
-        const batched = digest.everyMs !== null && !isUrgent(rows[0]);
+        const batched = !quiet && digest.everyMs !== null && !isUrgent(rows[0]);
         const row = rows[0];
         const progressRun = batched ? null : store.telegramProgressRun(row);
         const progress = progressRun !== null && isTelegramProgressNotification(row);
@@ -731,15 +744,80 @@ async function deliverOutboxTo(store, botId, binding, transport, owner, clock, r
             const after = (await readAccess()) ?? fence();
             return after === null ? edited : { ok: false, error: after };
         };
-        // A failure or decision still gets its own alert. Refresh an existing
-        // card first so it does not keep saying the build is running.
-        if (!progress && progressRun !== null)
-            await updateProgress(true);
-        const updated = progress ? await updateProgress(false) : null;
-        const outcome = updated !== null ? updated.ok ? { ok: true, receipt: receiptFor(botId, binding.chatId, updated.messageId) } : updated
-            : rows[0].kind === "acceptance-evidence" ? await imageSender(rows[0]) : batched
-                ? await deliverDigest(botId, binding, sender, rows, digest.lastSentAt, clock)
-                : await deliverOne(store, botId, binding, sender, rows[0], clock, phoneOrigin, evidenceRoot, projects);
+        /** Quiet mode: the task's one card (or its group's), created silently and then only ever edited. */
+        const updateCard = async (fact) => {
+            const problem = (await readAccess()) ?? fence();
+            if (problem !== null)
+                return { ok: false, error: problem };
+            const card = store.chatCardFor(fact.destination, fact.taskRef, store.getTask(fact.taskId)?.createdAt ?? fact.createdAt, clock());
+            const view = quietCardView(store, card.tasks, clock(), evidenceRoot);
+            if (view === null)
+                return { ok: true, messageId: card.message };
+            let button = null;
+            try {
+                button = phoneLinkButton(phoneOrigin?.() ?? null, view.link);
+            }
+            catch { /* No trusted origin. */ }
+            const keyboard = button === null ? [] : [button];
+            const shown = createHash("sha256").update(JSON.stringify([view.text, view.entities, keyboard])).digest("hex");
+            if (card.message !== null && card.digest === shown) {
+                store.recordTelegramMessage(fact, binding, card.message, clock());
+                return { ok: true, messageId: card.message };
+            }
+            if (card.message !== null) {
+                const edited = await editProgress(transport, binding.chatId, card.message, view.text, keyboard, view.entities);
+                if (edited.ok) {
+                    store.setChatCardMessage(card.id, card.message, shown);
+                    store.recordTelegramMessage(fact, binding, card.message, clock());
+                    const after = (await readAccess()) ?? fence();
+                    return after === null ? edited : { ok: false, error: after };
+                }
+                if (edited.retryAfter !== undefined)
+                    store.deferTelegram(botId, new Date(clock().getTime() + edited.retryAfter * 1000).toISOString());
+                // Only Telegram's definitive missing/uneditable answer permits a replacement card.
+                if (!edited.replace)
+                    return edited;
+            }
+            const sent = await sender(view.text, keyboard, [fact], view.entities, true);
+            // A card that reached the chat is kept even if a later fence refused the acknowledgement: never a second card.
+            const placed = sent.ok ? sent.messageId : store.telegramMessageOf(fact.id, fact.destination);
+            if (placed !== null)
+                store.setChatCardMessage(card.id, placed, shown);
+            return sent;
+        };
+        const quietOutcome = async (fact) => {
+            const card = await updateCard(fact);
+            if (!card.ok)
+                return card;
+            if (!needsPerson(fact))
+                return { ok: true, receipt: receiptFor(botId, binding.chatId, card.messageId) };
+            const readyRun = fact.kind === "run-finished" ? store.telegramProgressRun(fact) : null;
+            if (readyRun !== null) {
+                const ping = readyPingView(store, store.getRun(readyRun.id), fact.taskId, fact.project, clock(), evidenceRoot);
+                let button = null;
+                try {
+                    button = phoneLinkButton(phoneOrigin?.() ?? null, ping.link);
+                }
+                catch { /* No trusted origin. */ }
+                const sent = await sender(ping.text, button === null ? undefined : [button], [fact], ping.entities);
+                return sent.ok ? { ok: true, receipt: receiptFor(botId, binding.chatId, sent.messageId) } : sent;
+            }
+            return fact.kind === "acceptance-evidence" ? imageSender(fact) : deliverOne(store, botId, binding, sender, fact, clock, phoneOrigin, evidenceRoot, projects);
+        };
+        let outcome;
+        if (quiet && rows.length === 1 && isTaskFact(row))
+            outcome = await quietOutcome(row);
+        else {
+            // A failure or decision still gets its own alert. Refresh an existing
+            // card first so it does not keep saying the build is running.
+            if (!progress && progressRun !== null)
+                await updateProgress(true);
+            const updated = progress ? await updateProgress(false) : null;
+            outcome = updated !== null ? updated.ok ? { ok: true, receipt: receiptFor(botId, binding.chatId, updated.messageId) } : updated
+                : rows[0].kind === "acceptance-evidence" ? await imageSender(rows[0]) : batched
+                    ? await deliverDigest(botId, binding, sender, rows, digest.lastSentAt, clock)
+                    : await deliverOne(store, botId, binding, sender, rows[0], clock, phoneOrigin, evidenceRoot, projects);
+        }
         const finalProblem = outcome.ok ? (await readAccess()) ?? fence() : null;
         const settled = finalProblem === null ? outcome : { ok: false, error: finalProblem };
         // A skipped screenshot settles its row but nothing reached the phone.
@@ -934,7 +1012,7 @@ async function deliverOne(store, botId, binding, sender, notification, clock, ph
     }
     return { ok: true, receipt: receiptFor(botId, binding.chatId, sent.messageId) };
 }
-async function send(transport, chatId, text, keyboard, entities) {
+async function send(transport, chatId, text, keyboard, entities, silent) {
     // No markup parsing. Only machine-selected heading ranges may be bold;
     // agent text remains literal and URLs never trigger link previews.
     let answer;
@@ -944,6 +1022,8 @@ async function send(transport, chatId, text, keyboard, entities) {
             text,
             ...(entities === undefined ? {} : { entities }),
             link_preview_options: { is_disabled: true },
+            // A new quiet card arrives without a sound; only a ping should buzz.
+            ...(silent === true ? { disable_notification: true } : {}),
             ...(keyboard === undefined ? {} : { reply_markup: { inline_keyboard: keyboard } }),
         });
     }

package/dist/when-html.d.ts

@@ -0,0 +1,8 @@
+/** "16:39" today, "Yesterday 16:39" / "Tomorrow 16:39" beside it, "Sep 28" otherwise ("Sep 28 2025" in another year). */
+export declare function shortWhen(iso: string, now?: Date): string;
+/** The `<time>` for a stamp: `full` is the words a desk shows ("2026-09-30 16:39 UTC"). Empty for no stamp. */
+export declare function whenHtml(iso: string | null, full: string, now?: Date): string;
+/** "2026-09-30 16:39 UTC" — the desk's words for a stamp. */
+export declare const utcMinute: (iso: string) => string;
+/** Both the desk and phone forms of a UTC stamp. */
+export declare const whenUtc: (iso: string | null, now?: Date) => string;

package/dist/when-html.js

@@ -0,0 +1,36 @@
+/**
+ * A time a person reads. A desk shows the full stamp, as before; a phone (760px and narrower) shows the short
+ * one — "16:39" today, "Yesterday 16:39", "Sep 28" otherwise — and the full stamp stays in the title. Stamps are
+ * UTC to the minute, so the short form is counted in UTC too. The CSS that picks one lives in the shared page
+ * stylesheet (`.so-when-*` in serve.ts).
+ */
+const escape = (value) => value.replace(/[&<>"']/g, c => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
+const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+const DAY_MS = 86_400_000;
+/** "16:39" today, "Yesterday 16:39" / "Tomorrow 16:39" beside it, "Sep 28" otherwise ("Sep 28 2025" in another year). */
+export function shortWhen(iso, now = new Date()) {
+    const at = new Date(iso);
+    if (Number.isNaN(at.getTime()))
+        return iso;
+    const clock = iso.length >= 16 && iso[10] === "T" ? iso.slice(11, 16) : at.toISOString().slice(11, 16);
+    const days = Math.floor(at.getTime() / DAY_MS) - Math.floor(now.getTime() / DAY_MS);
+    if (days === 0)
+        return clock;
+    if (days === -1)
+        return `Yesterday ${clock}`;
+    if (days === 1)
+        return `Tomorrow ${clock}`;
+    const date = `${MONTHS[at.getUTCMonth()]} ${at.getUTCDate()}`;
+    return at.getUTCFullYear() === now.getUTCFullYear() ? date : `${date} ${at.getUTCFullYear()}`;
+}
+/** The `<time>` for a stamp: `full` is the words a desk shows ("2026-09-30 16:39 UTC"). Empty for no stamp. */
+export function whenHtml(iso, full, now = new Date()) {
+    if (iso === null || iso === "")
+        return "";
+    const words = escape(full);
+    return `<time datetime="${escape(iso)}" title="${words}"><span class="so-when-full">${words}</span><span class="so-when-short">${escape(shortWhen(iso, now))}</span></time>`;
+}
+/** "2026-09-30 16:39 UTC" — the desk's words for a stamp. */
+export const utcMinute = (iso) => `${iso.slice(0, 16).replace("T", " ")} UTC`;
+/** Both the desk and phone forms of a UTC stamp. */
+export const whenUtc = (iso, now = new Date()) => iso === null || iso === "" ? "" : whenHtml(iso, utcMinute(iso), now);