@timqi/pier 0.1.4 → 0.1.5

package/dist/channels/panel.js

@@ -1,23 +1,118 @@
 // The in-chat settings panel, minus the platform: one message edited in place,
 // every payload namespaced `cfg:` so a tap never reaches the agent. Choices
-// travel as an index: Telegram's callback data caps at 64 bytes.
-import { compact, thinkingLabel } from "../core/reply.js";
+// travel as an index: platform callback payloads are small and opaque. A thread
+// without a session shows a draft — cwd, model, reasoning, a pending question —
+// that rides every button's value, so the card is the store and a restart
+// loses nothing.
+import { sessionLabel, splitSpeaker } from "../core/identity.js";
+import { splitInboundFiles } from "../core/inbound-file.js";
+import { compact, cut, splitReply, thinkingLabel } from "../core/reply.js";
+import { isThinkingLevel, } from "../core/types.js";
+import { HAS_SESSION, NO_SESSION } from "./control.js";
+import { HandoffError } from "./handoff.js";
 export const PANEL_PREFIX = "cfg:";
-const MODELS_PER_PAGE = 8;
-export const CWD_TAIL = "A new session starts there; the current one stays in its own directory.";
+const PER_PAGE = 8;
+/** The picker's reach: five pages of the newest unbound sessions. */
+const SESSIONS_LISTED = 40;
+const TITLE_CHARS = 40;
+const QUESTION_CHARS = 80;
+/** Exchanges excerpted under the session, and the width of one line: four of
+ *  these stay far inside Slack's 3000-character section. */
+const RECENT_EXCHANGES = 2;
+const EXCERPT_CHARS = 150;
+/** Characters of the serialized draft — what a button actually carries. Slack
+ *  caps a value at 2000 and Lark a card at 30 KB; the rest of the 2000 is room
+ *  for the cwd, model and reasoning a pick adds after the question. */
+const DRAFT_CHARS = 1700;
+/** Pages whose every pick Pi's fixed-at-creation cwd or the row would refuse:
+ *  reachable only by tapping a card that gained a session since it was drawn. */
+const DRAFT_ONLY = new Set(["cwd", "cwdtype", "sessions", "session"]);
+export const CWD_DRAFT_TAIL = "Start creates the session there.";
 export const CWD_PLACEHOLDER = "/path/to/project";
-const onOff = (v) => (v ? "on" : "off");
+export const QUESTION_TOO_LONG = "Your question is too long to hold — send it again after Start.";
 const btn = (label, action) => ({ label, action });
+/** A button label is the last two segments; the numbered line above has the whole path. */
+const shortDir = (path) => {
+    const parts = path.split("/").filter(Boolean);
+    return parts.length > 2 ? `…/${parts.slice(-2).join("/")}` : path;
+};
+/** One transcript line as a reader sees it: what was said, minus what was
+ *  written for the model (the speaker header, attachment markers, the
+ *  next-step block, a silent turn's reason). */
+const excerpt = (text, role) => {
+    const said = role === "user" ? splitInboundFiles(splitSpeaker(text).text).text : splitReply(text).text;
+    return cut(said.replace(/\s+/g, " ").trim(), EXCERPT_CHARS);
+};
+const shortTitle = (s) => cut(sessionLabel(s), TITLE_CHARS);
+/** Compact age, as the web sidebar spells it ("now", "12m", "3h", "2d"). */
+const age = (ts, now) => {
+    const mins = Math.round((now - ts) / 60_000);
+    if (mins < 1)
+        return "now";
+    if (mins < 60)
+        return `${String(mins)}m`;
+    if (mins < 1440)
+        return `${String(Math.round(mins / 60))}h`;
+    return `${String(Math.round(mins / 1440))}d`;
+};
+/** Page `page` of `items`, clamped: a stale Next past the end lands on the last page. */
+const paged = (items, page) => {
+    const pages = Math.max(1, Math.ceil(items.length / PER_PAGE));
+    const at = Math.min(Math.max(page, 0), pages - 1);
+    const from = at * PER_PAGE;
+    return { at, pages, slice: items.slice(from, from + PER_PAGE), from };
+};
+const pager = (action, at, pages) => [
+    ...(at > 0 ? [btn("‹ Prev", `${action}:${String(at - 1)}`)] : []),
+    ...(at < pages - 1 ? [btn("Next ›", `${action}:${String(at + 1)}`)] : []),
+    btn("‹ Back", "panel"),
+];
+/** A refusal's sentence (a control refusal, a HandoffError) is the whole
+ *  answer; any other failure names what was attempted. */
+const failed = (what, err) => err instanceof HandoffError || (err instanceof Error && (err.message === NO_SESSION || err.message === HAS_SESSION))
+    ? err.message
+    : `${what}: ${String(err)}`;
+/** `undefined` when there is nothing to carry, so a with-session panel's buttons stay bare. */
+export const serializeDraft = (draft) => Object.keys(draft).length ? JSON.stringify(draft) : undefined;
+/** The question, or the fact that it was too long — measured as the button
+ *  carries it, escapes included, not as the bytes the user typed. */
+export const holdQuestion = (q) => {
+    if (!q)
+        return {};
+    return JSON.stringify({ q }).length > DRAFT_CHARS ? { dropped: true } : { q };
+};
+/** The held question as the card shows it: one line, its attachments counted, not listed. */
+const heldLine = (q) => {
+    const { text, paths } = splitInboundFiles(q);
+    const files = paths.length ? ` · ${paths.length} file${paths.length > 1 ? "s" : ""}` : "";
+    return `${text.replace(/\s+/g, " ").trim()}${files}`;
+};
+/** A platform echoed this; only the fields the draft knows, each type-checked. */
+export const readDraft = (raw) => {
+    const draft = {};
+    if (!raw || typeof raw !== "object")
+        return draft;
+    const v = raw;
+    if (typeof v.cwd === "string")
+        draft.cwd = v.cwd;
+    const model = v.model;
+    if (model && typeof model.provider === "string" && typeof model.id === "string") {
+        draft.model = { provider: model.provider, id: model.id };
+    }
+    if (isThinkingLevel(v.thinking))
+        draft.thinking = v.thinking;
+    if (typeof v.q === "string" && v.q)
+        draft.q = v.q;
+    if (v.dropped === true)
+        draft.dropped = true;
+    return draft;
+};
 export class ChatPanel {
     deps;
     panels = new Map();
     constructor(deps) {
         this.deps = deps;
     }
-    /** Gates this platform has and the other does not. */
-    gateExtras(_chat, _policy) {
-        return "";
-    }
     code(text) {
         return `${this.fence[0]}${this.esc(text)}${this.fence[1]}`;
     }
@@ -28,190 +123,304 @@ export class ChatPanel {
         return this.panels.get(key.conversationId);
     }
     // --- rendering ---------------------------------------------------------------
-    async view(key, chatId) {
+    async view(key, state) {
         const status = await this.deps.control.status(key);
+        if (!status)
+            return this.draftView(key, state.draft);
+        // The conversation is right above the card: no excerpt, and no way to a
+        // second session — that is a new thread.
+        return {
+            groups: [{ title: "Session", lines: this.sessionLines(status) }],
+            rows: [[
+                    btn("Model & reasoning", "pins:0"),
+                    ...(status.state === "streaming" ? [btn("⏹ Stop", "stop")] : []),
+                ]],
+        };
+    }
+    draftView(key, draft) {
+        const { cwd, model, thinking } = this.effective(key, draft);
+        const question = draft.q ? [`▸ ${this.esc(cut(heldLine(draft.q), QUESTION_CHARS))}`]
+            : draft.dropped ? [QUESTION_TOO_LONG] : [];
         return {
-            groups: [
-                {
+            groups: [{
                     title: "Session",
-                    lines: status
-                        ? this.sessionLines(status)
-                        : ["None yet — send a message to start one."],
-                },
-                {
-                    title: this.platform === "slack" ? "Channel" : "Chat",
-                    lines: this.chatLines(chatId),
-                },
-            ],
+                    suffix: draft.cwd || draft.model || draft.thinking ? undefined : " · chat defaults",
+                    lines: [
+                        `Starts in ${cwd ? this.code(cwd) : "Pier's directory"} · ${model ? this.esc(model.id) : "Pi default"} · ${thinking ? `reasoning ${thinking}` : "default reasoning"}`,
+                        ...question,
+                    ],
+                }],
             rows: [
-                [btn("Model", "models:0"), btn("Reasoning", "think")],
-                [btn("New session", "new"), btn("New session in…", "cwd")],
-                [
-                    ...(status?.state === "streaming" ? [btn("⏹ Stop", "stop")] : []),
-                    btn("Close", "close"),
-                ],
+                [btn("Model & reasoning", "pins:0"), btn("Directory…", "cwd"), btn("Continue web session…", "sessions:0")],
+                [btn("Start", "start"), btn("Close", "close")],
             ],
         };
     }
+    /** What Start would create with: the draft over the chat defaults. */
+    effective(key, draft) {
+        const launch = this.deps.control.launchFor(key);
+        return {
+            cwd: draft.cwd ?? launch.cwd,
+            model: draft.model ?? launch.model,
+            thinking: draft.thinking ?? launch.thinking,
+        };
+    }
     sessionLines(status) {
         const usage = status.tokens !== null && status.contextWindow
             ? `${compact(status.tokens)}/${compact(status.contextWindow)} tok`
             : "not measured yet";
+        const fresh = status.empty && status.state === "idle";
         return [
-            `${this.code(status.sessionId.slice(0, 8))} · ${status.state}`,
+            `${this.code(status.sessionId.slice(0, 8))} · ${fresh ? "created, no message yet" : status.state}`,
             `Directory: ${this.code(status.cwd || "?")}`,
             `Model: ${status.model ? this.esc(status.model.id) : "Pi default"} · ${thinkingLabel(status.thinking)}`,
-            `Context: ${usage}`,
+            `Context: ${status.empty ? "empty — the first message you send runs here." : usage}`,
         ];
     }
-    chatLines(chatId) {
-        const chat = this.deps.store.chat(this.platform, chatId);
-        if (!chat)
-            return [this.code(chatId)];
-        const policy = this.deps.store.policy(this.platform, chatId);
-        // A DM is bind-only by construction, so the group knobs would be a lie.
-        const gates = chat.kind === "dm"
-            ? "bound users only"
-            : `mention ${onOff(policy.requireMention)} · bind ${onOff(policy.requireBind)}${this.gateExtras(chat, policy)}`;
-        return [`${this.esc(chat.name || chatId)} · ${chat.kind} · ${this.code(chatId)}`, gates];
+    /** A listing that failed is one line on the card, logged — never an empty
+     *  list that reads as "nothing here". */
+    async listed(read, what) {
+        try {
+            return { items: await read };
+        }
+        catch (err) {
+            const unavailable = `${what}: ${String(err)}`;
+            this.deps.log(unavailable);
+            return { items: [], unavailable };
+        }
+    }
+    /** An excerpt, not a summary: the last exchanges are what makes a session
+     *  one has been away from recognisable on a phone. */
+    async recentGroups(key) {
+        const { items: exchanges, unavailable } = await this.listed(this.deps.control.recent(key, RECENT_EXCHANGES), "Could not read the transcript");
+        if (unavailable)
+            return [{ title: "Recent", lines: [unavailable] }];
+        const lines = exchanges.flatMap(({ user, assistant }) => {
+            const reply = assistant === undefined ? "" : excerpt(assistant, "assistant");
+            return [
+                `▸ ${this.esc(excerpt(user, "user"))}`,
+                ...(reply ? [`◂ ${this.esc(reply)}`] : []),
+            ];
+        });
+        return lines.length ? [{ title: "Recent", lines }] : [];
     }
     async refresh(key, note) {
         const state = this.state(key);
         if (!state)
             return;
-        await this.draw(state, await this.view(key, state.chatId), note);
+        await this.draw(state, await this.view(key, state), note);
+    }
+    /** The card's last draw, once an operation completed: the session as it now
+     *  is, no button. The panel is released with it, so nothing can tap it again
+     *  and the card stays as a record; another @bot opens a fresh one. `recent`
+     *  excerpts the transcript — what tells a phone reader which conversation
+     *  was continued. */
+    async settle(key, state, note, recent) {
+        const status = await this.deps.control.status(key);
+        if (!status)
+            return this.refresh(key, note);
+        await this.draw(state, {
+            groups: [{ title: "Session", lines: this.sessionLines(status) }, ...recent ? await this.recentGroups(key) : []],
+            rows: [],
+        }, note);
+        this.panels.delete(key.conversationId);
     }
     // --- actions -----------------------------------------------------------------
-    /** Returns false when the payload is not ours. `reopen` recovers a panel
-     *  whose state died with a previous process; it costs one tap. */
-    async dispatch(key, payload, ctx, reopen) {
+    /** Returns false when the payload is not ours. `recover` rebuilds the state
+     *  of a panel whose process died — from the tapped button's value, so the
+     *  tap is honoured on the card the user is looking at. `run` hands Start's
+     *  pending question to the router as the tapper's message. */
+    async dispatch(key, payload, ctx, recover, run) {
         if (!payload.startsWith(PANEL_PREFIX))
             return false;
         const [action = "", arg = ""] = payload.slice(PANEL_PREFIX.length).split(":");
-        const state = this.state(key);
-        if (!state && action !== "close") {
-            await reopen();
+        let state = this.state(key);
+        if (!state) {
+            state = recover();
+            this.remember(key, state);
+        }
+        if (DRAFT_ONLY.has(action) && this.deps.control.knows(key)) {
+            await this.refresh(key, HAS_SESSION);
             return true;
         }
         switch (action) {
             case "close":
                 this.panels.delete(key.conversationId);
-                if (state)
-                    await this.erase(state);
+                await this.erase(state);
                 return true;
             case "panel":
                 await this.refresh(key);
                 return true;
-            case "models":
-                await this.showModels(key, Number(arg) || 0);
+            case "pins":
+                await this.showPins(key, Number(arg) || 0);
                 return true;
-            case "model":
-                await this.pickModel(key, Number(arg));
+            case "pin":
+                await this.pickPin(key, Number(arg));
                 return true;
-            case "think":
-                if (arg)
-                    await this.pickThinking(key, arg);
-                else
-                    await this.showThinking(key);
+            case "sessions":
+                await this.showSessions(key, Number(arg) || 0);
                 return true;
-            case "new": {
-                const id = await this.deps.control.newSession(key);
-                await this.refresh(key, `Started session ${id.slice(0, 8)}.`);
+            case "session":
+                await this.pickSession(key, Number(arg));
                 return true;
-            }
             case "cwd":
+                if (arg)
+                    await this.pickDir(key, Number(arg));
+                else
+                    await this.showDirs(key);
+                return true;
+            case "cwdtype":
                 await this.promptCwd(key, state, ctx);
                 return true;
+            case "start":
+                await this.start(key, state, run);
+                return true;
             case "stop":
                 await this.deps.control.abort(key);
-                await this.refresh(key, "Stop requested.");
+                await this.settle(key, state, "Stop requested.", false);
                 return true;
             default:
                 this.deps.log(`unknown panel action: ${action}`);
                 return true;
         }
     }
-    async showModels(key, page) {
+    /** The operator's pins, model and reasoning in one pick: the catalog is the
+     *  Console's business, and a chat is the wrong place to browse it. */
+    async showPins(key, page) {
         const state = this.state(key);
         if (!state)
             return;
-        // An empty list and a catalog that could not be read are two different
-        // answers; the second must not draw as the first.
-        let unavailable;
-        state.models = await this.deps.control.models().catch((err) => {
-            unavailable = `Could not list models: ${String(err)}`;
-            this.deps.log(unavailable);
-            return [];
-        });
+        const pins = this.deps.control.pins();
         const status = await this.deps.control.status(key);
-        const pages = Math.max(1, Math.ceil(state.models.length / MODELS_PER_PAGE));
-        const at = Math.min(Math.max(page, 0), pages - 1);
-        const slice = state.models.slice(at * MODELS_PER_PAGE, (at + 1) * MODELS_PER_PAGE);
+        const current = status ?? this.effective(key, state.draft);
+        const { at, pages, slice, from } = paged(pins, page);
         await this.draw(state, {
             groups: [{
-                    title: "Model",
+                    title: "Model & reasoning",
                     suffix: ` · page ${at + 1}/${pages}`,
-                    lines: state.models.length ? [] : [unavailable ?? "No models with configured auth."],
+                    lines: slice.length
+                        ? slice.map((pin, i) => {
+                            const ticked = current.model?.provider === pin.provider && current.model.id === pin.id
+                                && current.thinking === pin.thinking;
+                            return `${String(from + i + 1)}. ${ticked ? "✓ " : ""}${this.esc(pin.id)} · ${thinkingLabel(pin.thinking)}${pin.note ? ` — ${this.esc(pin.note)}` : ""}`;
+                        })
+                        : ["No pinned models — Settings → Models → Model menu."],
                 }],
-            picks: slice.map((model, i) => {
-                const current = status?.model?.provider === model.provider && status.model.id === model.id;
-                return btn(`${current ? "✓ " : ""}${model.id}`, `model:${at * MODELS_PER_PAGE + i}`);
-            }),
-            rows: [[
-                    ...(at > 0 ? [btn("‹ Prev", `models:${at - 1}`)] : []),
-                    ...(at < pages - 1 ? [btn("Next ›", `models:${at + 1}`)] : []),
-                    btn("‹ Back", "panel"),
-                ]],
+            // The note stays on the line: a platform truncates a button label.
+            picks: slice.map((pin, i) => btn(`${String(from + i + 1)} ${pin.id}`, `pin:${String(from + i)}`)),
+            rows: [pager("pins", at, pages)],
         });
     }
-    async pickModel(key, index) {
-        const model = this.state(key)?.models[index];
-        if (!model)
+    async showSessions(key, page) {
+        const state = this.state(key);
+        if (!state)
+            return;
+        const { items, unavailable } = await this.listed(this.deps.handoff.unbound(SESSIONS_LISTED), "Could not list sessions");
+        state.sessions = items;
+        const { at, pages, slice, from } = paged(state.sessions, page);
+        const now = Date.now();
+        await this.draw(state, {
+            groups: [{
+                    title: "Continue web session",
+                    suffix: ` · page ${at + 1}/${pages}`,
+                    lines: slice.length
+                        ? slice.map((s, i) => `${String(from + i + 1)}. ${this.esc(shortTitle(s))} · ${this.code(s.cwd.split("/").filter(Boolean).at(-1) ?? s.cwd)} · ${age(s.modified ?? s.createdAt, now)}`)
+                        : [unavailable ?? "No unbound sessions."],
+                }],
+            picks: slice.map((s, i) => btn(`${String(from + i + 1)} ${shortTitle(s)}`, `session:${String(from + i)}`)),
+            rows: [pager("sessions", at, pages)],
+        });
+    }
+    async pickSession(key, index) {
+        const state = this.state(key);
+        const session = state?.sessions[index];
+        if (!state || !session)
+            return this.refresh(key, "That session is no longer listed.");
+        try {
+            await this.deps.handoff.continueHere(key, session.id);
+            // The bound session has its own settings; the draft is spent.
+            state.draft = {};
+            await this.settle(key, state, `Continuing session ${session.id.slice(0, 8)} — reply in this thread.`, true);
+        }
+        catch (err) {
+            await this.refresh(key, failed("Could not continue that session", err));
+        }
+    }
+    async pickPin(key, index) {
+        const state = this.state(key);
+        const pin = this.deps.control.pins()[index];
+        if (!state || !pin)
             return this.refresh(key, "That model is no longer listed.");
+        const model = { provider: pin.provider, id: pin.id };
+        if (!this.deps.control.knows(key)) {
+            state.draft = { ...state.draft, model, thinking: pin.thinking };
+            return this.refresh(key);
+        }
         try {
             await this.deps.control.setModel(key, model);
-            await this.refresh(key, `Model set to ${model.id}.`);
+            await this.deps.control.setThinking(key, pin.thinking);
+            await this.settle(key, state, `Model set to ${pin.id} · ${thinkingLabel(pin.thinking)}.`, false);
         }
         catch (err) {
-            await this.refresh(key, `Could not set that model: ${String(err)}`);
+            await this.refresh(key, failed("Could not set that model", err));
         }
     }
-    async showThinking(key) {
+    async showDirs(key) {
         const state = this.state(key);
         if (!state)
             return;
-        const status = await this.deps.control.status(key);
-        const levels = status?.thinkingLevels ?? [];
+        const { items, unavailable } = await this.listed(this.deps.control.recentDirs(key), "Could not list recent directories");
+        state.dirs = items;
         await this.draw(state, {
             groups: [{
-                    title: "Reasoning",
-                    lines: levels.length ? [] : ["This model has no levels."],
+                    title: "Directory",
+                    lines: state.dirs.length
+                        ? state.dirs.map((dir, i) => `${String(i + 1)}. ${this.code(dir)}`)
+                        : [unavailable ?? "No sessions yet — type a path."],
                 }],
-            picks: levels.map((level) => btn(`${status?.thinking === level ? "✓ " : ""}${thinkingLabel(level)}`, `think:${level}`)),
-            rows: [[btn("‹ Back", "panel")]],
+            picks: state.dirs.map((dir, i) => btn(`${String(i + 1)} ${shortDir(dir)}`, `cwd:${String(i)}`)),
+            rows: [[btn("Type a path…", "cwdtype"), btn("‹ Back", "panel")]],
         });
     }
-    async pickThinking(key, level) {
-        await this.deps.control.setThinking(key, level);
-        await this.refresh(key, `Reasoning set to ${thinkingLabel(level)}.`);
-    }
-    /** Pi fixes cwd at session creation, so "change the working directory" *is*
-     *  "start a new session there". */
-    async startSessionIn(key, path) {
-        if (!path.startsWith("/")) {
-            const error = "That is not an absolute path — nothing changed.";
-            await this.refresh(key, error);
-            return { error };
-        }
+    async pickDir(key, index) {
+        const dir = this.state(key)?.dirs[index];
+        if (!dir)
+            return this.refresh(key, "That directory is no longer listed.");
+        await this.chooseDir(key, dir);
+    }
+    /** Pi fixes cwd at session creation, so a directory is only ever the draft's:
+     *  a thread that already has a session keeps it, and a new one is a new thread. */
+    async chooseDir(key, path) {
+        const state = this.state(key);
+        if (!state)
+            return;
+        if (this.deps.control.knows(key))
+            return this.refresh(key, HAS_SESSION);
+        if (!path.startsWith("/"))
+            return this.refresh(key, "That is not an absolute path — nothing changed.");
+        state.draft = { ...state.draft, cwd: path };
+        await this.refresh(key);
+    }
+    /** Create with the draft, bind the thread, run the question as the tapper's
+     *  first message. A session that appeared meanwhile (a message raced the
+     *  tap) is not replaced: the draft would orphan it. */
+    async start(key, state, run) {
+        if (this.deps.control.knows(key))
+            return this.refresh(key, HAS_SESSION);
+        const { q, dropped: _dropped, ...launch } = state.draft;
+        let id;
         try {
-            const id = await this.deps.control.newSession(key, path);
-            await this.refresh(key, `Started session ${id.slice(0, 8)} in ${path}.`);
-            return { id };
+            id = await this.deps.control.newSession(key, launch);
         }
         catch (err) {
-            const error = `Could not start a session there: ${String(err)}`;
-            await this.refresh(key, error);
-            return { error };
+            return this.refresh(key, failed("Could not start a session", err));
+        }
+        state.draft = {};
+        if (q) {
+            await run(q);
+            return this.settle(key, state, `Started ${id.slice(0, 8)} — running your question.`, false);
         }
+        const cwd = (await this.deps.control.status(key))?.cwd ?? launch.cwd ?? "?";
+        await this.settle(key, state, `Started ${id.slice(0, 8)} in ${cwd}.`, false);
     }
 }

package/dist/channels/receipts.js

@@ -17,13 +17,13 @@ export class ReceiptLedger {
         this.platform = platform;
         this.db = db;
     }
-    add(receipt) {
+    add(receipt, createdAt = Date.now()) {
         this.db.prepare(`
       INSERT INTO receipts(platform, conversation_id, chat_id, message_id, created_at)
       VALUES (?, ?, ?, ?, ?)
       ON CONFLICT(platform, chat_id, message_id) DO UPDATE SET
         conversation_id = excluded.conversation_id, created_at = excluded.created_at
-    `).run(this.platform, receipt.conversationId, receipt.chatId, receipt.messageId, Date.now());
+    `).run(this.platform, receipt.conversationId, receipt.chatId, receipt.messageId, createdAt);
     }
     /** Returned once, then gone. `bookedBy` claims only what was on the books by
      *  then — see `Receipts.settle`. */
@@ -38,16 +38,20 @@ export class ReceiptLedger {
             .run(this.platform, conversationId, ...args);
         return rows.map(toReceipt);
     }
-    /** Claim receipts older than `ageMs`; `0` claims everything (startup sweep). */
-    takeStale(ageMs, now = Date.now()) {
+    /** Claim receipts older than `ageMs`; `0` claims everything (startup sweep).
+     *  A conversation `working` says yes to is skipped, whatever its age: its
+     *  turn is still going to settle. */
+    takeStale(ageMs, working = () => false, now = Date.now()) {
         const cutoff = now - ageMs;
         const rows = this.db.prepare(`
       SELECT conversation_id, chat_id, message_id FROM receipts
       WHERE platform = ? AND created_at <= ?
     `).all(this.platform, cutoff);
-        this.db.prepare("DELETE FROM receipts WHERE platform = ? AND created_at <= ?")
-            .run(this.platform, cutoff);
-        return rows.map(toReceipt);
+        const claimed = rows.map(toReceipt).filter(({ conversationId }) => !working(conversationId));
+        const drop = this.db.prepare("DELETE FROM receipts WHERE platform = ? AND chat_id = ? AND message_id = ?");
+        for (const { chatId, messageId } of claimed)
+            drop.run(this.platform, chatId, messageId);
+        return claimed;
     }
 }
 /** A receipt is booked synchronously (an instant turn must not clear an
@@ -59,21 +63,29 @@ export class Receipts {
     log;
     emoji;
     staleMs;
+    working;
     applying = new Map();
     sweptAt = 0;
     constructor(api, ledger, log, emoji, 
-    /** After this, a receipt's turn is assumed never to settle. */
-    staleMs) {
+    /** After this, a receipt whose conversation is idle is assumed never to
+     *  settle. A turn still running keeps its 👀 however long it takes. */
+    staleMs, working) {
         this.api = api;
         this.ledger = ledger;
         this.log = log;
         this.emoji = emoji;
         this.staleMs = staleMs;
+        this.working = working;
     }
-    mark(conversationId, chatId, messageId) {
+    /** `at` is when the turn this receipt belongs to began; it defaults to now,
+     *  which is right for a message someone typed. A system note is posted *by*
+     *  the turn that will clear it, so booking it at `now` — a round trip after
+     *  the turn started — would put it outside that turn's scope and leave the
+     *  reaction up until the stale sweep. */
+    mark(conversationId, chatId, messageId, at) {
         this.applying.set(`${chatId}:${messageId}`, this.api.setReaction(chatId, messageId, this.emoji)
             .catch((err) => this.log(`reaction failed: ${String(err)}`)));
-        this.ledger.add({ conversationId, chatId, messageId });
+        this.ledger.add({ conversationId, chatId, messageId }, at);
     }
     /** Only the messages *this* turn was working on: a message queued mid-turn
      *  is still owed an answer. `meta` says when the turn began; no meta clears
@@ -98,7 +110,8 @@ export class Receipts {
         if (!all && now - this.sweptAt < SWEEP_EVERY_MS)
             return Promise.resolve();
         this.sweptAt = now;
-        return this.clear(this.ledger.takeStale(all ? 0 : this.staleMs));
+        // The startup sweep needs no liveness check: no turn survives the process.
+        return this.clear(this.ledger.takeStale(all ? 0 : this.staleMs, all ? undefined : this.working));
     }
     async clear(receipts) {
         // A slow apply must not let a later receipt clear first.