@timqi/pier 0.0.16 → 0.0.19

package/dist/agent/events.js

@@ -184,13 +184,25 @@ export function toSessionEvents(e) {
         case "agent_start":
             return [{ type: "state", state: "streaming" }, { type: "turn-start" }];
         case "agent_end": {
+            // Pi retries a retryable provider error itself and emits one agent_end
+            // per attempt. Only the last one ends the turn: translating the others
+            // posts a reply and an error per attempt for a failure Pi is still
+            // recovering from, and an `idle` the session is not in.
+            if (e.willRetry)
+                return [];
             const final = lastAssistant(e.messages);
+            // A turn can end without the model ever answering. Carried twice on
+            // purpose: on turn-end because it is *how this turn ended*, which is what
+            // a task run settles on (tasks/agent.ts), and as the error event that is
+            // already every chat surface's failure path (core/router.ts).
+            const failure = final?.stopReason === "error"
+                ? final.errorMessage || "unknown agent error"
+                : undefined;
             const out = [
-                { type: "turn-end", text: textOf(final?.content) },
+                { type: "turn-end", text: textOf(final?.content), ...(failure ? { error: failure } : {}) },
             ];
-            if (final?.stopReason === "error") {
-                out.push({ type: "error", message: final.errorMessage ?? "unknown agent error" });
-            }
+            if (failure)
+                out.push({ type: "error", message: failure });
             out.push({ type: "state", state: "idle" });
             return out;
         }

package/dist/agent/listing.js

@@ -16,7 +16,7 @@
 // incremental.
 import { createReadStream, promises as fs } from "node:fs";
 import { join } from "node:path";
-import { pierDb } from "../db.js";
+import { pierDb, statements, transact } from "../db.js";
 import { SESSION_TITLE_MAX } from "../limits.js";
 import { logger } from "../log.js";
 import { defaultAgentDir } from "./config.js";
@@ -75,6 +75,7 @@ function fold(acc, line) {
 export class IndexedListing {
     dir;
     #db;
+    #statements;
     constructor(dir = join(defaultAgentDir(), "sessions"), db) {
         this.dir = dir;
         this.#db = db;
@@ -85,9 +86,12 @@ export class IndexedListing {
     #store() {
         return (this.#db ??= pierDb());
     }
+    /** The scan's three statements, compiled on the first scan and not again. */
+    #sql() {
+        return (this.#statements ??= statements(this.#store()));
+    }
     async scan() {
-        const db = this.#store();
-        const known = new Map(db.prepare("SELECT * FROM session_index").all().map((row) => [row.path, row]));
+        const known = new Map(this.#sql()("SELECT * FROM session_index").all().map((row) => [row.path, row]));
         const records = [];
         const write = [];
         for (const file of await this.#files()) {
@@ -228,26 +232,21 @@ export class IndexedListing {
         if (!rows.length && !gone.length)
             return;
         const db = this.#store();
-        const upsert = db.prepare(`INSERT INTO session_index(path, id, cwd, created_at, name, first_message, size, mtime, parsed_bytes)
+        const sql = this.#sql();
+        const upsert = sql(`INSERT INTO session_index(path, id, cwd, created_at, name, first_message, size, mtime, parsed_bytes)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(path) DO UPDATE SET
          id = excluded.id, cwd = excluded.cwd, created_at = excluded.created_at,
          name = excluded.name, first_message = excluded.first_message,
          size = excluded.size, mtime = excluded.mtime,
          parsed_bytes = excluded.parsed_bytes`);
-        const drop = db.prepare("DELETE FROM session_index WHERE path = ?");
-        db.exec("BEGIN");
-        try {
+        const drop = sql("DELETE FROM session_index WHERE path = ?");
+        transact(db, () => {
             for (const r of rows) {
                 upsert.run(r.path, r.id, r.cwd, r.created_at, r.name, r.first_message, r.size, r.mtime, r.parsed_bytes);
             }
             for (const path of gone)
                 drop.run(path);
-            db.exec("COMMIT");
-        }
-        catch (err) {
-            db.exec("ROLLBACK");
-            throw err;
-        }
+        });
     }
 }

package/dist/agent/pi.js

@@ -90,6 +90,17 @@ export const standDownShadowed = (base) => {
         }),
     };
 };
+/**
+ * A bundled skill stands down with the tool it documents. A skill's
+ * description is resident in every prompt, so one pointing at a tool this
+ * session was not given is both a cost and a route the agent cannot take.
+ */
+export const standDownUndocumented = (tools, skills) => {
+    const gone = new Set(tools.filter((tool) => tool.skill && !(tool.available?.() ?? true)).map((tool) => tool.skill));
+    if (!gone.size)
+        return skills;
+    return skills.filter((skill) => !gone.has(skill.name));
+};
 export class PiSession {
     pi;
     pinned;
@@ -285,8 +296,19 @@ export class PiSession {
         return this.pi.abort();
     }
     subscribe(fn) {
+        let retryPending = false;
         return this.pi.subscribe((event) => {
-            for (const payload of toSessionEvents(event)) {
+            const piEvent = event;
+            if (piEvent.type === "agent_end")
+                retryPending = piEvent.willRetry === true;
+            if (piEvent.type === "agent_settled" && retryPending) {
+                // Aborting Pi during retry backoff produces no final agent_end.
+                retryPending = false;
+                fn({ type: "turn-end", text: "", meta: this.lastTurnMeta() });
+                fn({ type: "state", state: "idle" });
+                return;
+            }
+            for (const payload of toSessionEvents(piEvent)) {
                 fn(payload.type === "turn-end" ? { ...payload, meta: this.lastTurnMeta() } : payload);
             }
         });
@@ -553,6 +575,10 @@ export class PiAgentFactory {
             // Pi's generic default, preserving the user's later instruction layer.
             systemPromptOverride: pierSystemPrompt,
             additionalSkillPaths: this.skillPaths,
+            skillsOverride: (base) => ({
+                ...base,
+                skills: standDownUndocumented(this.extraTools, base.skills),
+            }),
             extensionFactories: [
                 { name: "pier-bash-timeout", factory: bashTimeoutDefault, hidden: true },
                 ...inlineExtensions(this.enabledExtensions()),
@@ -688,7 +714,7 @@ export class PiAgentFactory {
      *  session this factory opened. The miss is what earns a fresh scan, because
      *  callers read it as permission to start a replacement session
      *  (channels/conversations.ts), which costs a conversation its history, or as
-     *  a session that no longer exists (tasks/, web/files.ts). `reused` is how we
+     *  a session that no longer exists (tasks/, web/server.ts). `reused` is how we
      *  know a scan is owed: same entry back, same disk state. */
     async locate(sessionId) {
         const find = (infos) => infos.find((s) => s.id === sessionId);

package/dist/boards/boards.js

@@ -122,15 +122,16 @@ export async function listBoards(dir) {
     catch {
         return []; // no boards yet
     }
-    const boards = [];
-    for (const slug of entries.sort()) {
+    // One board's manifest says nothing about the next one's, so the scan waits
+    // once for all of them rather than once per board.
+    const boards = await Promise.all(entries.sort().map(async (slug) => {
         const manifest = await readManifest(dir, slug);
         if (!manifest)
-            continue;
+            return null;
         const { title, description, sessions, public: isPublic, token } = manifest;
-        boards.push({ slug, title, description, sessions, public: isPublic, token, updatedAt: await updatedAt(dir, slug) });
-    }
-    return boards;
+        return { slug, title, description, sessions, public: isPublic, token, updatedAt: await updatedAt(dir, slug) };
+    }));
+    return boards.filter((board) => board !== null);
 }
 /** Containment, not normalization: the resolved realpath must sit inside the
  *  board's own site dir or nothing is served. */

package/dist/channels/attach.js

@@ -65,7 +65,14 @@ export async function sendAttachments(paths, upload, log) {
         log(`attachment ${path} not sent: ${reason}`);
         lost.push(lostMarker(nameOf(path), reason));
     };
-    for (const path of paths.slice(0, MAX_ATTACHMENTS)) {
+    const taken = paths.slice(0, MAX_ATTACHMENTS);
+    // Five files that know nothing about each other cost one round trip, not
+    // five. Two phases so the platform still receives them in the order the
+    // turn linked them, and each failure is kept in its own slot — `lost` reads
+    // in link order whichever upload finished first.
+    const reasons = [];
+    const reasonOf = (err) => (err instanceof Error ? err.message : String(err));
+    const files = await Promise.all(taken.map(async (path, i) => {
         try {
             const info = await stat(path);
             if (!info.isFile())
@@ -74,12 +81,19 @@ export async function sendAttachments(paths, upload, log) {
                 throw new Error(`too large (>${MAX_ATTACH_BYTES} bytes)`);
             const name = nameOf(path);
             const ext = extname(name).slice(1).toLowerCase();
-            await upload({ name, bytes: await readFile(path), image: IMAGE_EXT.has(ext) });
+            return { name, bytes: await readFile(path), image: IMAGE_EXT.has(ext) };
         }
         catch (err) {
-            fail(path, err instanceof Error ? err.message : String(err));
+            reasons[i] = reasonOf(err);
+            return undefined;
         }
-    }
+    }));
+    await Promise.all(files.map((file, i) => file ? upload(file).catch((err) => void (reasons[i] = reasonOf(err))) : undefined));
+    taken.forEach((path, i) => {
+        const reason = reasons[i];
+        if (reason !== undefined)
+            fail(path, reason);
+    });
     for (const path of paths.slice(MAX_ATTACHMENTS)) {
         fail(path, `more than ${MAX_ATTACHMENTS} files in one turn`);
     }

package/dist/channels/config.js

@@ -73,13 +73,18 @@ export class ChannelStore {
      * discovery is passive. A new chat copies the platform defaults and owns
      * them from then on — the mention and bind gates are what keep it harmless
      * until an operator configures it.
+     *
+     * Telegram gets a chat's name free with every update, so it discovers on
+     * every message: the "already known, unchanged" answer is read off the
+     * cached document and costs no clone. Only a real change pays for one.
      */
     discoverChat(platform, chat) {
+        const cached = this.cached(platform).chats.find((c) => c.id === chat.id);
+        if (cached && cached.name === chat.name && cached.kind === chat.kind)
+            return;
         const config = this.get(platform);
         const known = config.chats.find((c) => c.id === chat.id);
         if (known) {
-            if (known.name === chat.name && known.kind === chat.kind)
-                return;
             known.name = chat.name || known.name;
             known.kind = chat.kind;
         }

package/dist/channels/dedup.js

@@ -4,6 +4,9 @@
 // the second copy had already appeared and the map has an invariant that is
 // easy to lose on a rewrite: it is fed by every message in every chat the bot
 // is in, so it must be bounded and time-limited, never grow-only.
+/** Fraction of `max` a full map is cut back to, so the eviction walk is paid
+ *  once per that many messages instead of once per message. */
+const KEEP = 0.9;
 export class Dedup {
     log;
     ttlMs;
@@ -28,8 +31,13 @@ export class Dedup {
             // is a forgotten id under extreme load (a redelivery slips through,
             // which downstream handling tolerates); unbounded memory is worse.
             // Map iterates in insertion order, so the front is the oldest.
+            //
+            // Evicting down to `KEEP` rather than to exactly `max` is what makes
+            // the walk amortized: at the bound, freeing one slot per message meant
+            // re-walking the whole map on every message from then on.
+            const keep = Math.floor(this.max * KEEP);
             for (const [id] of this.seen) {
-                if (this.seen.size < this.max)
+                if (this.seen.size <= keep)
                     break;
                 this.seen.delete(id);
             }

package/dist/channels/lark.js

@@ -44,7 +44,6 @@ const DRAIN_TIMEOUT_MS = 5000;
 /** How long a delivered event id is remembered, against redelivery. */
 const DEDUP_TTL_MS = 5 * 60_000;
 const DEDUP_MAX = 2000;
-const SWEEP_EVERY_MS = 60_000;
 /**
  * A Lark conversation is always `<chatId>/<rootMessageId>` — the thread is
  * the session. This pair is the only definition of the format; control.ts
@@ -87,7 +86,6 @@ export class LarkChannel {
     out;
     socket;
     running = false;
-    sweptAt = 0;
     constructor(deps) {
         this.deps = deps;
         const config = deps.store.get("lark");
@@ -143,10 +141,8 @@ export class LarkChannel {
     onEvent(event, onMessage) {
         if (!this.running)
             return;
-        if (Date.now() - this.sweptAt > SWEEP_EVERY_MS) {
-            this.sweptAt = Date.now();
-            void this.receipts.sweep();
-        }
+        // Asked on every event, throttled inside receipts.ts.
+        void this.receipts.sweep();
         // Our own echo or another app's message.
         if (event.senderType === "app")
             return;

package/dist/channels/receipts.js

@@ -8,6 +8,14 @@
 // it finds at startup (nothing in memory can be its own yet), and sweeps its
 // own stragglers on a timer.
 import { pierDb } from "../db.js";
+/**
+ * How often the straggler sweep may really run. Adapters ask on the inbound
+ * path — per envelope, or per `getUpdates` round trip — and the books only
+ * change on the scale of `staleMs`, so a busy chat would otherwise run this
+ * query hundreds of times a minute. Throttled here rather than in each
+ * adapter, which is where the same timestamp had been copied twice already.
+ */
+const SWEEP_EVERY_MS = 60_000;
 const toReceipt = (row) => ({
     conversationId: row.conversation_id,
     chatId: row.chat_id,
@@ -68,6 +76,7 @@ export class Receipts {
     staleMs;
     /** In-flight `setReaction` per marked message. Only this process's own. */
     applying = new Map();
+    sweptAt = 0;
     constructor(api, ledger, log, emoji, 
     /** After this, a receipt's turn is assumed never to settle. */
     staleMs) {
@@ -106,14 +115,20 @@ export class Receipts {
      * ours yet — and past `staleMs` a receipt's turn is never going to settle.
      */
     sweep(all = false) {
+        const now = Date.now();
+        // `all` is the startup sweep: it takes everything, so it is never skipped.
+        if (!all && now - this.sweptAt < SWEEP_EVERY_MS)
+            return Promise.resolve();
+        this.sweptAt = now;
         return this.clear(this.ledger.takeStale(all ? 0 : this.staleMs));
     }
     async clear(receipts) {
-        for (const { chatId, messageId } of receipts) {
-            const key = `${chatId}:${messageId}`;
-            await this.applying.get(key);
-            this.applying.delete(key);
-            await this.api.setReaction(chatId, messageId, null).catch(() => { });
-        }
+        // Wait together, then launch clears in booking order: if one apply is slow,
+        // it must not let a later receipt clear first.
+        await Promise.all(receipts.map(({ chatId, messageId }) => this.applying.get(`${chatId}:${messageId}`)));
+        for (const { chatId, messageId } of receipts)
+            this.applying.delete(`${chatId}:${messageId}`);
+        await Promise.all(receipts.map(({ chatId, messageId }) => this.api.setReaction(chatId, messageId, null)
+            .catch((err) => this.log(`reaction clear failed: ${String(err)}`))));
     }
 }

package/dist/channels/slack-tool.js

@@ -27,19 +27,25 @@ const tsToNumber = (ts) => Number(ts);
 const tsToIso = (ts) => new Date(Math.floor(tsToNumber(ts) * 1000)).toISOString();
 /** Minute precision in the transcript: the exact time is in the `ts` beside it. */
 const tsToMinute = (ts) => `${tsToIso(ts).slice(0, 16)}Z`;
+/** Epoch seconds at the year 2100: past this, the caller meant milliseconds. */
+const MAX_SECONDS = 4_102_444_800;
 /** Accepts an ISO date, an epoch-seconds number, or a raw Slack ts. */
 export function toTs(value) {
     if (value === undefined || value === "")
         return undefined;
-    if (typeof value === "number")
-        return String(value);
-    const trimmed = value.trim();
-    if (/^\d+(\.\d+)?$/.test(trimmed))
-        return trimmed;
-    const parsed = Date.parse(trimmed);
-    if (Number.isNaN(parsed))
+    const raw = typeof value === "number" ? String(value) : value.trim();
+    // A ts is passed through untouched — it is an id, not a number to reformat.
+    const numeric = /^\d+(\.\d+)?$/.test(raw);
+    const seconds = numeric ? Number(raw) : Date.parse(raw) / 1000;
+    if (Number.isNaN(seconds))
         throw new Error(`not a time: ${value}`);
-    return String(parsed / 1000);
+    // Milliseconds are the mistake worth naming: Slack takes the window without
+    // complaint, finds nothing that far in the future, and answers with an empty
+    // read that is indistinguishable from a channel where nobody spoke.
+    if (seconds > MAX_SECONDS) {
+        throw new Error(`${value} is past the year 2100 — Slack times are epoch seconds, not milliseconds`);
+    }
+    return numeric ? raw : String(seconds);
 }
 /**
  * Whether a session opened now is given the tool at all: the same two switches
@@ -91,6 +97,8 @@ export function slackToolSpec(execute, available) {
             text: Type.Optional(Type.String()),
         }),
         available,
+        // Stands down with the tool: without Slack, its manual is a route to nowhere.
+        skill: "pier-slack",
         execute,
     };
 }
@@ -165,10 +173,12 @@ export async function handleSlackTool(deps, raw, callerSessionId = "") {
     // own bounds are inclusive-ish, so the boundary message is dropped here
     // rather than trusted to the API.
     const after = toTs(input.after);
+    // Both reads take it, so it is read once: a cap that worked on a channel and
+    // was ignored on a thread would be the more expensive kind of surprise.
+    const limit = Math.min(Number(input.limit) || MAX_MESSAGES, MAX_MESSAGES);
     if (input.operation === "read_channel") {
         const since = after ?? toTs(input.since);
         const until = toTs(input.until);
-        const limit = Math.min(Number(input.limit) || MAX_MESSAGES, MAX_MESSAGES);
         return readChannel(deps, client, channel, since, until, after, limit);
     }
     if (input.operation === "read_thread") {
@@ -177,7 +187,7 @@ export async function handleSlackTool(deps, raw, callerSessionId = "") {
             : at?.threadTs;
         if (!threadTs)
             throw new Error("thread_ts is required outside a Slack thread");
-        return readThread(deps, client, channel, threadTs, after);
+        return readThread(deps, client, channel, threadTs, after, limit);
     }
     if (input.operation === "read_message") {
         const asked = typeof input.thread_ts === "string" ? input.thread_ts.trim() : "";
@@ -204,6 +214,7 @@ export async function handleSlackTool(deps, raw, callerSessionId = "") {
             at: sent.ts ? tsToIso(sent.ts) : null,
             // Returned so a follow-up can reply under what was just posted.
             threadTs: threadTs ?? sent.ts,
+            ...inertMention(text),
         };
     }
     if (input.operation === "edit") {
@@ -211,14 +222,23 @@ export async function handleSlackTool(deps, raw, callerSessionId = "") {
         // and Slack keeps no visible record of what it said before.
         const ts = required(input.ts, "ts");
         const text = messageText(input.text);
+        // Defaulted from `here` as `post` is: a correction is nearly always to a
+        // reply the agent made in this thread, and `conversations.history` cannot
+        // see inside a thread — without this the read below always comes up empty.
+        const asked = typeof input.thread_ts === "string" ? input.thread_ts.trim() : "";
+        const inThread = asked || (channel === at?.channel ? at?.threadTs : undefined);
+        // Read before the write, because after it the old wording exists nowhere:
+        // Slack keeps no version, so this log is the only record of what was
+        // replaced. Best-effort — a failed read must not block the correction.
+        const was = await previousText(client, channel, ts, inThread);
         try {
             await client.updateMessage({ channel, ts, text, blocks: [{ type: "markdown", text }] });
         }
         catch (err) {
             throw new Error(explain(err));
         }
-        deps.log(`slack tool edited ${ts} in ${channel}`);
-        return { channel, ts, edited: true };
+        deps.log(`slack tool edited ${ts} in ${channel}; was: ${was ?? "(not captured)"}`);
+        return { channel, ts, edited: true, ...inertMention(text) };
     }
     if (input.operation === "delete") {
         // Never defaulted from `here`: the thread's ts is the parent message, and
@@ -237,6 +257,50 @@ export async function handleSlackTool(deps, raw, callerSessionId = "") {
     }
     throw new Error(`unknown slack operation: ${String(input.operation)}`);
 }
+/**
+ * The one message at `ts`. A `ts` is unique only within its conversation, and
+ * `conversations.history` never returns what was posted inside a thread — so a
+ * reply has to be asked for through its thread, and only the caller knows.
+ */
+async function oneMessage(client, channel, ts, threadTs) {
+    const page = threadTs
+        ? await client.replies(channel, threadTs, { oldest: ts, limit: 20 })
+        : await client.history(channel, { oldest: ts, latest: ts, limit: 1 });
+    return page.messages.find((msg) => msg.ts === ts);
+}
+/** One line of what a message said, for the log an edit leaves behind. */
+async function previousText(client, channel, ts, threadTs) {
+    try {
+        const text = (await oneMessage(client, channel, ts, threadTs))?.text;
+        return text === undefined ? undefined : text.slice(0, 200).replace(/\s+/g, " ");
+    }
+    catch {
+        // Not swallowed: the caller logs that the old wording was not captured,
+        // which is the fact that matters. Refusing the edit over it would be worse.
+        return undefined;
+    }
+}
+/**
+ * A plain `@alice` is the one Slack mistake that looks like it worked: the
+ * message goes up, renders as text, and notifies nobody. Reported after the
+ * fact rather than refused — a name in prose is legitimate, an unping is not
+ * worth losing the message over.
+ */
+function inertMention(text) {
+    const prose = text
+        .replace(/```[\s\S]*?```|`[^`]*`/g, "") // code says @ and # for other reasons
+        .replace(/<[^>]*>/g, ""); // already Slack syntax
+    const hit = /(?:^|\s)([@#][A-Za-z][\w.-]*)/.exec(prose)?.[1];
+    if (!hit)
+        return {};
+    const as = hit.startsWith("@")
+        ? /^@(here|channel|everyone)$/.test(hit) ? `<!${hit.slice(1)}>` : "<@U…>"
+        : "<#C…>";
+    return {
+        hint: `${hit} is plain text and notified nobody — Slack needs ${as}. ` +
+            `Edit this ts if it was meant to reach someone.`,
+    };
+}
 /** Accept a `#name` or a bare name as well as an id — models prefer names. */
 function resolveChannel(deps, given) {
     if (/^[CDG][A-Z0-9]+$/.test(given))
@@ -265,30 +329,27 @@ async function readChannel(deps, client, channel, since, until, after, limit) {
         messages: await lines(deps, client, window),
     };
 }
-async function readThread(deps, client, channel, threadTs, after) {
+async function readThread(deps, client, channel, threadTs, after, limit) {
     const fetched = await fetchPages(deps, (cursor) => client.replies(channel, threadTs, { oldest: after, cursor }), `thread ${threadTs} in ${channel}`);
-    const messages = newerThan(transcript(fetched.messages), after);
+    const all = newerThan(transcript(fetched.messages), after);
+    // Oldest first, as in a channel read: a thread cut at its newest end still
+    // reads as a thread, and the cut has to be said either way — a long thread
+    // that answers as if it were complete is the read nobody double-checks.
+    const messages = all.slice(0, limit);
     return {
         channel,
         // Hoisted: every line in a thread carries the same one.
         threadTs,
         count: messages.length,
+        ...(fetched.truncated || all.length > messages.length ? { truncated: true } : {}),
         ...(fetched.incomplete ? { incomplete: fetched.incomplete } : {}),
         format: LINE_FORMAT,
         messages: await lines(deps, client, messages),
     };
 }
-/**
- * One message, because that is sometimes the whole question. A `ts` is unique
- * only within its conversation, and `conversations.history` never returns what
- * was posted inside a thread — so a reply has to be asked for through its
- * thread, and saying which one is the caller's job.
- */
+/** One message, because that is sometimes the whole question. */
 async function readMessage(deps, client, channel, ts, threadTs) {
-    const page = threadTs
-        ? await client.replies(channel, threadTs, { oldest: ts, limit: 20 })
-        : await client.history(channel, { oldest: ts, latest: ts, limit: 1 });
-    const found = page.messages.find((msg) => msg.ts === ts);
+    const found = await oneMessage(client, channel, ts, threadTs);
     if (!found) {
         throw new Error(threadTs
             ? `no message ${ts} in thread ${threadTs}`
@@ -342,7 +403,7 @@ function explain(err) {
     const code = /slack [\w.]+: (\w+)/.exec(String(err))?.[1] ?? "";
     return {
         channel_not_found: "no such channel, or Pier's bot cannot see it — check the channels operation",
-        not_in_channel: "Pier's bot is not in that channel; someone has to invite it before it can read",
+        not_in_channel: "Pier's bot is not in that channel; someone has to run `/invite @Pier` there before it can read",
         missing_scope: "Pier's Slack app lacks the scope for this call; the operator must reinstall it",
         ratelimited: "Slack rate-limited Pier; wait a minute, and narrow the range if this was a read",
         thread_not_found: "no thread with that ts in this channel",

package/dist/channels/slack.js

@@ -52,8 +52,6 @@ const DRAIN_TIMEOUT_MS = 5000;
  */
 const DEDUP_TTL_MS = 5 * 60_000;
 const DEDUP_MAX = 2000;
-/** How often the straggler sweep may run; see onEnvelope. */
-const SWEEP_EVERY_MS = 60_000;
 /**
  * Commands that may appear as a bare word, and exactly how many arguments each
  * takes. Both halves are load-bearing, because Slack gives us no leading `/` to
@@ -132,7 +130,6 @@ export class SlackChannel {
     out;
     socket;
     running = false;
-    sweptAt = 0;
     constructor(deps) {
         this.deps = deps;
         const config = deps.store.get("slack");
@@ -195,13 +192,8 @@ export class SlackChannel {
     onEnvelope(env, onMessage) {
         if (!this.running)
             return;
-        // Envelopes arrive pushed, not in polled batches, so the sweep is timed
-        // rather than per-envelope: a busy channel would otherwise run this query
-        // hundreds of times a minute for something that changes every 30.
-        if (Date.now() - this.sweptAt > SWEEP_EVERY_MS) {
-            this.sweptAt = Date.now();
-            void this.receipts.sweep();
-        }
+        // Asked on every envelope, throttled inside receipts.ts.
+        void this.receipts.sweep();
         if (env.type === "events_api") {
             const payload = env.payload;
             const event = payload?.event;

package/dist/channels/telegram.js

@@ -124,6 +124,7 @@ export class TelegramChannel {
                 const updates = await this.api.getUpdates(this.offset, POLL_SECONDS);
                 if (!this.running)
                     return;
+                // Asked on every round trip, throttled inside receipts.ts.
                 void this.receipts.sweep();
                 if (!updates.length && Date.now() - startedAt < 1000) {
                     await new Promise((r) => setTimeout(r, 1000));

package/dist/core/hub.js

@@ -36,9 +36,18 @@ export class EventHub {
             sessionId,
             ...payload,
         };
-        b.buffer.push(event);
-        if (b.buffer.length > RING_SIZE)
-            b.buffer.shift();
+        // Text deltas fan out live but never enter the ring: one long reply emits
+        // thousands of them, so a ring that held them would hold *only* them and
+        // would have evicted the turn-start, tool and turn-end events a
+        // reconnecting client replays for. The text is not lost — `turn-end`
+        // carries the full reply (web/ui/chat.ts treats it as authoritative).
+        // Thinking stays replayable because a native EventSource reconnect does
+        // not reload the transcript snapshot that would otherwise restore it.
+        if (payload.type !== "text-delta") {
+            b.buffer.push(event);
+            if (b.buffer.length > RING_SIZE)
+                b.buffer.shift();
+        }
         fanOut(b.subscribers, event);
     }
     subscribe(sessionId, fn) {
@@ -46,7 +55,8 @@ export class EventHub {
         b.subscribers.add(fn);
         return () => b.subscribers.delete(fn);
     }
-    /** Events with seq > afterSeq still held in the ring buffer. */
+    /** Events with seq > afterSeq still held in the ring buffer — oldest first,
+     *  and without text deltas, which are live-only. */
     replay(sessionId, afterSeq) {
         return this.bus(sessionId).buffer.filter((e) => e.seq > afterSeq);
     }

package/dist/core/inbox.js

@@ -11,7 +11,7 @@ import { randomBytes } from "node:crypto";
 import { basename, join } from "node:path";
 import { pierPath } from "../paths.js";
 import { fileMarker, lostMarker, MAX_INBOUND_BYTES, safeName } from "./inbound-file.js";
-/** Where every inbound file lives; web/files.ts allowlists this root. */
+/** Where every inbound file lives; the attachment route allowlists this root. */
 export const INBOX_DIR = pierPath("inbox");
 /**
  * Write one inbound file and return its absolute path. The timestamp-random