toolroll 0.9.8 → 0.9.10

package/dist/telegram-progress.d.ts

@@ -1,5 +1,6 @@
 import { type PhoneTaskLink } from "./telegram-status.js";
 import type { Run, Store } from "./store.js";
+import { type TaskStatus, type TaskStatusFacts } from "./task-status.js";
 /** Offsets are UTF-16, as required by Telegram. Only our two headings are bold;
  * user text stays literal, including angle brackets and Markdown characters. */
 export type ProgressEntity = {
@@ -7,9 +8,13 @@ export type ProgressEntity = {
     offset: number;
     length: number;
 };
-export declare function telegramProgressCard(store: Store, run: Run, taskId: string, project: string, now?: Date, root?: string): {
+/** `viewer`: the person whose chat shows the card. Their own act is never told back to them. */
+export declare function telegramProgressCard(store: Store, run: Run, taskId: string, project: string, now?: Date, root?: string, viewer?: string): {
     text: string;
     entities: ProgressEntity[];
     link: PhoneTaskLink;
     next: string;
+    status: TaskStatus;
+    facts: TaskStatusFacts;
+    completedByLead: boolean;
 };

package/dist/telegram-progress.js

@@ -8,6 +8,7 @@ import { assignmentOf } from "./assignment.js";
 import { chatResultHref, chatControlHref } from "./chat-controls.js";
 import { phoneText, projectLabel } from "./telegram-status.js";
 import { assignmentStatusFacts, headlineEmoji, pullRequestFactOf, requirementsOf, statusDetailLines, taskStatusOf } from "./task-status.js";
+import { chatTitle } from "./chat-voice.js";
 import { manualReviewOnly } from "./proof.js";
 import { failedCheckExit } from "./workspace-ui.js";
 /** The saved assignment for this exact result, or null when the run is not
@@ -21,7 +22,8 @@ function assignmentFor(store, run, taskId, project, now, root) {
         return null;
     }
 }
-export function telegramProgressCard(store, run, taskId, project, now = new Date(), root) {
+/** `viewer`: the person whose chat shows the card. Their own act is never told back to them. */
+export function telegramProgressCard(store, run, taskId, project, now = new Date(), root, viewer) {
     const built = run.finishedAt !== null && (run.outcome === "built" || run.outcome === "no-change");
     const assignment = built ? assignmentFor(store, run, taskId, project, now, root) : null;
     const publication = store.publicationForRun(run.id);
@@ -72,20 +74,26 @@ export function telegramProgressCard(store, run, taskId, project, now = new Date
     else {
         facts = { stage: "failed", reason: "The build stopped before it finished. Inspect the blocker, then retry." };
     }
+    // "Marked complete by <you>" (or by your lead, which signs in as you) is never told back to you.
+    const completer = assignment?.completion?.actor.replace(/^(?:operator|coordinator|lead):/, "") ?? null;
+    if (viewer !== undefined && facts.completedBy != null && (completer === viewer || facts.completedBy === viewer))
+        facts = { ...facts, completedBy: null };
     const status = taskStatusOf(facts);
     const checkProgress = store.checkProgress(run.id);
     const progress = status.headline === "Building" && checkProgress !== null ? [`● ${checkProgress.line}`] : [];
-    const title = phoneText(store.getTask(taskId)?.title ?? taskId, 88);
+    // A short human title: never "— revision" or an id (chat-voice.ts).
+    const title = chatTitle(store, taskId);
     const heading = `${headlineEmoji(status.headline)} ${status.headline}`;
     const next = phoneText(status.sentence, 200);
     // A person's acceptance is its own recorded decision; it never changes a check.
     const acceptance = store.proofAcceptance(run.id) === null ? [] : [manualReviewOnly(store.proofVerdictFor(run.id))
             ? "Accepted by a person · Recorded checks unchanged" : "Accepted with an exception · Recorded checks unchanged"];
     const rows = [...statusDetailLines(status), ...progress, ...acceptance];
-    const text = [title, heading, next, ...(rows.length === 0 ? [] : ["", ...rows]), "", `${projectLabel(project)} · #${run.id}`].join("\n");
+    const text = [title, heading, next, ...(rows.length === 0 ? [] : ["", ...rows]), "", projectLabel(project)].join("\n");
     const failedChecks = status.details.some(one => one.key === "checks" && (one.mark === "failed" || one.mark === "note"));
     const recovery = operatorHold !== undefined || accessBlocked || (!built && run.outcome !== null);
-    return { text, next, entities: [{ type: "bold", offset: 0, length: title.length }, { type: "bold", offset: title.length + 1, length: heading.length }],
-        link: { label: built ? "Open result" : "Open task", path: recovery
+    return { text, next, status, facts, completedByLead: assignment?.completion?.lead === true, entities: [{ type: "bold", offset: 0, length: title.length }, { type: "bold", offset: title.length + 1, length: heading.length }],
+        // Needs you: the button names the action that resolves it.
+        link: { label: status.need != null && status.need.key !== "other" && status.need.key !== "review-result" ? status.need.action.label : built ? "Open result" : "Open task", path: recovery
                 ? chatControlHref("recovery", taskId) : built ? chatResultHref(taskId, run.id, failedChecks ? "checks" : "summary") : chatControlHref("task", taskId) } };
 }

package/dist/telegram-status.d.ts

@@ -72,4 +72,5 @@ export declare function phoneTaskView(store: Store, repos: readonly string[], id
     run: number | null;
 };
 /** Concise display only: authorization uses the stored full project identity. */
-export declare function notificationIdentity(row: Pick<Notification, "project" | "taskId">): string;
+/** Where a fact belongs: its project and, given one, the task's short title — never the task's id. */
+export declare function notificationIdentity(row: Pick<Notification, "project" | "taskId">, title?: string): string;

package/dist/telegram-status.js

@@ -3,7 +3,7 @@ import { manualReviewOnly } from "./proof.js";
 /** Read-only phone views over the same dispatch and proof records as chat.
  * No provider calls, repository access, new workflow state, or inferred success. */
 import { diagnoseTaskDispatch, withDispatchDiagnoses } from "./dispatch.js";
-import { COMPLETION_ACTION } from "./result-completion.js";
+import { familyCompleted } from "./result-completion.js";
 import { plainReasonOf, stageOfDispatch, taskStatusOf } from "./task-status.js";
 import { CHAT_CONTROLS, chatControlHref, chatResultHref } from "./chat-controls.js";
 export function phoneCommand(text) {
@@ -54,8 +54,8 @@ export function projectLabel(repo) {
 }
 /** The shared headline (task-status.ts) for a dispatch diagnosis on the phone. */
 function headlineFor(store, id, d) {
-    const completed = d.code === "complete" && store.handle.prepare("SELECT 1 FROM action_ledger WHERE task_id = ? AND action = ? AND source = 'work' LIMIT 1")
-        .get(store.taskFamilyOf(id, null, true)?.root.id ?? id, COMPLETION_ACTION) !== undefined;
+    // Any version of a completed family reads Complete, as taskWaitSnapshot says.
+    const completed = d.code === "complete" && familyCompleted(store, id);
     const read = stageOfDispatch(d, { completed });
     const finished = read.stage === "finished" || read.stage === "complete" || read.stage === "failed";
     return taskStatusOf({ stage: read.stage, ...(read.need === undefined ? {} : { need: read.need }), reason: finished ? null : plainReasonOf(read.stage, d.code, d.detail),
@@ -271,8 +271,9 @@ export function phoneTaskView(store, repos, id, now) {
     });
 }
 /** Concise display only: authorization uses the stored full project identity. */
-export function notificationIdentity(row) {
+/** Where a fact belongs: its project and, given one, the task's short title — never the task's id. */
+export function notificationIdentity(row, title) {
     if (row.project === null)
         return "";
-    return `${projectLabel(row.project)}${row.taskId === null ? "" : ` / ${plain(row.taskId, 64)}`} · `;
+    return `${projectLabel(row.project)}${row.taskId === null || title === undefined ? "" : ` / ${plain(title, 64)}`} · `;
 }

package/dist/telegram.d.ts

@@ -227,4 +227,4 @@ export declare function followBridge(store: Store, options: {
 /** The digest text: a header with the count and the window, then one
  * fact per entry — its subject, then its body's first line, indented.
  * Plain text, no buttons: nothing in a digest is tappable. */
-export declare function digestText(rows: readonly Notification[], since: string | null, now: Date): string;
+export declare function digestText(rows: readonly Notification[], since: string | null, now: Date, titleOf?: (taskId: string) => string): string;

package/dist/telegram.js

@@ -29,7 +29,8 @@ 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 { enqueueEveningDigests, finishedView, isTaskFact, joinsBatch, needsPerson, quietCardView } from "./chat-quiet.js";
+import { BATCH_MS, chatText, chatTitle, factLinkLabel, mentions, nameTelegramBot } from "./chat-voice.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";
@@ -438,6 +439,8 @@ export async function followBridge(store, options) {
                     await transport("setMyCommands", { commands: TELEGRAM_COMMANDS });
                 }
                 catch { /* typed commands still work */ }
+                // After an upgrade, a bot still called StandingOrders becomes Toolroll, once per start; any other name is kept.
+                await nameTelegramBot(transport, "upgrade");
             }
             const startedAt = Date.now();
             const report = { sent: 0, answered: 0, paired: 0, ignored: 0, backlog: false, problems: [] };
@@ -514,21 +517,25 @@ async function processConversations(store, botId, transport, owner, clock, repor
         report.chatRefused = (report.chatRefused ?? 0) + chat.refused;
     report.problems.push(...chat.problems);
 }
-/** The one button a plain fact may carry: its machine-minted console path
- * under the trusted origin read now — the same road `/task` uses. The label
- * names where the path goes; nothing in it comes from the fact's text. */
-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))
-        return "Open task";
-    if (/^\/d\//.test(path))
-        return "Open decision";
-    return "Open console";
+/** A fact's own next-action button row under the trusted origin read now; none without one. */
+function factButton(phoneOrigin, link) {
+    try {
+        return phoneLinkButton(phoneOrigin?.() ?? null, { label: factLinkLabel(link), path: link });
+    }
+    catch {
+        return null;
+    }
+}
+/** A view's buttons on one row: its link, then any others ([Merge] [Look first]); none without a trusted origin. */
+function viewKeyboard(phoneOrigin, view) {
+    try {
+        const origin = phoneOrigin?.() ?? null;
+        const row = [view.link, ...(view.also ?? [])].flatMap(link => phoneLinkButton(origin, link) ?? []);
+        return row.length === 0 ? [] : [row];
+    }
+    catch {
+        return [];
+    }
 }
 /** Team-conversation traffic to the chats that follow one — after the outbox, under the same delivery switch, never a problem to raise when nothing follows anything. */
 async function deliverTeam(store, botId, transport, clock, report, readProjects, canDeliver, phoneOrigin) {
@@ -720,7 +727,7 @@ async function deliverOutboxTo(store, botId, binding, transport, owner, clock, r
             const messageId = store.telegramProgressMessage(binding, progressRun);
             if (messageId === null && onlyExisting)
                 return null;
-            const card = telegramProgressCard(store, store.getRun(progressRun.id), row.taskId, row.project, clock(), evidenceRoot);
+            const card = telegramProgressCard(store, store.getRun(progressRun.id), row.taskId, row.project, clock(), evidenceRoot, binding.approver);
             let button = null;
             try {
                 button = phoneLinkButton(phoneOrigin?.() ?? null, card.link);
@@ -750,7 +757,7 @@ async function deliverOutboxTo(store, botId, binding, transport, owner, clock, r
             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);
+            const view = quietCardView(store, card.tasks, clock(), evidenceRoot, binding.approver);
             if (view === null)
                 return { ok: true, messageId: card.message };
             let button = null;
@@ -792,14 +799,55 @@ async function deliverOutboxTo(store, botId, binding, transport, owner, clock, r
             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);
+            if (readyRun !== null || (fact.kind !== "run-finished" && joinsBatch(fact))) {
+                // Any update for this person joins their open batch: one message, edited in place while it grows.
+                const batch = store.chatBatchFor(fact.destination, fact.taskRef, readyRun?.id ?? store.telegramProgressRun(fact)?.id ?? null, clock(), BATCH_MS, readyRun !== null ? null : fact.id);
+                // A lone update that is not finished work goes out exactly as it always has; a later one edits it in place.
+                const lone = batch.items.length === 1 && batch.items[0].notification !== null;
+                if (batch.message === null && lone) {
+                    const sent = await deliverOne(store, botId, binding, sender, fact, clock, phoneOrigin, evidenceRoot, projects);
+                    const placed = store.telegramMessageOf(fact.id, fact.destination);
+                    if (placed !== null)
+                        store.setChatBatchMessage(batch.id, placed, "");
+                    return sent;
                 }
-                catch { /* No trusted origin. */ }
-                const sent = await sender(ping.text, button === null ? undefined : [button], [fact], ping.entities);
+                const view = finishedView(store, batch, clock(), evidenceRoot, binding.approver);
+                // Nothing in the batch reads as a line. Finished work left out on purpose (a release check, a replaced task,
+                // the reader's own completion) stays quiet; any other update that needs this person still reaches them alone.
+                if (view === null) {
+                    if (readyRun !== null)
+                        return { ok: true, receipt: receiptFor(botId, binding.chatId, card.messageId) };
+                    return deliverOne(store, botId, binding, sender, fact, clock, phoneOrigin, evidenceRoot, projects);
+                }
+                // While a lone update is still the only item, its edit keeps that update's own action button.
+                const own = lone && fact.link !== null ? factButton(phoneOrigin, fact.link) : null;
+                const keyboard = own !== null ? [own] : viewKeyboard(phoneOrigin, view);
+                const shown = createHash("sha256").update(JSON.stringify([view.text, keyboard])).digest("hex");
+                if (batch.message !== null) {
+                    if (batch.digest === shown) {
+                        store.recordTelegramMessage(fact, binding, batch.message, clock());
+                        return { ok: true, receipt: receiptFor(botId, binding.chatId, batch.message) };
+                    }
+                    const problem = (await readAccess()) ?? fence();
+                    if (problem !== null)
+                        return { ok: false, error: problem };
+                    const edited = await editProgress(transport, binding.chatId, batch.message, view.text, keyboard);
+                    if (edited.ok) {
+                        store.setChatBatchMessage(batch.id, batch.message, shown);
+                        store.recordTelegramMessage(fact, binding, batch.message, clock());
+                        const after = (await readAccess()) ?? fence();
+                        return after === null ? { ok: true, receipt: receiptFor(botId, binding.chatId, batch.message) } : { 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 new message.
+                    if (!edited.replace)
+                        return edited;
+                }
+                const sent = await sender(view.text, keyboard.length === 0 ? undefined : keyboard, [fact]);
+                const placed = sent.ok ? sent.messageId : store.telegramMessageOf(fact.id, fact.destination);
+                if (placed !== null)
+                    store.setChatBatchMessage(batch.id, placed, shown);
                 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);
@@ -815,7 +863,7 @@ async function deliverOutboxTo(store, botId, binding, transport, owner, clock, r
             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 deliverDigest(botId, binding, sender, rows, digest.lastSentAt, clock, taskId => chatTitle(store, taskId))
                     : await deliverOne(store, botId, binding, sender, rows[0], clock, phoneOrigin, evidenceRoot, projects);
         }
         const finalProblem = outcome.ok ? (await readAccess()) ?? fence() : null;
@@ -850,26 +898,29 @@ function isUrgent(notification) {
 /** The digest text: a header with the count and the window, then one
  * fact per entry — its subject, then its body's first line, indented.
  * Plain text, no buttons: nothing in a digest is tappable. */
-export function digestText(rows, since, now) {
+export function digestText(rows, since, now, titleOf) {
     const window = since === null ? "" : ` since ${since.slice(0, 16).replace("T", " ")}`;
     const lines = [`digest — ${rows.length} routine fact(s)${window} (as of ${now.toISOString().slice(0, 16).replace("T", " ")})`, ""];
     for (const row of rows) {
-        lines.push(digestEntry(row));
+        lines.push(digestEntry(row, titleOf));
     }
     return lines.join("\n");
 }
-function digestEntry(row) {
+function digestEntry(row, titleOf) {
+    const title = row.taskId === null ? undefined : titleOf?.(row.taskId);
+    const task = row.taskId === null ? [] : [{ id: row.taskId, ...(title === undefined ? {} : { title }) }];
+    const subject = chatText(row.subject, task);
     const first = row.body.split("\n").map(one => one.trim()).find(one => one !== "");
     const body = first === undefined ? "" : `\n    ${first.length > 200 ? `${first.slice(0, 200).replace(/[\uD800-\uDBFF]$/, "")}…` : first}`;
-    return `• ${notificationIdentity(row)}${row.subject}${body}`;
+    return `• ${notificationIdentity(row, title !== undefined && mentions(subject, title) ? undefined : title)}${subject}${chatText(body, task)}`;
 }
-async function deliverDigest(botId, binding, sender, rows, since, clock) {
-    const text = digestText(rows, since, clock());
+async function deliverDigest(botId, binding, sender, rows, since, clock, titleOf) {
+    const text = digestText(rows, since, clock(), titleOf);
     // Track the exact rows represented by each text part. A split row may bind
     // several messages; a digest message may bind several rows.
     let offset = text.indexOf("\n\n") + 2;
     const spans = rows.map(row => {
-        const length = digestEntry(row).length;
+        const length = digestEntry(row, titleOf).length;
         const span = { row, start: offset, end: offset + length };
         offset += length + 1;
         return span;
@@ -917,16 +968,13 @@ async function deliverOne(store, botId, binding, sender, notification, clock, ph
             else
                 body = `${packet.text}\n\n${notification.body}`;
         }
-        const parts = split(`${notificationIdentity(notification)}${alreadyAccepted ? "Acceptance recorded" : notification.subject}\n\n${body}`);
-        let button = null;
-        if (notification.link !== null && !alreadyAccepted && current) {
-            try {
-                button = phoneLinkButton(phoneOrigin?.() ?? null, { label: factLinkLabel(notification.link), path: notification.link });
-            }
-            catch {
-                button = null;
-            }
-        }
+        // A short title, never the task's id or a "— revision" suffix (chat-voice.ts).
+        const title = notification.taskId === null ? undefined : chatTitle(store, notification.taskId);
+        const task = notification.taskId === null ? [] : [{ id: notification.taskId, ...(title === undefined ? {} : { title }) }];
+        const words = chatText(`${alreadyAccepted ? "Acceptance recorded" : notification.subject}${body === "" ? "" : `\n\n${body}`}`, task);
+        // The task's title once: in front, unless the words already name it.
+        const parts = split(`${notificationIdentity(notification, title !== undefined && mentions(words, title) ? undefined : title)}${words}`);
+        const button = notification.link !== null && !alreadyAccepted && current ? factButton(phoneOrigin, notification.link) : null;
         // A flow card waiting on a decision (v86): Approve, Edit, Send back on the last part, for this visit only.
         const visit = FLOW_DECIDE_KEY.exec(notification.dedupeKey);
         const waiting = visit === null ? null : flowDecisionAt(store, Number(visit[1]), Number(visit[2]));
@@ -1403,6 +1451,8 @@ function applyMessage(context, update, effects) {
             text: `paired: this chat now answers as ${approver}\n\nSend /status to check recent work, /task <id> for one task, or /help for your options.`,
             link_preview_options: { is_disabled: true },
         });
+        // The bot is Toolroll in every chat list from here on (best effort; pairing never waits on it).
+        await nameTelegramBot(transport, "pairing");
     });
 }
 /**

package/dist/test-temp.d.ts

@@ -0,0 +1,19 @@
+/** Name prefixes of what tests, journeys and scripts leave in the temp folder. */
+export declare const TEST_TEMP_PREFIXES: readonly string[];
+export declare function isTestTemp(name: string): boolean;
+/** Where they collect: the temp folder (and /tmp, where some scripts write). */
+export declare function tempRoots(): string[];
+export type TempLeftover = {
+    path: string;
+    touchedAt: number;
+};
+/** Every test temp folder in `roots`, and which of them nothing has touched for a day. */
+export declare function testTempFolders(roots: readonly string[], now: Date): {
+    all: TempLeftover[];
+    stale: TempLeftover[];
+};
+/** Remove the test temp folders nothing has touched for a day; each is looked at again right before it goes. */
+export declare function removeStaleTestTemp(roots: readonly string[], now: Date): {
+    removed: string[];
+    failed: string[];
+};

package/dist/test-temp.js

@@ -0,0 +1,98 @@
+/**
+ * Test temp folders (`toolroll storage`, `storage clean`): what the unit tests, journeys and scripts make in the
+ * system temp folder. The tests delete their own (each run gets one temp root that its global teardown removes:
+ * test/temp-root.ts); a run that was killed, and older versions, leave folders behind. `toolroll storage` counts them
+ * and `storage clean` removes the ones nothing has touched for a day.
+ *
+ * Every prefix the tests and scripts give tmpdir() is covered here (test-temp.test.ts reads the sources to keep it
+ * so), and Playwright's own browser profiles.
+ */
+import { lstatSync, readdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+const DAY_MS = 86_400_000;
+/** Name prefixes of what tests, journeys and scripts leave in the temp folder. */
+export const TEST_TEMP_PREFIXES = [
+    "so-", "standing-orders-", "toolroll-", "no-wt", "epoch", "cancel-floor",
+    "attest-", "budgets-", "chat-v66-", "check-levels-", "coding-context-", "console-url-", "console-v2-", "e2-attest-",
+    "flow-goal-", "flow-scratch", "flows-chat-", "invoke-attest-", "knowledge-test-", "learning-", "peek-", "phone-origin-",
+    "proposal-repo-", "race-", "refresh-migration-", "refresh-refusal-", "release-check-", "shared-chat-", "skills-test-",
+    "task-status-surfaces-", "template-repo-", "template-test-", "v14-migrate-", "v17-migrate-", "watch-anchor-",
+    "needs-you-", "deps-lock-", "deps-state-", "upgrade-fresh-", "upgrade-path-",
+    // Playwright's browser profiles and artifacts.
+    "playwright_chromiumdev_profile-", "playwright_firefoxdev_profile-", "playwright-artifacts-",
+];
+export function isTestTemp(name) {
+    return TEST_TEMP_PREFIXES.some(prefix => name.startsWith(prefix));
+}
+/** Where they collect: the temp folder (and /tmp, where some scripts write). */
+export function tempRoots() {
+    const roots = [tmpdir()];
+    if (process.platform !== "win32" && !roots.includes("/tmp"))
+        roots.push("/tmp");
+    return roots;
+}
+/** When anything last happened in a folder: it, or what is directly in it, last changed. */
+function touchedAt(path) {
+    let newest = lstatSync(path).mtimeMs;
+    let names = [];
+    try {
+        names = readdirSync(path);
+    }
+    catch {
+        return newest;
+    }
+    for (const name of names) {
+        try {
+            newest = Math.max(newest, lstatSync(join(path, name)).mtimeMs);
+        }
+        catch { /* gone */ }
+    }
+    return newest;
+}
+/** Every test temp folder in `roots`, and which of them nothing has touched for a day. */
+export function testTempFolders(roots, now) {
+    const all = [];
+    const seen = new Set();
+    for (const root of roots) {
+        let names = [];
+        try {
+            names = readdirSync(root);
+        }
+        catch {
+            continue;
+        }
+        for (const name of names) {
+            if (!isTestTemp(name))
+                continue;
+            const path = join(root, name);
+            try {
+                const stat = lstatSync(path);
+                const key = `${stat.dev}:${stat.ino}`;
+                if (seen.has(key) || stat.isSymbolicLink())
+                    continue;
+                seen.add(key);
+                all.push({ path, touchedAt: stat.isDirectory() ? touchedAt(path) : stat.mtimeMs });
+            }
+            catch { /* gone */ }
+        }
+    }
+    return { all, stale: all.filter(one => now.getTime() - one.touchedAt > DAY_MS) };
+}
+/** Remove the test temp folders nothing has touched for a day; each is looked at again right before it goes. */
+export function removeStaleTestTemp(roots, now) {
+    const removed = [];
+    const failed = [];
+    for (const one of testTempFolders(roots, now).stale) {
+        try {
+            if (now.getTime() - (lstatSync(one.path).isDirectory() ? touchedAt(one.path) : lstatSync(one.path).mtimeMs) <= DAY_MS)
+                continue;
+            rmSync(one.path, { recursive: true, force: true, maxRetries: 3 });
+            removed.push(one.path);
+        }
+        catch {
+            failed.push(one.path);
+        }
+    }
+    return { removed, failed };
+}

package/dist/toolroll-update-ui.js

@@ -12,7 +12,7 @@ export const UPDATES_CSS = `.updates{max-width:640px;min-width:0;overflow-wrap:a
     `.updates ol.update-steps li[data-state=failed]{color:var(--so-danger);font-weight:600}.updates ol.update-steps li[data-state=failed]::before{background:var(--so-danger);border-color:var(--so-danger)}` +
     `.updates ol.update-steps .step-detail{grid-column:2;font-weight:400;color:var(--so-muted);font-size:.8125rem;margin-top:2px}` +
     `.updates .whats-new ul{margin:10px 0 0;padding-left:18px}.updates .whats-new li{margin:4px 0}.updates .whats-new form{margin:14px 0 0}` +
-    `.updates .update-problem{color:var(--so-danger)}.updates .stamp{margin:10px 0 0}.updates code{white-space:nowrap}` +
+    `.updates .update-problem{color:var(--so-danger)}.updates .stamp{margin:10px 0 0}.updates code{white-space:nowrap}.updates [data-update-outcome=stopped] code,.updates .step-detail code{white-space:normal;overflow-wrap:anywhere}` +
     `@media (prefers-reduced-motion:no-preference){.updates ol.update-steps li[data-state=now]::before{animation:update-pulse 1.6s ease-in-out infinite}}@keyframes update-pulse{50%{box-shadow:0 0 0 7px color-mix(in srgb,var(--so-info) 6%,transparent)}}` +
     `@media (max-width:600px){.updates .update-actions{display:grid}.updates .update-actions button{width:100%;min-height:44px}.updates .step-up{max-width:none}.updates .step-up input{min-height:44px}}`;
 /** The steps, each done, current, failed or waiting. Also the live region's fragment. */
@@ -23,7 +23,8 @@ export function updateStepsHtml(j, running) {
     const items = UPDATE_STEPS.map((step, i) => {
         const state = j.phase === "complete" || i < last ? "done" : i > last ? "waiting" : failed ? "failed" : finished ? "waiting" : "now";
         // Only where it adds something: which work it waits for, or what went wrong.
-        const detail = (state === "now" && step === "draining") || (state === "failed" && j.phase === "rolling-back") ? `<span class="step-detail">${e(j.detail)}</span>` : "";
+        const detail = state === "now" && step === "draining" && j.waiting ? `<span class="step-detail">${e(j.waiting.on)}.${j.waiting.action ? ` If nothing of it is running, run <code>${e(j.waiting.action)}</code>.` : ""}</span>`
+            : (state === "now" && step === "draining") || (state === "failed" && j.phase === "rolling-back") ? `<span class="step-detail">${e(j.detail)}</span>` : "";
         return `<li data-step="${step}" data-state="${state}">${e(STEP_WORDS[step])}${detail}</li>`;
     }).join("");
     const title = j.phase === "scheduled" ? `Update to ${e(j.to.version)} scheduled for ${e(clock(j.at ?? j.startedAt))}`
@@ -38,6 +39,10 @@ function outcomeHtml(j) {
         return j.kind === "rollback" ? `<div class="card" data-update-outcome="rolled-back"><h2>Back on ${e(j.to.version)}</h2><p class="meta">${e(j.detail)}</p></div>` : "";
     if (j.phase === "cancelled")
         return `<div class="card" data-update-outcome="cancelled"><h2>Update cancelled</h2><p class="meta">Nothing changed.</p></div>`;
+    // Stopped on a finished run it can't show has ended: what is in the way and the one command, nothing more.
+    if (j.phase === "refused" && j.waiting)
+        return `<div class="card" data-update-outcome="stopped"><h2>Update to ${e(j.to.version)} stopped: run #${e(j.waiting.run)} is in the way</h2>` +
+            `<p>${e(j.waiting.on)}. New work resumed.</p>` + (j.waiting.action ? `<p class="meta">If nothing of it is running, run <code>${e(j.waiting.action)}</code>, then update again.</p>` : `<p class="meta">Update again once it has stopped.</p>`) + `</div>`;
     const title = j.phase === "refused" ? `Didn't update to ${e(j.to.version)}` : j.phase === "restored" ? `Update to ${e(j.to.version)} didn't finish` : "The update needs attention";
     return `<div class="card" data-update-outcome="${e(j.phase)}"><h2>${title}</h2><p class="${j.phase === "needs-attention" ? "update-problem" : ""}" role="alert">${e(j.detail)}</p>` +
         `<details><summary>Steps</summary>${updateStepsHtml(j, false).replace(/<h2>.*?<\/h2>/, "")}</details></div>`;

package/dist/toolroll-update.d.ts

@@ -1,4 +1,5 @@
 import type { DatabaseSync } from "node:sqlite";
+import { type LingeringRun, type UpdateWaiting } from "./desktop-update.js";
 import { type SupervisorRunner } from "./daemon.js";
 export declare const PROVENANCE_REPOSITORY = "https://github.com/ap9000/toolroll";
 export declare const PROVENANCE_WORKFLOW = ".github/workflows/publish.yml";
@@ -103,6 +104,11 @@ export type RuntimeUpdateJournal = {
      * the restored version and would be lost), and it keeps a fresh copy aside before every attempt until then. */
     restoredDatabase?: boolean;
     seen?: boolean;
+    /** The finished run the update is waiting on (or stopped waiting on): what is in the way and the command that
+     * clears it. Absent while it waits on ordinary running work. */
+    waiting?: LingeringRun & {
+        since: string;
+    };
 };
 export type PackageRelease = {
     version: string;
@@ -160,6 +166,8 @@ export type UpdateOutcome = {
     journal: RuntimeUpdateJournal | null;
 };
 export declare const runtimeUpdateTerminal: (phase: RuntimePhase) => boolean;
+/** How long a launched or resuming updater is expected to take to start and hold the lock. */
+export declare const UPDATER_START_MS: number;
 export declare function readRuntimeUpdate(stateDir: string, file?: string): RuntimeUpdateJournal | null;
 /** The update `--rollback` returns from: the last one that completed, whatever was attempted since. */
 export declare function lastCompletedUpdate(stateDir: string): RuntimeUpdateJournal | null;
@@ -245,6 +253,18 @@ export type RuntimeUpdateStatus = {
     } | null;
 };
 export declare function runtimeUpdateStatus(stateDir: string): RuntimeUpdateStatus;
+/** An update that is waiting, what on, and the one action that clears it: for `toolroll status` and the console.
+ * `inTheWay` asks whether a finished run still holds it up; a stopped update whose run has since cleared says nothing. */
+export type { UpdateWaiting };
+export declare function updateWaitingOf(stateDir: string, inTheWay: (run: number) => boolean): UpdateWaiting | null;
+/** An updater that ended while letting work finish (a crash, a kill, the Mac restarting) leaves new work paused with
+ * nobody left to lift the pause. With no updater holding the update, the pause is lifted here and the update says it
+ * stopped. Nothing was switched before the backup, so nothing else needs putting back. The background worker's
+ * reconcile, `toolroll status` and the console run this. Returns what it said, or null. */
+export declare function releaseStalledUpdate(stateDir: string, now: Date): string | null;
+/** What `toolroll status` and the console show: a stalled `toolroll update` released first, then this installation's
+ * waiting update, `toolroll update`'s or the desktop app's. */
+export declare function waitingUpdate(databaseFile: string, inTheWay: (run: number) => boolean, now: Date, desktopStates?: readonly string[]): UpdateWaiting | null;
 export declare function markWhatsNewSeen(stateDir: string): void;
 type Exec = (command: string, args: string[], options?: {
     cwd?: string;
@@ -282,8 +302,8 @@ export declare function launchRuntimeUpdate(args: {
     run?: SupervisorRunner;
     platform?: NodeJS.Platform;
     npmBin?: () => Promise<string | null>;
+    now?: () => Date;
 }): 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;
 export declare const nextScheduledAt: typeof nextAt;
-export {};