toolroll 0.8.1 → 0.9.0

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] },

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/toolroll-update-ui.d.ts

@@ -24,6 +24,8 @@ export type UpdatesView = {
         version: string;
         notes: string[];
     } | null;
+    /** The version `toolroll update --rollback` returns to: the last completed update's, while it is what runs. */
+    rollbackTo: string | null;
     csrf: string;
 };
 /** The steps, each done, current, failed or waiting. Also the live region's fragment. */

package/dist/toolroll-update-ui.js

@@ -70,7 +70,7 @@ export function updatesHtml(view, notice) {
             `<div class="update-actions"><button type="submit" name="when" value="now" class="primary">Update now</button>` +
             `<button type="submit" name="when" value="when-idle">When idle</button><button type="submit" name="when" value="tonight">Tonight (03:00)</button></div></form>`
         : "";
-    const rollback = j?.kind === "update" && j.phase === "complete" ? `<p class="meta">To go back to ${e(j.from.version)}: <code>toolroll update --rollback</code></p>` : "";
+    const rollback = view.rollbackTo !== null ? `<p class="meta">To go back to ${e(view.rollbackTo)}: <code>toolroll update --rollback</code></p>` : "";
     return `<section class="updates">${note}${whatsNew}${j ? outcomeHtml(j) : ""}<div class="card" data-update-state="${newer ? "available" : "current"}">${state}${form}${rollback}</div></section>`;
 }
 export function newerThan(a, b) {

package/dist/toolroll-update.d.ts

@@ -67,10 +67,12 @@ export type RuntimeUpdateJournal = {
         unit: string;
         pids: number[];
     };
-    /** Each repo's watch daemon that runs this version, recorded the same way: stopped, switched and restarted with the service. */
+    /** Each repo's watch daemon that runs this version, recorded the same way: switched with the service, and stopped and
+     * restarted with it only when launchd had it loaded before the update (`loaded` absent: 0.8.1 stopped every one). */
     watches?: {
         unit: string;
         pids: number[];
+        loaded?: boolean;
     }[];
     /** Recorded before each change so a resumed or failed run knows what to put back. */
     switched?: {
@@ -88,10 +90,15 @@ export type RuntimeUpdateJournal = {
         }[];
         databaseRestored?: boolean;
     };
-    /** What the live database held when a failed run restored its backup: nothing written is lost. */
+    /** What the live database held when a failed run restored its backup: nothing written is lost. The newest of `kept`. */
     keptAside?: string;
     /** The live database could not be read, so it was moved aside whole rather than copied. */
     keptAsideUnreadable?: boolean;
+    /** Every copy kept aside, oldest first: a retried restore adds one and never drops the pointer to an earlier one. */
+    kept?: {
+        path: string;
+        unreadable: boolean;
+    }[];
     /** The restore put the backup back: a retried restore never puts it back again (what was written since belongs to
      * the restored version and would be lost), and it keeps a fresh copy aside before every attempt until then. */
     restoredDatabase?: boolean;
@@ -129,6 +136,8 @@ export type UpdateSystem = {
     }) => Promise<void>;
     /** The processes the service runs now. */
     servicePids: (unit: string) => Promise<number[]>;
+    /** Whether launchd has the service loaded now. */
+    serviceLoaded: (unit: string) => Promise<boolean>;
     /** Unload the service; resolves once launchd no longer has it. */
     stopService: (unit: string) => Promise<void>;
     /** Load and start the service from its definition on disk. */
@@ -138,8 +147,11 @@ export type UpdateSystem = {
     healthTimeoutMs?: number;
     /** How long stopped service processes may take to exit. */
     exitTimeoutMs?: number;
-    /** Fault injection for state-machine tests, never selectable by a flag. */
-    checkpoint?: (phase: RuntimePhase) => void;
+    /** Bytes free for this user in the folder `dir` is on. */
+    freeBytes?: (dir: string) => number;
+    /** Fault injection for state-machine tests, never selectable by a flag. `kept-aside`: the live database was just
+     * kept aside, before the backup is put back. */
+    checkpoint?: (phase: RuntimePhase | "kept-aside") => void;
 };
 export type UpdateOutcome = {
     ok: boolean;
@@ -211,7 +223,10 @@ export declare function startRuntimeRollback(o: {
 export declare function resumeRuntimeUpdate(stateDir: string, system: UpdateSystem, id?: string): Promise<UpdateOutcome>;
 /** A prepared update whose job could not start. */
 export declare function abandonRuntimeUpdate(stateDir: string, id: string, why: string, now: Date): void;
-export declare function requestRuntimeUpdateCancel(stateDir: string, now?: Date): string;
+/** `locked`: a test's seam, called once the updater's lock is held and before the journal is read again. */
+export declare function requestRuntimeUpdateCancel(stateDir: string, now?: Date, seams?: {
+    locked?: () => void;
+}): string;
 /** Keep the newest release-* runtimes (and any in `keep`), at most KEEP_RUNTIMES; deploy-browser's browser-* and
  * the rollback-* records are not this updater's to remove. */
 export declare function pruneRuntimes(stateDir: string, keep: readonly string[]): string[];
@@ -223,6 +238,11 @@ export type RuntimeUpdateStatus = {
         version: string;
         notes: string[];
     } | null;
+    /** The last completed update `--rollback` returns from, whatever was attempted since. */
+    lastUpdate: {
+        from: string;
+        to: string;
+    } | null;
 };
 export declare function runtimeUpdateStatus(stateDir: string): RuntimeUpdateStatus;
 export declare function markWhatsNewSeen(stateDir: string): void;
@@ -261,7 +281,7 @@ export declare function launchRuntimeUpdate(args: {
     home?: string;
     run?: SupervisorRunner;
     platform?: NodeJS.Platform;
-    npmBin?: () => string | null;
+    npmBin?: () => Promise<string | null>;
 }): Promise<void>;
 /** The job's last act: its definition goes, so nothing can start it again. Only the definition for this id. */
 export declare function retireUpdateJob(id: string, home?: string): void;