toolroll 0.9.52 → 0.9.54

package/dist/chat-delivery.js

@@ -14,7 +14,7 @@ import { answerChatFlowPrompt, answerChoiceMessage, applyChatFlowTap, flowDecisi
 import { connectChannel, FLOW_WORDS, takeChannelMessage, watchedChannel } from "./chat-inbox.js";
 import { triggerConfigOf } from "./flow-triggers.js";
 import { telegramProgressCard } from "./telegram-progress.js";
-import { enqueueEveningDigests, finishedView, isTaskFact, joinsBatch, needsPerson, quietCardView } from "./chat-quiet.js";
+import { enqueueEveningDigests, finishedView, isTaskFact, joinsBatch, needsPerson, quietCardView, wantedBeforePairing } from "./chat-quiet.js";
 import { BATCH_MS, chatText, chatTitle } from "./chat-voice.js";
 import { LEAD_SAY_KIND, enqueueLeadLapses, leadSayEarlier, leadSayText, leadSubjectOf } from "./lead-voice.js";
 import { leadChannelOf } from "./lead-context.js";
@@ -25,6 +25,8 @@ import { isTelegramProgressNotification, proposalTaskOf } from "./store.js";
 import { isShotsKind, resultShotsFor } from "./result-shots.js";
 import { messageTeammate } from "./teammate-desk.js";
 import { CHAT_APP_NAMES } from "./flow-triggers.js";
+import { answersPrompt, applyDecideFeedback, applyDecideTap, decideFallbackLink, decideOffer, decideTargetOf, hasLiveDecideTokens, linksFor, mergedText, mintDecideButtons, offerFingerprint, openPromptFor, recordChatMerge } from "./chat-decide.js";
+import { mergePullRequest } from "./pull-request-flow.js";
 export const chatObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v)
     ? v
     : {};
@@ -69,6 +71,72 @@ export async function channelAccess(options, binding, ceiling) {
         throw new ChatDeliveryError("Chat access changed");
     return latest;
 }
+// ---- decisions that finish in the chat (chat-decide.ts), the same in every app --------------------------------------
+/** Where a paired person taps: their binding, and the chat the card is in. */
+const decideSeat = (state, binding, chat = binding.channel) => ({ channel: state.provider, binding: binding.id, chat, approver: binding.approver, generation: binding.generation });
+/** What a card about one result, plan, failure or pull request may act on in this person's chat now, under their
+ * current ceiling; null keeps its link. Reads only. */
+function decideOfferFor(options, binding, target, repos, now) {
+    if (target == null)
+        return null;
+    const principal = verifyApproverStanding(options.store, binding.approver, binding.generation, repos);
+    return principal.ok ? decideOffer(options.store, target, principal.who, now, options.state.provider, options.evidenceRoot) : null;
+}
+/** A card's buttons as a part carries them. */
+const decideRows = (rows) => rows.map(row => row.map(one => "token" in one ? { label: one.label, token: one.token } : { label: one.label, link: one.link }));
+/** The offer's buttons, minted now: they ride the part's message once it is sent (ChatState.partSent). */
+function mintDecide(options, binding, target, offer, now) {
+    return { rows: decideRows(mintDecideButtons(options.store, decideSeat(options.state, binding), target, offer, now).rows) };
+}
+/**
+ * A decide button (chat-decide.ts), inside the tap's transaction: the same door, words and two taps as on Telegram.
+ * The card it rode is repainted in place; Request changes asks for the next message; a merge goes out after.
+ */
+function applyChatDecideTap(options, event, binding, token, repos, now) {
+    const { store, state } = options;
+    // The card the button rode: this person's part on that message.
+    const row = state.prepare(`SELECT p.id, p.payload FROM chat_part p JOIN chat_event e ON e.provider = p.provider AND e.id = p.event
+    WHERE p.provider = :provider AND e.binding = ? AND p.message = ? ORDER BY p.id DESC LIMIT 1`).get(binding.id, event.ts);
+    const read = row === undefined ? null : readChatPart(String(row["payload"]));
+    const card = read?.ok === true ? read.value : null;
+    const tapped = applyDecideTap(store, decideSeat(state, binding, event.channel), { token, message: event.ts, shown: card?.text ?? "", repos, root: options.evidenceRoot, now });
+    if (tapped === null) {
+        state.plan(event.id, [{ text: "That button doesn't do anything now." }], now);
+        return null;
+    }
+    const replies = [];
+    let repainted = null;
+    if (tapped.edit !== undefined && row !== undefined && card !== null) {
+        const { decide: _decide, link: _link, also: _also, edit: _edit, ...kept } = card;
+        repainted = { ...kept, text: tapped.edit.text, ...(tapped.edit.rows.length === 0 ? {} : { decide: { rows: decideRows(tapped.edit.rows) } }) };
+        state.repaint(Number(row["id"]), repainted);
+    }
+    else
+        replies.push({ text: tapped.ack });
+    if (tapped.prompt !== undefined)
+        replies.push({ text: tapped.prompt.text, prompt: tapped.prompt.id });
+    state.plan(event.id, replies, now);
+    return tapped.merge === undefined || row === undefined || repainted === null ? null
+        : { merge: tapped.merge, part: Number(row["id"]), shown: tapped.edit?.text ?? card?.text ?? "", content: repainted };
+}
+/** GitHub is a network call: after the tap's transaction, then the card says how it went, and the ledger too. */
+async function mergeFromChat(options, pending) {
+    const { merge } = pending;
+    let merged;
+    try {
+        const result = options.merge !== undefined ? await options.merge({ runId: merge.runId, by: merge.by })
+            : await mergePullRequest(options.store, { runId: merge.runId, by: merge.by, clock: () => nowOf(options) });
+        merged = result.ok ? { ok: true } : { ok: false, message: result.message };
+    }
+    catch {
+        merged = { ok: false, message: "GitHub couldn't be reached just now. Try again from the task." };
+    }
+    recordChatMerge(options.store, merge, merged, nowOf(options));
+    const { decide: _decide, ...kept } = pending.content;
+    // A merge that didn't land keeps a way to the task.
+    options.state.repaint(pending.part, { ...kept, text: mergedText(pending.shown, merged),
+        ...(merged.ok ? {} : { decide: { rows: decideRows(linksFor({ kind: "merge", taskId: merge.taskId, run: merge.runId })) } }) });
+}
 export async function processChatEvent(options) {
     const { store, identity } = options, state = options.state, now = nowOf(options);
     if (!state.owns(identity.installation, options.owner, now) ||
@@ -88,14 +156,14 @@ export async function processChatEvent(options) {
                 return false;
             const body = readChatPairBody(event.payload);
             const paired = body.ok
-                ? state.pair(identity, body.value.hash, event.member, event.channel, nowOf(options))
+                ? state.pair(identity, body.value.hash, event.member, event.channel, nowOf(options), event.id)
                 : null;
             if (!paired) {
                 state.finish(event.id, true);
                 return true;
             }
             state
-                .prepare("UPDATE chat_event SET binding=? WHERE id=?")
+                .prepare("UPDATE chat_event SET binding=? WHERE provider=:provider AND id=?")
                 .run(paired.id, event.id);
             state.plan(event.id, [
                 {
@@ -114,7 +182,9 @@ export async function processChatEvent(options) {
         }
         const repos = await channelAccess(options, binding);
         if (event.kind === "action") {
-            applyChatAction(options, event, binding, repos);
+            const merging = applyChatAction(options, event, binding, repos);
+            if (merging !== null)
+                await mergeFromChat(options, merging);
             return true;
         }
         const body = readChatMessageBody(event.payload);
@@ -134,12 +204,22 @@ export async function processChatEvent(options) {
         // A flow decision asked for this person's next message (Edit, Send back): it is the draft or the note.
         if (answerChatFlowPrompt({ store, state, label: options.label }, event, binding, { text, ...(typeof input.originalLength === "number" ? { originalLength: input.originalLength } : {}) }, repos, nowOf(options)))
             return true;
+        // After Request changes asked "What should change?": the person's next message in their own chat is the feedback
+        // (a reply in another message's thread keeps its own meaning).
+        if (event.channel === binding.channel && text.trim() !== "" && phoneCommand(text) === null) {
+            const prompt = openPromptFor(store, { channel: state.provider, binding: binding.id, chat: binding.channel }, nowOf(options));
+            if (prompt !== null && answersPrompt(prompt, event.thread !== "" && event.thread !== event.ts ? event.thread : null)) {
+                const answer = applyDecideFeedback(store, decideSeat(state, binding), prompt, text, repos, options.evidenceRoot, nowOf(options));
+                state.plan(event.id, [{ text: answer.said, ...(answer.link === null ? {} : { link: answer.link }) }], nowOf(options));
+                return true;
+            }
+        }
         // A "Person chooses" notice's thread reply is the note; the first other message after it is asked about (chat-flow.ts).
         if (answerChoiceMessage({ store, state, label: options.label }, event, binding, { text, ...(typeof input.originalLength === "number" ? { originalLength: input.originalLength } : {}), lead: input.lead === true }, nowOf(options), repos))
             return true;
         // A message to a teammate by name (v96), in someone's own chat with Toolroll: a card on its desk.
         if (event.channel === binding.channel) {
-            const handed = messageTeammate(store, { who: binding.approver, repos, via: CHAT_APP_NAMES[state.channel] ?? "Chat" }, text, nowOf(options));
+            const handed = messageTeammate(store, { who: binding.approver, repos, via: CHAT_APP_NAMES[state.provider] ?? "Chat" }, text, nowOf(options));
             if (handed !== null) {
                 state.plan(event.id, [{ text: handed.said, ...(handed.link === undefined ? {} : { link: handed.link }) }], nowOf(options));
                 return true;
@@ -190,7 +270,7 @@ export async function processChatEvent(options) {
             const replies = [];
             const registry = await options.readProjects();
             const consumed = applyRoomInbound({
-                store, channel: state.channel, backend: state.roomBackend(identity.installation, now), chatId: event.channel, isGroup: isRoom,
+                store, channel: state.provider, backend: state.roomBackend(identity.installation, now), chatId: event.channel, isGroup: isRoom,
                 sender: { approver: binding.approver, generation: binding.generation, binding: binding.id }, updateKey: event.id, text,
                 projects: registry, origin: options.origin(), now, report: { ignored: 0 },
                 say: (reply, link) => replies.push({ text: reply, ...(link ? { link } : {}), ...(isRoom ? { channel: event.channel } : {}) }),
@@ -208,7 +288,7 @@ export async function processChatEvent(options) {
             ], nowOf(options));
             return true;
         }
-        const request = chatHash(`${options.state.channel}:${binding.id}:${event.id}`).slice(0, 32);
+        const request = chatHash(`${options.state.provider}:${binding.id}:${event.id}`).slice(0, 32);
         let receipt = event.session === null
             ? null
             : store.mateRequestReceipt(event.session, request);
@@ -241,10 +321,10 @@ export async function processChatEvent(options) {
                 return true;
             }
             state
-                .prepare("UPDATE chat_event SET session=? WHERE id=? AND state='queued'")
+                .prepare("UPDATE chat_event SET session=? WHERE provider=:provider AND id=? AND state='queued'")
                 .run(resolved.session.id, event.id);
             const contexts = state
-                .prepare("SELECT p.payload FROM chat_part p JOIN chat_event e ON e.id=p.event WHERE e.binding=? AND e.channel=? AND (p.message=? OR e.thread=?) AND p.state='sent' ORDER BY p.id DESC LIMIT 100")
+                .prepare("SELECT p.payload FROM chat_part p JOIN chat_event e ON e.provider=p.provider AND e.id=p.event WHERE p.provider=:provider AND e.binding=? AND e.channel=? AND (p.message=? OR e.thread=?) AND p.state='sent' ORDER BY p.id DESC LIMIT 100")
                 .all(binding.id, binding.channel, event.thread, event.thread)
                 // Context only: a part that can't be read adds none.
                 .flatMap((row) => { const read = readChatPart(String(row.payload)); return read.ok ? [read.value] : []; })
@@ -275,7 +355,7 @@ export async function processChatEvent(options) {
             if (context?.task) {
                 about = { task: context.task, run: context.run ?? null };
                 state
-                    .prepare("UPDATE chat_event SET payload=? WHERE id=? AND state='queued'")
+                    .prepare("UPDATE chat_event SET payload=? WHERE provider=:provider AND id=? AND state='queued'")
                     .run(JSON.stringify({ ...input, about }), event.id);
             }
             // An unknown surface names no channel rather than a guess.
@@ -397,16 +477,16 @@ export async function processChatEvent(options) {
             : new ChatDeliveryError(`${options.label} is waiting to retry`);
         if (problem.permanent) {
             state.plan(event.id, [{ text: problem.message }], nowOf(options));
-            state.prepare("UPDATE chat_event SET next_at=NULL,problem=? WHERE id=?").run(problem.message, event.id);
+            state.prepare("UPDATE chat_event SET next_at=NULL,problem=? WHERE provider=:provider AND id=?").run(problem.message, event.id);
             return true;
         }
         state
-            .prepare("UPDATE chat_runtime SET problem=? WHERE installation=? AND owner=?")
+            .prepare("UPDATE chat_runtime SET problem=? WHERE provider=:provider AND installation=? AND owner=?")
             .run(problem.message, identity.installation, options.owner);
         state.defer(event.id, problem.message, new Date(nowOf(options).getTime() + problem.retryMs));
         if (problem.code === "ratelimited")
             state
-                .prepare("UPDATE chat_runtime SET retry_at=? WHERE installation=?")
+                .prepare("UPDATE chat_runtime SET retry_at=? WHERE provider=:provider AND installation=?")
                 .run(new Date(nowOf(options).getTime() + problem.retryMs).toISOString(), identity.installation);
         return true;
     }
@@ -416,7 +496,7 @@ export async function processChatEvent(options) {
  * or that the channel's flow takes as a card. False: not for an inbox.
  */
 async function channelInboxEvent(options, event) {
-    const { store, identity } = options, state = options.state, app = state.channel;
+    const { store, identity } = options, state = options.state, app = state.provider;
     const binding = event.binding === null ? null : state.bindingById(event.binding);
     if (binding !== null && event.channel === binding.channel)
         return false;
@@ -454,13 +534,14 @@ async function channelInboxEvent(options, event) {
         state.finish(event.id);
         return true;
     }
-    state.prepare("UPDATE chat_event SET binding=? WHERE id=?").run(grant.id, event.id);
+    state.prepare("UPDATE chat_event SET binding=? WHERE provider=:provider AND id=?").run(grant.id, event.id);
     state.plan(event.id, [{ text: taken.said, channel: event.channel, ...(taken.link === undefined ? {} : { link: taken.link }) }], nowOf(options));
     return true;
 }
 /** Bound to the paired member, exact channel/message, pending proposal and current ceiling. */
 export function applyChatAction(options, event, binding, repos) {
     const state = options.state, { store } = options, now = nowOf(options), signals = [];
+    let merging = null;
     store.transact(() => {
         if (!state.owns(options.identity.installation, options.owner, now) ||
             !options.current() ||
@@ -476,6 +557,11 @@ export function applyChatAction(options, event, binding, repos) {
             return;
         }
         const token = body.value.token;
+        // A result's, plan's, failure's or pull request's own button (chat-decide.ts).
+        if (token.startsWith("d:")) {
+            merging = applyChatDecideTap(options, event, binding, token, repos, now);
+            return;
+        }
         // A flow decision's button (v88) is answered by the flow's own door.
         if (applyChatFlowTap({ store, state, label: options.label }, event, binding, token, repos, now))
             return;
@@ -486,7 +572,7 @@ export function applyChatAction(options, event, binding, repos) {
         if (applyChatAskTap({ store, state }, event, binding, token, now))
             return;
         const saved = state
-            .prepare("SELECT a.*,p.message,e.binding,e.channel,e.thread FROM chat_action a JOIN chat_part p ON p.id=a.part JOIN chat_event e ON e.id=p.event WHERE token=?")
+            .prepare("SELECT a.token,a.part,a.proposal,a.phase,a.expires,a.consumed,p.message,e.binding,e.channel,e.thread FROM chat_action a JOIN chat_part p ON p.provider=a.provider AND p.id=a.part JOIN chat_event e ON e.provider=p.provider AND e.id=p.event WHERE a.provider=:provider AND a.token=?")
             .get(token);
         // The saved button, read by its schema: one that can't be read is a spent button, never a guess.
         const read = saved === undefined ? null : readProposalActionRow({ ...saved });
@@ -495,7 +581,7 @@ export function applyChatAction(options, event, binding, repos) {
             action.binding !== binding.id ||
             action.channel !== event.channel ||
             action.message !== event.ts ||
-            (options.state.channel === "slack" && action.thread !== event.thread) ||
+            (options.state.provider === "slack" && action.thread !== event.thread) ||
             action.consumed !== null ||
             action.expires <= now.toISOString();
         if (invalid) {
@@ -517,7 +603,7 @@ export function applyChatAction(options, event, binding, repos) {
             proposal: proposal.id,
             edit: event.ts,
         };
-        const preview = proposalPreview(store, proposal, repos, options.state.channel);
+        const preview = proposalPreview(store, proposal, repos, options.state.provider);
         const phase = action.phase;
         if (proposal.state !== "pending")
             content = { text: proposalOutcomeText(proposal), edit: event.ts };
@@ -544,10 +630,9 @@ export function applyChatAction(options, event, binding, repos) {
         }
         else {
             const outcome = confirmMateProposal(store, verified.who, proposal.id, now, {
-                via: options.state.channel,
+                via: options.state.provider,
                 evidenceRoot: options.evidenceRoot,
                 confirm: phase === "yes",
-                ...(options.held ? { held: options.held } : {}),
                 deferSignal: (signal) => signals.push(signal),
             });
             if (!outcome.ok && outcome.reason === "needs-confirm") {
@@ -567,20 +652,21 @@ export function applyChatAction(options, event, binding, repos) {
         }
         // Repaint the original persisted card; retain one placement and fresh tokens.
         state
-            .prepare("UPDATE chat_part SET payload=?,state='pending',next_at=NULL WHERE id=?")
+            .prepare("UPDATE chat_part SET payload=?,state='pending',next_at=NULL WHERE provider=:provider AND id=?")
             .run(savedChatPart(content), action.part);
         if (!content.proposal)
             state
-                .prepare("UPDATE chat_action SET consumed=? WHERE proposal=? AND consumed IS NULL")
+                .prepare("UPDATE chat_action SET consumed=? WHERE provider=:provider AND proposal=? AND consumed IS NULL")
                 .run(now.toISOString(), proposal.id);
         else
             state
-                .prepare("UPDATE chat_action SET consumed=? WHERE token=?")
+                .prepare("UPDATE chat_action SET consumed=? WHERE provider=:provider AND token=?")
                 .run(now.toISOString(), token);
         state.finish(event.id);
     });
     for (const signal of signals)
         signal();
+    return merging;
 }
 /**
  * Carry new conversation messages to every room that follows one: the
@@ -610,7 +696,7 @@ export async function planRoomMessages(options) {
         if (row === null)
             continue;
         for (const message of roomMessagesAfter(store, row.thread, room.cursor)) {
-            const text = roomMessageText(message, state.channel, room.chat);
+            const text = roomMessageText(message, state.provider, room.chat);
             let carrier = null;
             if (room.kind === "private")
                 carrier = live.find(one => one.channel === room.chat) ?? null;
@@ -632,7 +718,7 @@ export async function planRoomMessages(options) {
             if (message.role === "assistant" && message.turn !== null)
                 for (const proposal of store.listMateProposals(row.thread, ["pending"]).filter(one => one.turn === message.turn))
                     parts.push({ text: "", proposal: proposal.id, channel: room.chat });
-            const id = chatHash(`${state.channel}:room:${room.id}:${message.id}`);
+            const id = chatHash(`${state.provider}:room:${room.id}:${message.id}`);
             const target = carrier;
             store.transact(() => {
                 if (parts.length > 0 && state.enqueue({ id, installation: identity.installation, binding: target.id, kind: "message", channel: room.chat, member: target.member, ts: "", thread: "", payload: {}, created: now.toISOString() }))
@@ -648,7 +734,7 @@ function planQuietCard(options, binding, notification, now) {
     const { state, store, identity } = options;
     if (notification.taskRef === null || notification.taskId === null)
         return;
-    const card = store.chatCardFor(`${state.channel}:${binding.id}`, notification.taskRef, store.getTask(notification.taskId)?.createdAt ?? notification.createdAt, now);
+    const card = store.chatCardFor(`${state.provider}:${binding.id}`, notification.taskRef, store.getTask(notification.taskId)?.createdAt ?? notification.createdAt, now);
     const view = quietCardView(store, card.tasks, now, options.evidenceRoot, binding.approver);
     if (view === null)
         return;
@@ -657,45 +743,53 @@ function planQuietCard(options, binding, notification, now) {
     if (card.message !== null) {
         if (card.digest === shown)
             return;
-        state.prepare("UPDATE chat_part SET payload=?,state='pending',created=?,next_at=NULL WHERE id=? AND state!='dropped'").run(savedChatPart(content), now.toISOString(), Number(card.message));
+        state.prepare("UPDATE chat_part SET payload=?,state='pending',created=?,next_at=NULL WHERE provider=:provider AND id=? AND state!='dropped'").run(savedChatPart(content), now.toISOString(), Number(card.message));
         store.setChatCardMessage(card.id, card.message, shown);
         return;
     }
-    const id = chatHash(`${state.channel}:card:${binding.id}:${card.id}`);
+    const id = chatHash(`${state.provider}:card:${binding.id}:${card.id}`);
     state.enqueue({ id, installation: identity.installation, binding: binding.id, kind: "notice", channel: binding.channel, member: binding.member,
         ts: "", thread: "", payload: {}, created: now.toISOString() });
     state.plan(id, [content], now);
-    const part = state.prepare("SELECT id FROM chat_part WHERE event=?").get(id);
+    const part = state.prepare("SELECT id FROM chat_part WHERE provider=:provider AND event=?").get(id);
     if (part !== undefined)
         store.setChatCardMessage(card.id, String(part.id), shown);
 }
 /** Any update for this person joins their open batch (two minutes from its first), and the batch's one message
  * is planned once, then repainted in place as more updates land. `notification`: an update that is not a finished
  * result (null for one that is). False when nothing in the batch reads as a line, so the update goes out on its own. */
-function planFinished(options, binding, taskRef, run, now, notification = null) {
+function planFinished(options, binding, taskRef, run, now, notification = null, repos = []) {
     const { state, store, identity } = options;
-    const batch = store.chatBatchFor(`${state.channel}:${binding.id}`, taskRef, run, now, BATCH_MS, notification);
+    const batch = store.chatBatchFor(`${state.provider}:${binding.id}`, taskRef, run, now, BATCH_MS, notification);
     const view = finishedView(store, batch, now, options.evidenceRoot, binding.approver);
     if (view === null)
         return false;
     // A single update keeps its task and run, so a reply to it names that work.
     const single = batch.items.length === 1 ? batch.items[0] : null;
     const task = single === null ? null : store.refById(single.taskRef)?.externalId ?? null;
-    const content = { text: view.text, link: view.link, ...(view.also === undefined ? {} : { also: view.also }),
-        ...(task === null ? {} : { task }), ...(single?.run == null ? {} : { run: single.run }) };
-    const shown = chatHash(JSON.stringify(content));
+    const about = { ...(task === null ? {} : { task }), ...(single?.run == null ? {} : { run: single.run }) };
+    // A message about one result, plan, failure or pull request acts in place (chat-decide.ts), as on Telegram: its
+    // buttons are minted only when what it offers changed, or its own were spent (Not now), so an unchanged repaint keeps them.
+    const offer = decideOfferFor(options, binding, view.target, repos, now);
+    const content = offer === null
+        ? { text: view.text, link: view.link, ...(view.also === undefined ? {} : { also: view.also }), ...about }
+        : { text: offer.text ?? view.text, ...about };
+    const shown = chatHash(JSON.stringify(offer === null ? content : [content, offerFingerprint(offer)]));
     if (batch.message !== null) {
-        if (batch.digest === shown)
+        const placed = state.part(Number(batch.message));
+        const live = offer === null || placed?.state === "pending" || (placed?.message != null && hasLiveDecideTokens(store, state.provider, binding.channel, placed.message, now));
+        if (batch.digest === shown && live)
             return true;
-        state.prepare("UPDATE chat_part SET payload=?,state='pending',created=?,next_at=NULL WHERE id=? AND state!='dropped'").run(savedChatPart(content), now.toISOString(), Number(batch.message));
+        const painted = offer === null ? content : { ...content, decide: mintDecide(options, binding, view.target, offer, now) };
+        state.prepare("UPDATE chat_part SET payload=?,state='pending',created=?,next_at=NULL WHERE provider=:provider AND id=? AND state!='dropped'").run(savedChatPart(painted), now.toISOString(), Number(batch.message));
         store.setChatBatchMessage(batch.id, batch.message, shown);
         return true;
     }
-    const id = chatHash(`${state.channel}:batch:${binding.id}:${batch.id}`);
+    const id = chatHash(`${state.provider}:batch:${binding.id}:${batch.id}`);
     state.enqueue({ id, installation: identity.installation, binding: binding.id, kind: "notice", channel: binding.channel, member: binding.member,
         ts: "", thread: "", payload: {}, created: now.toISOString() });
-    state.plan(id, [content], now);
-    const part = state.prepare("SELECT id FROM chat_part WHERE event=?").get(id);
+    state.plan(id, [offer === null ? content : { ...content, decide: mintDecide(options, binding, view.target, offer, now) }], now);
+    const part = state.prepare("SELECT id FROM chat_part WHERE provider=:provider AND event=?").get(id);
     if (part !== undefined)
         store.setChatBatchMessage(batch.id, String(part.id), shown);
     return true;
@@ -716,20 +810,20 @@ function planResultShots(options, binding, notification, repos, id, now) {
         if (visit !== null) {
             for (const key of [`flow-send:${visit[1]}:${visit[2]}`, `flow-choose:${visit[1]}:${visit[2]}`]) {
                 const notice = store.handle.prepare("SELECT id FROM notification WHERE dedupe_key=?").get(key);
-                const part = notice === undefined ? undefined : state.prepare("SELECT id FROM chat_part WHERE event=? ORDER BY id DESC LIMIT 1").get(chatHash(`${state.channel}:notice:${binding.id}:${Number(notice["id"])}`));
+                const part = notice === undefined ? undefined : state.prepare("SELECT id FROM chat_part WHERE provider=:provider AND event=? ORDER BY id DESC LIMIT 1").get(chatHash(`${state.provider}:notice:${binding.id}:${Number(notice["id"])}`));
                 if (part !== undefined)
                     return Number(part.id);
             }
             return null;
         }
-        const batch = notification.taskRef === null ? null : store.chatBatchMessageFor(`${state.channel}:${binding.id}`, notification.taskRef, notification.run);
+        const batch = notification.taskRef === null ? null : store.chatBatchMessageFor(`${state.provider}:${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);
+        const card = state.prepare("SELECT part FROM chat_progress WHERE provider=:provider AND binding=? AND run=?").get(binding.id, notification.run);
         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"])}`));
+            const part = state.prepare("SELECT id FROM chat_part WHERE provider=:provider AND event=? ORDER BY id LIMIT 1").get(chatHash(`${state.provider}:notice:${binding.id}:${Number(one["id"])}`));
             if (part !== undefined)
                 return Number(part.id);
         }
@@ -738,7 +832,7 @@ function planResultShots(options, binding, notification, repos, id, now) {
     const image = (artifact, sha256) => ({ taskId: where.task, run: where.run, artifact, sha256 });
     const parts = plan.kind === "line" ? [{ text: plan.text, ...where }]
         // Teams has no file upload here: one message that links to the saved result.
-        : state.channel === "teams" ? [{ text: plan.shots.length === 1 ? plan.shots[0].caption : `${plan.shots[0].caption} · ${plan.shots.length} screenshots`,
+        : state.provider === "teams" ? [{ text: plan.shots.length === 1 ? plan.shots[0].caption : `${plan.shots[0].caption} · ${plan.shots.length} screenshots`,
                 image: image(plan.shots[0].artifact, plan.shots[0].sha256), shot: { follows: null }, ...where }]
             : plan.shots.map(one => ({ text: one.caption, image: image(one.artifact, one.sha256), shot: { follows }, ...where }));
     state.enqueue({ id, installation: identity.installation, binding: binding.id, kind: "notice", channel: binding.channel, member: binding.member,
@@ -760,163 +854,187 @@ export async function planChatNotifications(options) {
     catch { /* Retried on the next pass. */ }
     enqueueLeadLapses(store, nowOf(options));
     const cursor = Number(state
-        .prepare("SELECT notification FROM chat_runtime WHERE installation=?")
+        .prepare("SELECT notification FROM chat_runtime WHERE provider=:provider AND installation=?")
         .get(identity.installation)?.notification ?? 0);
+    // A person who paired after the cursor passed is still owed what wanted them before: once per pairing, their
+    // unresolved attention notices and open decisions from before it, through the same door as every new one.
+    for (const binding of bindings) {
+        const owed = `owed-before-pairing:${binding.id}`;
+        if (state.meta(identity.installation, owed) !== null)
+            continue;
+        for (const notification of store.notificationsWantedBefore(binding.created, cursor))
+            offerNotice(options, notification, binding, registry);
+        state.setMeta(identity.installation, owed, "offered", nowOf(options));
+    }
     // Every paired person is a destination of their own, under their own ceiling.
     for (const notification of store.notificationsAfter(cursor, 100)) {
-        for (const binding of bindings) {
-            const repos = channelRepos(store, binding.approver, registry);
-            store.transact(() => {
-                // One person's notification (v83) goes to that person alone, task or not.
-                const personal = notification.recipient !== null;
-                if (notification.createdAt >= binding.created &&
-                    notification.resolvedAt === null &&
-                    // A promise the lead made on another chat is reported there (lead-commitments.ts); one its owner asked for on
-                    // this chat is always said here, however quiet the lead's own work is kept.
-                    (promiseChannelOf(notification) ?? state.channel) === state.channel &&
-                    // Pings follow responsibility: the lead's work, this person's own act and a muted project stay in the console.
-                    (promiseChannelOf(notification) === state.channel || store.pingAllowed(notification, binding.approver)) &&
-                    // A flow decision for "anyone who approves" reaches every approver who can see the project.
-                    // A notification addressed to this person reaches them whatever project
-                    // their channel follows (a sign-in pause is the installation's, v108).
-                    (personal
-                        ? notification.recipient === binding.approver && (notification.project === null || repos.includes(notification.project))
-                        : (notification.taskId || notification.kind === "flow-decision") && notification.project !== null && repos.includes(notification.project))) {
-                    const run = store.telegramProgressRun(notification);
-                    const id = chatHash(`${options.state.channel}:notice:${binding.id}:${notification.id}`), now = nowOf(options);
-                    // Only when I'm needed (the default): the task's one card is edited in place, and a new message
-                    // follows only when this person is needed. Every step keeps the branches below unchanged.
-                    const quiet = !personal && isTaskFact(notification) && store.notificationPreference(binding.approver).mode === "quiet";
-                    if (isShotsKind(notification.kind)) {
-                        planResultShots(options, binding, notification, repos, id, now);
-                        return;
-                    }
-                    if (notification.kind === LEAD_SAY_KIND) {
-                        // The lead's words (lead-voice.ts): one message, repainted in place when a later say joins it.
-                        const content = { text: leadSayText(store, notification, binding.approver),
-                            ...(notification.link ? { link: { label: "Open", path: notification.link } } : {}) };
-                        const earlier = leadSayEarlier(store, notification).map(one => state.prepare("SELECT id FROM chat_part WHERE event=?")
-                            .get(chatHash(`${options.state.channel}:notice:${binding.id}:${one}`))).find(one => one !== undefined);
-                        if (earlier !== undefined) {
-                            state.prepare("UPDATE chat_part SET payload=?,state='pending',created=?,next_at=NULL WHERE id=? AND state!='dropped'").run(savedChatPart(content), now.toISOString(), Number(earlier.id));
-                            return;
-                        }
-                        state.enqueue({ id, installation: identity.installation, binding: binding.id, kind: "notice", channel: binding.channel, member: binding.member,
-                            ts: "", thread: "", payload: {}, created: now.toISOString() });
-                        state.plan(id, [content], now);
+        for (const binding of bindings)
+            offerNotice(options, notification, binding, registry);
+        state
+            .prepare("UPDATE chat_runtime SET notification=? WHERE provider=:provider AND installation=?")
+            .run(notification.id, identity.installation);
+    }
+}
+/** One notification for one paired person: planned as their parts, or nothing. Never twice: each plan's event id is
+ * the notification's for this binding. */
+function offerNotice(options, notification, binding, registry) {
+    const { state, store, identity } = options;
+    const repos = channelRepos(store, binding.approver, registry);
+    store.transact(() => {
+        // One person's notification (v83) goes to that person alone, task or not.
+        const personal = notification.recipient !== null;
+        if (
+        // From before the pairing, only what still wants a person (the rule every chat app shares, wantedBeforePairing).
+        (notification.createdAt >= binding.created || wantedBeforePairing(notification)) &&
+            notification.resolvedAt === null &&
+            // A promise the lead made on another chat is reported there (lead-commitments.ts); one its owner asked for on
+            // this chat is always said here, however quiet the lead's own work is kept.
+            (promiseChannelOf(notification) ?? state.provider) === state.provider &&
+            // Pings follow responsibility: the lead's work, this person's own act and a muted project stay in the console.
+            (promiseChannelOf(notification) === state.provider || store.pingAllowed(notification, binding.approver)) &&
+            // A flow decision for "anyone who approves" reaches every approver who can see the project.
+            // A notification addressed to this person reaches them whatever project
+            // their channel follows (a sign-in pause is the installation's, v108).
+            (personal
+                ? notification.recipient === binding.approver && (notification.project === null || repos.includes(notification.project))
+                : (notification.taskId || notification.kind === "flow-decision") && notification.project !== null && repos.includes(notification.project))) {
+            const run = store.telegramProgressRun(notification);
+            const id = chatHash(`${options.state.provider}:notice:${binding.id}:${notification.id}`), now = nowOf(options);
+            // Only when I'm needed (the default): the task's one card is edited in place, and a new message
+            // follows only when this person is needed. Every step keeps the branches below unchanged.
+            const quiet = !personal && isTaskFact(notification) && store.notificationPreference(binding.approver).mode === "quiet";
+            if (isShotsKind(notification.kind)) {
+                planResultShots(options, binding, notification, repos, id, now);
+                return;
+            }
+            if (notification.kind === LEAD_SAY_KIND) {
+                // The lead's words (lead-voice.ts): one message, repainted in place when a later say joins it.
+                const content = { text: leadSayText(store, notification, binding.approver),
+                    ...(notification.link ? { link: { label: "Open", path: notification.link } } : {}) };
+                const earlier = leadSayEarlier(store, notification).map(one => state.prepare("SELECT id FROM chat_part WHERE provider=:provider AND event=?")
+                    .get(chatHash(`${options.state.provider}:notice:${binding.id}:${one}`))).find(one => one !== undefined);
+                if (earlier !== undefined) {
+                    state.prepare("UPDATE chat_part SET payload=?,state='pending',created=?,next_at=NULL WHERE provider=:provider AND id=? AND state!='dropped'").run(savedChatPart(content), now.toISOString(), Number(earlier.id));
+                    return;
+                }
+                state.enqueue({ id, installation: identity.installation, binding: binding.id, kind: "notice", channel: binding.channel, member: binding.member,
+                    ts: "", thread: "", payload: {}, created: now.toISOString() });
+                state.plan(id, [content], now);
+                return;
+            }
+            if (quiet) {
+                planQuietCard(options, binding, notification, now);
+                if (!needsPerson(notification))
+                    return;
+                if (notification.kind === "run-finished" && run) {
+                    // Finished work goes out only as the batch line; one left out on purpose (a release check, a replaced
+                    // task, the reader's own completion) stays quiet rather than falling through to another message.
+                    planFinished(options, binding, notification.taskRef, run.id, now, null, repos);
+                    return;
+                }
+                // Every other update for this person within two minutes joins the same one message.
+                else if (notification.kind !== "run-finished" && joinsBatch(notification)) {
+                    if (planFinished(options, binding, notification.taskRef, run?.id ?? null, now, notification.id, repos))
                         return;
+                }
+            }
+            if (!quiet && run && notification.taskId && notification.project !== null && isTelegramProgressNotification(notification)) {
+                const card = telegramProgressCard(store, store.getRun(run.id), notification.taskId, notification.project, now, options.evidenceRoot, binding.approver);
+                const content = {
+                    text: card.text,
+                    task: notification.taskId,
+                    run: run.id,
+                    link: card.link,
+                };
+                const digest = chatHash(JSON.stringify(content));
+                const prior = state
+                    .prepare("SELECT part,digest FROM chat_progress WHERE provider=:provider AND binding=? AND run=?")
+                    .get(binding.id, run.id);
+                if (prior) {
+                    if (prior.digest !== digest) {
+                        state
+                            .prepare("UPDATE chat_part SET payload=?,state='pending',created=?,next_at=NULL WHERE provider=:provider AND id=? AND state!='dropped'")
+                            .run(JSON.stringify(content), now.toISOString(), Number(prior.part));
+                        state
+                            .prepare("UPDATE chat_progress SET digest=? WHERE provider=:provider AND binding=? AND run=?")
+                            .run(digest, binding.id, run.id);
                     }
-                    if (quiet) {
-                        planQuietCard(options, binding, notification, now);
-                        if (!needsPerson(notification))
-                            return;
-                        if (notification.kind === "run-finished" && run) {
-                            // Finished work goes out only as the batch line; one left out on purpose (a release check, a replaced
-                            // task, the reader's own completion) stays quiet rather than falling through to another message.
-                            planFinished(options, binding, notification.taskRef, run.id, now);
-                            return;
-                        }
-                        // Every other update for this person within two minutes joins the same one message.
-                        else if (notification.kind !== "run-finished" && joinsBatch(notification)) {
-                            if (planFinished(options, binding, notification.taskRef, run?.id ?? null, now, notification.id))
-                                return;
-                        }
-                    }
-                    if (!quiet && run && notification.taskId && notification.project !== null && isTelegramProgressNotification(notification)) {
-                        const card = telegramProgressCard(store, store.getRun(run.id), notification.taskId, notification.project, now, options.evidenceRoot, binding.approver);
-                        const content = {
-                            text: card.text,
-                            task: notification.taskId,
-                            run: run.id,
-                            link: card.link,
-                        };
-                        const digest = chatHash(JSON.stringify(content));
-                        const prior = state
-                            .prepare("SELECT part,digest FROM chat_progress WHERE binding=? AND run=?")
-                            .get(binding.id, run.id);
-                        if (prior) {
-                            if (prior.digest !== digest) {
-                                state
-                                    .prepare("UPDATE chat_part SET payload=?,state='pending',created=?,next_at=NULL WHERE id=? AND state!='dropped'")
-                                    .run(JSON.stringify(content), now.toISOString(), Number(prior.part));
-                                state
-                                    .prepare("UPDATE chat_progress SET digest=? WHERE binding=? AND run=?")
-                                    .run(digest, binding.id, run.id);
-                            }
-                        }
-                        else {
-                            state.enqueue({
-                                id,
-                                installation: identity.installation,
-                                binding: binding.id,
-                                kind: "notice",
-                                channel: binding.channel,
-                                member: binding.member,
-                                ts: "",
-                                thread: "",
-                                payload: {},
-                                created: now.toISOString(),
-                            });
-                            state.plan(id, [content], now);
-                            const part = state
-                                .prepare("SELECT id FROM chat_part WHERE event=?")
-                                .get(id);
-                            state
-                                .prepare("INSERT INTO chat_progress VALUES(?,?,?,?)")
-                                .run(binding.id, run.id, Number(part.id), digest);
-                        }
-                    }
-                    else if (notification.kind === "flow-decision") {
-                        // The draft as written, and Approve / Edit / Send back on its last part; a card that moved on is not news.
-                        const parts = flowDecisionParts(store, notification, state.channel);
-                        if (parts !== null) {
-                            state.enqueue({ id, installation: identity.installation, binding: binding.id, kind: "notice", channel: binding.channel, member: binding.member,
-                                ts: "", thread: "", payload: {}, created: now.toISOString() });
-                            state.plan(id, parts, now);
-                        }
-                    }
-                    else if (personal && flowSendParts(store, notification, state.channel) !== null) {
-                        // A flow's "Send to me" (flow-send.ts): what was done, with its links as buttons.
-                        state.enqueue({ id, installation: identity.installation, binding: binding.id, kind: "notice", channel: binding.channel, member: binding.member,
-                            ts: "", thread: "", payload: {}, created: now.toISOString() });
-                        state.plan(id, flowSendParts(store, notification, state.channel), now);
-                    }
-                    else if (notification.kind === "flow-card" && questionParts(store, notification, binding) !== null) {
-                        // A teammate's question (v93): its options and "Answer in words" on the notice, for the person it asks.
-                        state.enqueue({ id, installation: identity.installation, binding: binding.id, kind: "notice", channel: binding.channel, member: binding.member,
-                            ts: "", thread: "", payload: {}, created: now.toISOString() });
-                        state.plan(id, questionParts(store, notification, binding), now);
-                    }
-                    else if (notification.pushClass !== null || personal || quiet) {
-                        state.enqueue({
-                            id,
-                            installation: identity.installation,
-                            binding: binding.id,
-                            kind: "notice",
-                            channel: binding.channel,
-                            member: binding.member,
-                            ts: "",
-                            thread: "",
-                            payload: {},
-                            created: now.toISOString(),
-                        });
-                        state.plan(id, [
-                            {
-                                // Never the task's id or a "— revision" suffix (chat-voice.ts).
-                                text: chatText(phoneText(notification.body === "" ? leadSubjectOf(store, notification, binding.approver) : `${leadSubjectOf(store, notification, binding.approver)}\n\n${notification.body}`, 2500), notification.taskId === null ? [] : [{ id: notification.taskId, title: chatTitle(store, notification.taskId) }]),
-                                ...(notification.taskId ? { task: notification.taskId } : {}),
-                                ...(run ? { run: run.id } : {}),
-                                ...(notification.link
+                }
+                else {
+                    state.enqueue({
+                        id,
+                        installation: identity.installation,
+                        binding: binding.id,
+                        kind: "notice",
+                        channel: binding.channel,
+                        member: binding.member,
+                        ts: "",
+                        thread: "",
+                        payload: {},
+                        created: now.toISOString(),
+                    });
+                    state.plan(id, [content], now);
+                    const part = state
+                        .prepare("SELECT id FROM chat_part WHERE provider=:provider AND event=?")
+                        .get(id);
+                    state
+                        .prepare("INSERT INTO chat_progress (provider,binding,run,part,digest) VALUES(:provider,?,?,?,?)")
+                        .run(binding.id, run.id, Number(part.id), digest);
+                }
+            }
+            else if (notification.kind === "flow-decision") {
+                // The draft as written, and Approve / Edit / Send back on its last part; a card that moved on is not news.
+                const parts = flowDecisionParts(store, notification, state.provider);
+                if (parts !== null) {
+                    state.enqueue({ id, installation: identity.installation, binding: binding.id, kind: "notice", channel: binding.channel, member: binding.member,
+                        ts: "", thread: "", payload: {}, created: now.toISOString() });
+                    state.plan(id, parts, now);
+                }
+            }
+            else if (personal && flowSendParts(store, notification, state.provider) !== null) {
+                // A flow's "Send to me" (flow-send.ts): what was done, with its links as buttons.
+                state.enqueue({ id, installation: identity.installation, binding: binding.id, kind: "notice", channel: binding.channel, member: binding.member,
+                    ts: "", thread: "", payload: {}, created: now.toISOString() });
+                state.plan(id, flowSendParts(store, notification, state.provider), now);
+            }
+            else if (notification.kind === "flow-card" && questionParts(store, notification, binding) !== null) {
+                // A teammate's question (v93): its options and "Answer in words" on the notice, for the person it asks.
+                state.enqueue({ id, installation: identity.installation, binding: binding.id, kind: "notice", channel: binding.channel, member: binding.member,
+                    ts: "", thread: "", payload: {}, created: now.toISOString() });
+                state.plan(id, questionParts(store, notification, binding), now);
+            }
+            else if (notification.pushClass !== null || personal || quiet) {
+                state.enqueue({
+                    id,
+                    installation: identity.installation,
+                    binding: binding.id,
+                    kind: "notice",
+                    channel: binding.channel,
+                    member: binding.member,
+                    ts: "",
+                    thread: "",
+                    payload: {},
+                    created: now.toISOString(),
+                });
+                // A result, plan, failure or ready pull request acts in place (chat-decide.ts); otherwise its one link (a plan's
+                // is Review & start, where the password step lives).
+                const target = decideTargetOf(notification);
+                const offer = decideOfferFor(options, binding, target, repos, now);
+                const fallback = offer === null ? decideFallbackLink(target) : null;
+                state.plan(id, [
+                    {
+                        // Never the task's id or a "— revision" suffix (chat-voice.ts).
+                        text: offer?.text ?? chatText(phoneText(notification.body === "" ? leadSubjectOf(store, notification, binding.approver) : `${leadSubjectOf(store, notification, binding.approver)}\n\n${notification.body}`, 2500), notification.taskId === null ? [] : [{ id: notification.taskId, title: chatTitle(store, notification.taskId) }]),
+                        ...(notification.taskId ? { task: notification.taskId } : {}),
+                        ...(run ? { run: run.id } : {}),
+                        ...(offer !== null ? { decide: mintDecide(options, binding, target, offer, now) }
+                            : fallback !== null ? { link: fallback }
+                                : notification.link
                                     ? { link: { label: notification.kind === "pull-request-ready" ? "Merge" : personal ? "Open" : "Review", path: notification.link } }
                                     : {}),
-                            },
-                        ], now);
-                    }
-                }
-            });
+                    },
+                ], now);
+            }
         }
-        state
-            .prepare("UPDATE chat_runtime SET notification=? WHERE installation=?")
-            .run(notification.id, identity.installation);
-    }
+    });
 }