toolroll 0.9.18 → 0.9.19

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.9.19 — 2026-10-03
+
+- A release candidate whose check was rerun on the same commit can be
+  deployed; no fresh gate needed.
+- Screenshots with results follow their result message and thread under it on
+  Slack and Discord, never sent twice.
+- A process-cleanup test no longer flakes under load.
+
 ## 0.9.18 — 2026-10-03
 
 - **Decide in Telegram.** A ready result's Accept and finish, Request changes

package/dist/chat-delivery.js

@@ -677,13 +677,21 @@ function planResultShots(options, binding, notification, repos, id, now) {
     if (plan.kind === "none" || notification.taskId === null || notification.run === null)
         return;
     const where = { task: notification.taskId, run: notification.run };
-    // The result's message here: its finished-work batch (quiet), or its progress card (every step).
+    // The result's message here: its finished-work batch (quiet), its progress card (every step), or the result's own
+    // notice. The transport threads the screenshots under it once it is posted, and holds them until then.
     const follows = (() => {
         const batch = notification.taskRef === null ? null : store.chatBatchMessageFor(`${state.channel}:${binding.id}`, notification.taskRef, notification.run);
         if (batch !== null)
             return Number(batch);
         const card = state.prepare("SELECT part FROM chat_progress WHERE binding=? AND run=?").get(binding.id, notification.run);
-        return card === undefined ? null : Number(card.part);
+        if (card !== undefined)
+            return Number(card.part);
+        for (const one of store.handle.prepare("SELECT id FROM notification WHERE source_run=? AND recipient IS NULL AND id<? ORDER BY id DESC").all(notification.run, notification.id)) {
+            const part = state.prepare("SELECT id FROM chat_part WHERE event=? ORDER BY id LIMIT 1").get(chatHash(`${state.channel}:notice:${binding.id}:${Number(one["id"])}`));
+            if (part !== undefined)
+                return Number(part.id);
+        }
+        return null;
     })();
     const image = (artifact, sha256) => ({ taskId: where.task, run: where.run, artifact, sha256 });
     const parts = plan.kind === "line" ? [{ text: plan.text, ...where }]

package/dist/discord-chat.js

@@ -2,7 +2,7 @@
 import { chatQuestionButtons } from "./teammate-question.js";
 import { chatAskButtons } from "./chat-ask.js";
 import { chatFlowButtons } from "./chat-flow.js";
-import { refuseResultShots, resultShotsPruned } from "./result-shots.js";
+import { refuseResultShots, resultShotsPruned, shotWaitsUntil } from "./result-shots.js";
 import { channelInbox } from "./chat-inbox.js";
 import { roomCommand } from "./chat-rooms.js";
 import { ChatState, ChatDeliveryError, chatHash, } from "./chat-delivery-state.js";
@@ -210,8 +210,13 @@ export async function deliverDiscordPart(options) {
             state.prepare("UPDATE chat_part SET state='dropped',problem='Removed by retention' WHERE id=?").run(row.id);
             return true;
         }
-        // A screenshot sent with a result replies to that result's message once it is placed.
-        const follows = content.shot?.follows == null ? undefined : state.prepare("SELECT message FROM chat_part WHERE id=? AND state='sent'").get(content.shot.follows)?.message;
+        // A screenshot sent with a result replies to that result's message once it is placed, and waits until then.
+        const result = content.shot?.follows == null ? undefined : state.prepare("SELECT message,state,next_at FROM chat_part WHERE id=?").get(content.shot.follows);
+        if (result !== undefined && !discordId(result["message"]) && result["state"] === "pending") {
+            state.prepare("UPDATE chat_part SET next_at=? WHERE id=?").run(shotWaitsUntil(result["next_at"], now), row.id);
+            return true;
+        }
+        const follows = result?.["message"];
         const thread = discordId(follows) ? String(follows) : event.thread;
         if (content.image) {
             const image = verifyResultImage(store, options.evidenceRoot, repos, content.image);

package/dist/result-shots.d.ts

@@ -39,6 +39,8 @@ export type ResultShotsPlan =
  * no wait in between, or asks again.
  */
 export declare function resultShotsFor(store: Store, evidenceRoot: string | undefined, repos: readonly string[], row: Pick<Notification, "kind" | "recipient" | "taskId" | "taskRef" | "run">, sent?: ReadonlySet<number>): ResultShotsPlan;
+/** A screenshot whose result message is not posted yet waits for that message's own next try (at least a second). */
+export declare function shotWaitsUntil(resultNextAt: unknown, now: Date): string;
 /** Retention removed this result's files: its screenshots go quietly, never as a complaint. */
 export declare function resultShotsPruned(evidenceRoot: string, run: number): boolean;
 /**

package/dist/result-shots.js

@@ -102,6 +102,11 @@ export function resultShotsFor(store, evidenceRoot, repos, row, sent = new Set()
     const remaining = shots.filter(one => !sent.has(one.artifact));
     return remaining.length === 0 ? { kind: "none", why: "sent" } : { kind: "send", taskId: row.taskId, run: row.run, shots: remaining };
 }
+/** A screenshot whose result message is not posted yet waits for that message's own next try (at least a second). */
+export function shotWaitsUntil(resultNextAt, now) {
+    const soonest = new Date(now.getTime() + 1_000).toISOString();
+    return typeof resultNextAt === "string" && resultNextAt > soonest ? resultNextAt : soonest;
+}
 /** Retention removed this result's files: its screenshots go quietly, never as a complaint. */
 export function resultShotsPruned(evidenceRoot, run) {
     return existsSync(join(evidenceRoot, String(run), RETENTION_NOTE));

package/dist/slack-chat.js

@@ -1,5 +1,5 @@
 import { chatFlowButtons } from "./chat-flow.js";
-import { refuseResultShots, resultShotsPruned } from "./result-shots.js";
+import { refuseResultShots, resultShotsPruned, shotWaitsUntil } from "./result-shots.js";
 import { chatQuestionButtons } from "./teammate-question.js";
 import { chatAskButtons } from "./chat-ask.js";
 import { channelInbox } from "./chat-inbox.js";
@@ -233,8 +233,13 @@ export async function deliverSlackPart(options) {
         if (content.task &&
             !repos.includes(store.lookupRef(content.task)?.repo ?? ""))
             throw new SlackError("Connected projects changed");
-        // A screenshot sent with a result goes in that result's thread once its message is placed.
-        const follows = content.shot?.follows == null ? undefined : state.db.prepare("SELECT message FROM slack_part WHERE id=? AND state='sent'").get(content.shot.follows)?.message;
+        // A screenshot sent with a result goes in that result's thread once its message is placed, and waits until then.
+        const result = content.shot?.follows == null ? undefined : state.db.prepare("SELECT message,state,next_at FROM slack_part WHERE id=?").get(content.shot.follows);
+        if (result !== undefined && !slackTs(result["message"]) && result["state"] === "pending") {
+            state.db.prepare("UPDATE slack_part SET next_at=? WHERE id=?").run(shotWaitsUntil(result["next_at"], now), row.id);
+            return true;
+        }
+        const follows = result?.["message"];
         const thread = slackTs(follows) ? String(follows) : event.thread;
         if (content.image && content.shot && resultShotsPruned(options.evidenceRoot, content.image.run)) {
             state.db.prepare("UPDATE slack_part SET state='dropped',problem='Removed by retention' WHERE id=?").run(row.id);

package/dist/telegram.js

@@ -690,7 +690,7 @@ async function deliverOutboxTo(store, botId, binding, transport, owner, clock, r
     const groups = [];
     for (const row of claimed) {
         const last = groups[groups.length - 1];
-        if (!quiet && digest.everyMs !== null && !isUrgent(row) && last !== undefined && !isUrgent(last[0]))
+        if (!quiet && digest.everyMs !== null && joinsDigest(row) && last !== undefined && joinsDigest(last[0]))
             last.push(row);
         else
             groups.push([row]);
@@ -787,18 +787,26 @@ async function deliverOutboxTo(store, botId, binding, transport, owner, clock, r
                 const sent = await sender(`A screenshot for result #${row.run} could not be sent: ${verified.problem}. Inspect the result before accepting.`);
                 return sent.ok ? { ok: true, receipt: receiptFor(botId, binding.chatId, sent.messageId) } : sent;
             }
+            // Already sent with its result (result-shots.ts): the same screenshot is not sent again.
+            const artifact = Number(match[2]);
+            if (store.resultShotsSent(row.destination, row.run).has(artifact))
+                return { ok: true, receipt: "skipped:screenshot-sent" };
+            // Marked while it goes, so the screenshots sent with the result skip it; any failure unmarks it for the retry.
+            store.markResultShotsSent(row.destination, row.run, [artifact], clock());
             // No await between the access fence, file validation and upload.
             let answer;
             try {
                 answer = await transport("sendDocument", { chat_id: binding.chatId, caption: `${resultTaskLabel(row.taskId)} · result #${row.run} · screenshot for acceptance` }, undefined, {
-                    field: "document", bytes: verified.bytes, contentType: verified.format === "png" ? "image/png" : "image/jpeg", fileName: resultImageFileName(row.taskId, row.run, Number(match[2]), verified.format),
+                    field: "document", bytes: verified.bytes, contentType: verified.format === "png" ? "image/png" : "image/jpeg", fileName: resultImageFileName(row.taskId, row.run, artifact, verified.format),
                 });
             }
             catch {
+                store.unmarkResultShotsSent(row.destination, row.run, [artifact]);
                 return { ok: false, error: "Screenshot delivery is unconfirmed; retry may duplicate it" };
             }
             const messageId = answer.result?.message_id;
             if (!answer.ok || !Number.isSafeInteger(messageId)) {
+                store.unmarkResultShotsSent(row.destination, row.run, [artifact]);
                 if (answer.parameters?.retry_after !== undefined)
                     store.deferTelegram(botId, new Date(clock().getTime() + answer.parameters.retry_after * 1000).toISOString());
                 return { ok: false, error: answer.uncertain || (answer.ok && messageId == null) ? "Screenshot delivery is unconfirmed; retry may duplicate it" : "Telegram did not accept the screenshot" };
@@ -856,7 +864,7 @@ async function deliverOutboxTo(store, botId, binding, transport, owner, clock, r
             }
             return { ok: true, receipt };
         };
-        const batched = !quiet && digest.everyMs !== null && !isUrgent(rows[0]);
+        const batched = !quiet && digest.everyMs !== null && joinsDigest(rows[0]);
         const row = rows[0];
         const progressRun = batched ? null : store.telegramProgressRun(row);
         const progress = progressRun !== null && isTelegramProgressNotification(row);
@@ -1094,8 +1102,12 @@ async function deliverOutboxTo(store, botId, binding, transport, owner, clock, r
 }
 /** What pages singly whatever the cadence: a decision, or an attention-class fact. */
 function isUrgent(notification) {
-    return /^decision:\d+$/.test(notification.dedupeKey) || notification.pushClass === "attention" || notification.kind === "acceptance-evidence" || notification.kind === "acceptance-ready"
-        || notification.kind === RESULT_SHOTS_KIND;
+    return /^decision:\d+$/.test(notification.dedupeKey) || notification.pushClass === "attention" || notification.kind === "acceptance-evidence" || notification.kind === "acceptance-ready";
+}
+/** A routine fact the digest may carry. Screenshots are never urgent (they follow their result message, which the
+ * task's order fence holds them behind) and never a digest line: they go as their own photos once it has gone. */
+function joinsDigest(notification) {
+    return !isUrgent(notification) && notification.kind !== RESULT_SHOTS_KIND;
 }
 /** 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolroll",
-  "version": "0.9.18",
+  "version": "0.9.19",
   "description": "A control plane for unattended coding agents — queue tasks, walk away, come back to pull requests. Agents build in leased worktrees, never touch your default branch, and interrupt you only for decisions that need a human.",
   "directories": {
     "doc": "docs"