@timqi/pier 0.1.3 → 0.1.5

package/dist/channels/slack-panel.js

@@ -1,23 +1,26 @@
-// Slack's half of the settings panel (panel.ts has the rest). The modal's
-// `private_metadata` carries the conversation, so a submission needs no
-// adapter-side state and survives a reload.
-import { ChatPanel, CWD_PLACEHOLDER, CWD_TAIL, PANEL_PREFIX, } from "./panel.js";
-import { context, escapeMrkdwn as esc, section } from "./slack-render.js";
+// Slack's half of the settings panel (panel.ts has the rest). Every button's
+// `value` and the modal's `private_metadata` carry the draft with the card's
+// coordinates, so a click or a submission after a reload is understood from
+// the payload alone and lands on the message the user is looking at.
+import { ChatPanel, CWD_DRAFT_TAIL, CWD_PLACEHOLDER, holdQuestion, PANEL_PREFIX, readDraft, serializeDraft, } from "./panel.js";
+import { context, escapeMrkdwn as esc, section, truncate } from "./slack-render.js";
+import { chatOf } from "./types.js";
 const CWD_VIEW = "cfg_cwd";
 const CWD_BLOCK = "cwd_block";
 const CWD_INPUT = "cwd_input";
-const button = (b) => ({
+const button = (b, value) => ({
     type: "button",
     action_id: `${PANEL_PREFIX}${b.action}`,
-    text: { type: "plain_text", text: b.label, emoji: true },
+    text: { type: "plain_text", text: truncate(b.label), emoji: true },
+    ...(value ? { value } : {}),
 });
-const row = (buttons) => ({
+const row = (buttons, value) => ({
     type: "actions",
-    elements: buttons.map(button),
+    elements: buttons.map((b) => button(b, value)),
 });
+const fresh = (channel, ts, draft) => ({ chatId: channel, ts, draft, dirs: [], sessions: [] });
 export class SlackPanel extends ChatPanel {
     deps;
-    platform = "slack";
     fence = ["`", "`"];
     constructor(deps) {
         super(deps);
@@ -26,30 +29,64 @@ export class SlackPanel extends ChatPanel {
     esc(text) {
         return esc(text);
     }
+    /** Said on the next redraw when a value could not be read: the picks it held are gone. */
+    resetNote;
+    /** A malformed value is a stale or foreign card: logged, drawn as an empty draft, and said. */
+    parseDraft(raw) {
+        if (!raw)
+            return {};
+        try {
+            return readDraft(JSON.parse(raw));
+        }
+        catch (err) {
+            this.deps.log(`unreadable panel value, draft reset: ${String(err)}`);
+            this.resetNote = "Your earlier picks could not be read — pick again.";
+            return {};
+        }
+    }
     // --- rendering -------------------------------------------------------------
-    blocks(view, note) {
+    blocks(view, draft, note) {
+        const value = serializeDraft(draft);
         return [
             ...view.groups.map((g) => section([`*${g.title}*${g.suffix ?? ""}`, ...g.lines].join("\n"))),
-            ...(view.picks?.length ? [row(view.picks)] : []),
-            ...view.rows.filter((r) => r.length).map(row),
+            ...(view.picks?.length ? [row(view.picks, value)] : []),
+            ...view.rows.filter((r) => r.length).map((r) => row(r, value)),
             ...(note ? [context(esc(note))] : []),
         ];
     }
-    async open(key, channel, threadTs) {
-        const sent = await this.deps.api.postMessage({
-            channel,
-            thread_ts: threadTs,
-            text: "Settings",
-            blocks: this.blocks(await this.view(key, channel)),
-        });
-        this.remember(key, { chatId: channel, threadTs, ts: sent.ts, models: [] });
+    /** A card that cannot be posted must not look like nothing happening: the
+     *  thread gets the reason as plain text. */
+    async open(key, channel, threadTs, question) {
+        const draft = holdQuestion(question);
+        const state = fresh(channel, "", draft);
+        let sent;
+        try {
+            sent = await this.deps.api.postMessage({
+                channel,
+                thread_ts: threadTs,
+                text: "Settings",
+                blocks: this.blocks(await this.view(key, state), draft),
+            });
+        }
+        catch (err) {
+            this.deps.log(`panel open failed: ${String(err)}`);
+            await this.deps.api.postMessage({
+                channel,
+                thread_ts: threadTs,
+                text: `Could not open the panel: ${String(err)}`,
+            }).catch((e) => this.deps.log(`panel open failure not posted: ${String(e)}`));
+            return;
+        }
+        this.remember(key, { ...state, ts: sent.ts });
     }
     async draw(state, view, note) {
+        const said = note ?? this.resetNote;
+        this.resetNote = undefined;
         await this.deps.api.updateMessage({
             channel: state.chatId,
             ts: state.ts,
             text: "Settings",
-            blocks: this.blocks(view, note),
+            blocks: this.blocks(view, state.draft, said),
         }).catch((err) => this.deps.log(`panel edit failed: ${String(err)}`));
     }
     async erase(state) {
@@ -57,35 +94,32 @@ export class SlackPanel extends ChatPanel {
             .catch((err) => this.deps.log(`panel close failed: ${String(err)}`));
     }
     // --- actions ---------------------------------------------------------------
-    /** Returns false when the action is not ours. */
-    async onAction(interaction, key, actionId) {
-        return this.dispatch(key, actionId, interaction, async () => {
-            const channel = interaction.channel?.id;
-            const message = interaction.message;
-            if (channel && message)
-                await this.open(key, channel, message.thread_ts ?? message.ts);
-        });
+    /** Returns false when the action is not ours. `run` delivers Start's
+     *  question as the clicker's message. */
+    async onAction(interaction, key, actionId, run) {
+        return this.dispatch(key, actionId, interaction, () => fresh(interaction.channel?.id ?? chatOf(key.conversationId), interaction.message?.ts ?? "", this.parseDraft(interaction.actions?.[0]?.value)), run);
     }
     // --- working directory (one typed answer, in a modal) ----------------------
-    async promptCwd(key, _state, interaction) {
+    async promptCwd(key, state, interaction) {
         const trigger = interaction.trigger_id;
         if (!trigger) {
             await this.refresh(key, "Could not open the dialog — try again.");
             return;
         }
+        const metadata = { conversation: key.conversationId, ts: state.ts, draft: serializeDraft(state.draft) };
         await this.deps.api.openView(trigger, {
             type: "modal",
             callback_id: CWD_VIEW,
-            private_metadata: key.conversationId,
-            title: { type: "plain_text", text: "New session" },
-            submit: { type: "plain_text", text: "Start" },
+            private_metadata: JSON.stringify(metadata),
+            title: { type: "plain_text", text: "Directory" },
+            submit: { type: "plain_text", text: "Set" },
             close: { type: "plain_text", text: "Cancel" },
             blocks: [
                 {
                     type: "input",
                     block_id: CWD_BLOCK,
                     label: { type: "plain_text", text: "Working directory" },
-                    hint: { type: "plain_text", text: `An absolute path. ${CWD_TAIL}` },
+                    hint: { type: "plain_text", text: `An absolute path. ${CWD_DRAFT_TAIL}` },
                     element: {
                         type: "plain_text_input",
                         action_id: CWD_INPUT,
@@ -100,11 +134,18 @@ export class SlackPanel extends ChatPanel {
         const view = interaction.view;
         if (view?.callback_id !== CWD_VIEW)
             return false;
-        const key = {
-            channelId: "slack",
-            conversationId: view.private_metadata ?? "",
-        };
-        await this.startSessionIn(key, (view.state?.values?.[CWD_BLOCK]?.[CWD_INPUT]?.value ?? "").trim());
+        let meta;
+        try {
+            meta = JSON.parse(view.private_metadata ?? "");
+        }
+        catch (err) {
+            this.deps.log(`cwd modal without readable metadata, dropped: ${String(err)}`);
+            return true;
+        }
+        const key = { channelId: "slack", conversationId: meta.conversation };
+        if (!this.state(key))
+            this.remember(key, fresh(chatOf(meta.conversation), meta.ts, this.parseDraft(meta.draft)));
+        await this.chooseDir(key, (view.state?.values?.[CWD_BLOCK]?.[CWD_INPUT]?.value ?? "").trim());
         return true;
     }
 }

package/dist/channels/slack-render.js

@@ -2,6 +2,7 @@
 // `actions` row. mrkdwn is not markdown (`*bold*`, `_italic_`, `~strike~`,
 // `<url|label>`), so the agent's markdown is translated; Slack degrades unknown
 // syntax to literal text rather than rejecting the message.
+import { cut } from "../core/reply.js";
 import { balanceFences, chunkText } from "./chunk.js";
 /** Slack caps `markdown` blocks at 12,000 cumulative chars per message. */
 export const MARKDOWN_MAX = 11_000;
@@ -97,7 +98,8 @@ export const context = (text) => ({
 /** `action_id` carries an index: the label is read back off the message Slack
  *  echoes with the click, so a button survives a reload. */
 export const OFFER_PREFIX = "sg:";
-const truncate = (label) => label.length > BUTTON_MAX ? `${label.slice(0, BUTTON_MAX - 1)}\u2026` : label;
+/** Slack refuses a button label over BUTTON_MAX: every button, the panel's too. */
+export const truncate = (label) => cut(label, BUTTON_MAX);
 /** Slack wraps buttons on its own, so there is no row packing to budget. */
 export function actions(labels) {
     if (!labels.length)

package/dist/channels/slack-thread.js

@@ -0,0 +1,41 @@
+// A Slack thread as transcript lines for the prompt: what a forwarded thread
+// parent is read into when a person hands the agent a message. One page, since
+// the adapter only inlines a thread it already knows to be short; anything
+// longer is the pier-slack skill's business, in a shell.
+import { ordered, transcript } from "./slack-transcript.js";
+/** Terse: this string goes in a prompt, so every word is paid for per read. */
+const LINE_FORMAT = "<ts> HH:MM name[id]: text, local time, a date line when the day changes;"
+    + " [thread N · <ts>] marks a parent, [file <name> <F…> <size>] an upload";
+/** Error codes an agent can act on become the action; the rest keep their
+ *  searchable raw code. */
+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",
+        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 before reading again",
+        thread_not_found: "no thread with that ts in this channel",
+    }[code] ?? String(err);
+}
+/** Oldest first, one per ts, cut to `limit` at the newest end and saying so. */
+export async function readThread(directory, client, channel, threadTs, limit) {
+    let page;
+    try {
+        page = await client.replies(channel, threadTs, { limit });
+    }
+    catch (err) {
+        throw new Error(explain(err));
+    }
+    const all = ordered(page.messages);
+    const window = all.slice(0, limit);
+    // Only users: a bot names itself, and users.info on a `B…` id fails.
+    const ids = window.map((msg) => msg.user ?? "").filter(Boolean);
+    const names = await directory.names(client, ids);
+    return {
+        count: window.length,
+        ...(page.nextCursor || all.length > window.length ? { truncated: true } : {}),
+        format: LINE_FORMAT,
+        messages: transcript(window, names, { ts: true, ids: true, thread: true }),
+    };
+}

package/dist/channels/slack-transcript.js

@@ -0,0 +1,107 @@
+// The one transcript format a Slack conversation is read in: the adapter's
+// inline forwarded thread (slack-thread.ts) and `pier slack` (slack-cli.ts)
+// both render through here, so the pier-slack skill describes it once and no
+// header repeats it. Lines, not objects: forty six-key objects spend most of
+// their tokens on key names.
+const pad = (n) => String(n).padStart(2, "0");
+const local = (ts) => new Date(Math.floor(Number(ts) * 1000));
+export const localDate = (ts) => {
+    const d = local(ts);
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+};
+export const localTime = (ts) => {
+    const d = local(ts);
+    return `${pad(d.getHours())}:${pad(d.getMinutes())}`;
+};
+export const localStamp = (ts) => `${localDate(ts)} ${localTime(ts)}`;
+/** `+0800`: the header carries it once so HH:MM needs no suffix. */
+export function tzLabel(now = new Date()) {
+    const minutes = -now.getTimezoneOffset();
+    const abs = Math.abs(minutes);
+    return `${minutes < 0 ? "-" : "+"}${pad(Math.floor(abs / 60))}${pad(abs % 60)}`;
+}
+/** Enough to judge a fetch against the 32 MB cap without arithmetic. */
+const sizeLabel = (bytes) => bytes < 1024
+    ? `${bytes}B`
+    : bytes < 1024 * 1024
+        ? `${Math.round(bytes / 1024)}KB`
+        : `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+const speaker = (msg) => msg.user ?? msg.bot_id;
+/** Oldest first, one per ts (page seams repeat), strictly newer than `after`.
+ *  Compared as numbers: a `ts` is `<epoch seconds>.<microseconds>`. */
+export function ordered(messages, after) {
+    const byTs = new Map();
+    for (const msg of messages)
+        if (msg.ts)
+            byTs.set(msg.ts, msg);
+    const all = [...byTs.values()].sort((a, b) => Number(a.ts) - Number(b.ts));
+    return after ? all.filter((m) => Number(m.ts) > Number(after)) : all;
+}
+/** The text, or a stand-in for a message whose content is only blocks or attachments. */
+function body(msg) {
+    if (msg.text)
+        return msg.text;
+    const titles = (msg.attachments ?? []).map((a) => a.title || a.fallback || a.text);
+    if (titles.length)
+        return titles.map((t) => (t ? `[attachment: ${t}]` : "[attachment]")).join(" ");
+    return msg.blocks?.length ? "[blocks]" : "";
+}
+function markers(msg, inThread) {
+    const out = [];
+    if (msg.edited)
+        out.push("[edited]");
+    if (msg.reply_count && (msg.thread_ts ?? msg.ts) === msg.ts) {
+        out.push(`[thread ${msg.reply_count} · ${msg.ts}]`);
+    }
+    else if (!inThread && msg.thread_ts && msg.thread_ts !== msg.ts) {
+        // A reply also sent to the channel; under its parent the indent says where it is.
+        out.push(`[in thread ${msg.thread_ts}]`);
+    }
+    for (const file of msg.files ?? []) {
+        out.push(`[file ${file.name ?? file.mimetype ?? "file"} ${file.id}${file.size === undefined ? "" : ` ${sizeLabel(file.size)}`}]`);
+    }
+    if (msg.reactions?.length) {
+        out.push(`[${msg.reactions.map((r) => `:${r.name}: ${r.count ?? 1}`).join(", ")}]`);
+    }
+    return out;
+}
+/** One message as lines: `HH:MM name: text [markers]`, continuation lines
+ *  indented four past the message. `names` resolves user ids; a bot names itself. */
+export function renderMessage(msg, names, opts = {}, indent = "") {
+    const id = speaker(msg);
+    const name = msg.user
+        ? names.get(msg.user) ?? msg.user
+        : msg.bot_profile?.name ?? msg.username ?? id;
+    const who = !id || !name ? "unknown" : opts.ids && name !== id ? `${name}[${id}]` : name;
+    const [first = "", ...rest] = body(msg).split("\n");
+    const lines = [
+        `${indent}${opts.ts ? `${msg.ts ?? ""} ` : ""}${localTime(msg.ts ?? "0")} ${who}:${first ? ` ${first}` : ""}`,
+        ...rest.map((line) => `${indent}    ${line}`),
+    ];
+    const tail = markers(msg, opts.thread || indent !== "").join(" ");
+    if (tail)
+        lines[lines.length - 1] += ` ${tail}`;
+    return lines;
+}
+/** Messages in the order given, a date line before the first and whenever the
+ *  local day changes, replies two spaces under their parent. */
+export function transcript(messages, names, opts = {}) {
+    const out = [];
+    let day = "";
+    const push = (msg, indent) => {
+        const date = localDate(msg.ts ?? "0");
+        if (date !== day) {
+            out.push(date);
+            day = date;
+        }
+        out.push(...renderMessage(msg, names, opts, indent));
+    };
+    for (const msg of messages) {
+        push(msg, "");
+        for (const reply of msg.replies ?? [])
+            push(reply, "  ");
+    }
+    return out;
+}
+/** `# <scope> · <tz> · <N> messages · last <ts>`: `last` is what `--after` takes next time. */
+export const header = (scope, count, last) => `# ${scope} · ${tzLabel()} · ${count} messages${last ? ` · last ${last}` : ""}`;

package/dist/channels/slack.js

@@ -10,21 +10,22 @@ import { awaitsTurn } from "../core/reply.js";
 import { bindHint, bindResult, picked, STALE_OPTION, STOPPED } from "./lines.js";
 import { logger } from "../log.js";
 import { Chains } from "./chains.js";
-import { parseCommand } from "./commands.js";
+import { parseCommand, settingsDraft } from "./commands.js";
 import { Dedup } from "./dedup.js";
 import { Gatekeeper } from "./gatekeeper.js";
 import { ReceiptLedger, Receipts } from "./receipts.js";
 import { SlackDirectory } from "./slack-directory.js";
 import { SlackApi, } from "./slack-api.js";
 import { SlackOutbound } from "./slack-outbound.js";
-import { readThread, slackToolAvailable } from "./slack-tool.js";
 import { SlackPanel } from "./slack-panel.js";
+import { readThread } from "./slack-thread.js";
 import { context, escapeMrkdwn, offeredLabel } from "./slack-render.js";
 const WORKING = "eyes";
 // The envelope is already acked, so this bounds concurrency (sockets,
 // downloads), not the backlog.
 const MAX_ACTIVE_CHATS = 16;
-const RECEIPT_STALE_MS = 30 * 60_000;
+/** Only an idle conversation ages out, so this need not cover a long turn. */
+const RECEIPT_STALE_MS = 10 * 60_000;
 const DRAIN_TIMEOUT_MS = 5000;
 /** Only has to cover a redelivery that crossed our immediate ack. */
 const DEDUP_TTL_MS = 5 * 60_000;
@@ -90,7 +91,7 @@ export class SlackChannel {
         const config = deps.store.get("slack");
         this.log = deps.log ?? ((m) => logger("slack").warn(m));
         this.chains = new Chains(this.log, MAX_ACTIVE_CHATS);
-        this.directory = deps.directory ?? new SlackDirectory(this.log);
+        this.directory = new SlackDirectory(this.log);
         this.gate = new Gatekeeper(deps.store, "slack", this.log, "channel");
         this.seen = new Dedup(this.log, DEDUP_TTL_MS, DEDUP_MAX);
         this.api = deps.client ?? new SlackApi(config.token, config.appToken, this.log);
@@ -101,12 +102,12 @@ export class SlackChannel {
             setReaction: (channel, ts, emoji) => emoji
                 ? this.api.addReaction(channel, ts, emoji)
                 : this.api.removeReaction(channel, ts, WORKING),
-        }, deps.receipts ?? new ReceiptLedger("slack"), this.log, WORKING, RECEIPT_STALE_MS);
-        if (deps.control) {
+        }, deps.receipts ?? new ReceiptLedger("slack"), this.log, WORKING, RECEIPT_STALE_MS, (conversationId) => deps.control?.working({ channelId: this.id, conversationId }) ?? false);
+        if (deps.control && deps.handoff) {
             this.panel = new SlackPanel({
                 api: this.api,
                 control: deps.control,
-                store: deps.store,
+                handoff: deps.handoff,
                 log: this.log,
             });
         }
@@ -218,14 +219,17 @@ export class SlackChannel {
             return this.bind(channel, event.user, threadTs, command?.args ?? "");
         if (command?.name === "stop")
             return this.abortTurn(here, channel, threadTs);
-        // A bare `@bot` and `settings` are the same request.
-        if (this.panel && (command?.name === "settings" || (!text && !files.length && !shares.length))) {
-            return this.panel.open(here, channel, threadTs);
-        }
         // Downloading only past the gate: an unauthorized sender must not make the
         // bot pull bytes on their behalf.
         const markers = await this.saveAttachments(files);
         const shared = await Promise.all(shares.map((share) => this.sharedBlock(share)));
+        // A bare `@bot` and `settings` are the same request; `s <text>` drafts a
+        // session, so only where this message would start one: a thread root. The
+        // held question carries its markers, so Start sends what the user sent.
+        const question = threadTs === ts ? settingsDraft(text) : undefined;
+        if (this.panel && (question || command?.name === "settings" || (!text && !files.length && !shares.length))) {
+            return this.panel.open(here, channel, threadTs, question && [question, ...shared, ...markers].join("\n"));
+        }
         // Resolved before the mark: any await between mark() and dispatch is a
         // window in which a previous turn can settle and take this receipt with it.
         const sender = { id: event.user, name: await this.directory.user(this.api, event.user) };
@@ -272,7 +276,9 @@ export class SlackChannel {
         });
         if (!admitted)
             return;
-        if (await this.panel?.onAction(interaction, key, actionId))
+        // Start's question: the card is the message the click was on, so it carries the 👀.
+        const run = (text) => this.deliver(key, channel, message.ts, user, text, onMessage);
+        if (await this.panel?.onAction(interaction, key, actionId, run))
             return;
         const text = offeredLabel(message.blocks, actionId);
         if (text === undefined) {
@@ -285,7 +291,6 @@ export class SlackChannel {
         await this.retireOptions(channel, message.ts, message.blocks);
         // A bot cannot post as the user, so the pick is echoed: otherwise the
         // thread shows an answer to a request nobody can see, with nothing to carry the eyes.
-        const sender = { id: user, name: await this.directory.user(this.api, user) };
         const echo = await this.api.postMessage({
             channel,
             thread_ts: threadTs,
@@ -294,9 +299,14 @@ export class SlackChannel {
             this.log(`option echo failed: ${String(err)}`);
             return undefined;
         });
+        await this.deliver(key, channel, echo?.ts, user, text, onMessage);
+    }
+    /** A click's text as the clicker's message; `ts` is the message that carries the 👀. */
+    async deliver(key, channel, ts, user, text, onMessage) {
+        const sender = { id: user, name: await this.directory.user(this.api, user) };
         // No await between mark and dispatch — see onMessage.
-        if (echo?.ts)
-            this.receipts.mark(key.conversationId, channel, echo.ts);
+        if (ts)
+            this.receipts.mark(key.conversationId, channel, ts);
         onMessage({ key, senderId: user, sender, text, mode: "steer" });
     }
     /** Slack will not accept a message with neither text nor blocks, so a turn
@@ -354,10 +364,8 @@ export class SlackChannel {
         }
         return name ?? channel;
     }
-    /** The eager thread read runs whether or not `agentTool` is on: a human
-     *  handing the agent a message is the same act as an upload, which nothing
-     *  gates. `agentTool` only changes the hint, which must not name a tool this
-     *  session does not have. */
+    /** The eager thread read is not gated: a human handing the agent a message
+     *  is the same act as an upload. */
     async sharedBlock(share) {
         const source = share.original_message;
         const ts = share.ts ?? source?.ts;
@@ -386,23 +394,19 @@ export class SlackChannel {
         const thread = parent && parent.replies <= INLINE_REPLY_MAX
             ? await this.sharedThread(parent.channel, parent.ts, parent.replies)
             : { transcript: false, lines: [] };
-        // The coordinates carry the tool's own parameter names; naming the tool is
-        // a lie when the Console has switched agent access off.
-        const how = slackToolAvailable(this.deps.store) ? "read with the slack tool: " : "";
+        // The coordinates in `pier slack`'s own words (skills/pier-slack).
         const hint = parent && !thread.transcript
-            ? `[thread: ${parent.replies} replies — ${how}channel ${parent.channel}, thread_ts ${parent.ts}]`
+            ? `[thread: ${parent.replies} replies — channel ${parent.channel}, thread_ts ${parent.ts}]`
             : "";
         // The transcript opens with the shared message itself.
         return [`[${head}]`, thread.transcript ? "" : body, ...thread.lines, hint]
             .filter(Boolean).join("\n");
     }
-    /** Through the slack tool's own read, so paging and dedup exist once. A read
-     *  that fails or comes back cut says so in the prompt (§5). */
+    /** A read that fails or comes back cut says so in the prompt (§5). */
     async sharedThread(channel, ts, replies) {
-        const deps = { directory: this.directory, log: this.log };
         try {
             // One over the budget, so an undercounting reply_count still reports as cut.
-            const read = await readThread(deps, this.api, channel, ts, undefined, INLINE_REPLY_MAX + 2);
+            const read = await readThread(this.directory, this.api, channel, ts, INLINE_REPLY_MAX + 2);
             if (!read.messages.length)
                 return { transcript: false, lines: [] };
             return {
@@ -410,9 +414,7 @@ export class SlackChannel {
                 lines: [
                     `[thread: ${replies} replies, oldest first — ${read.format}]`,
                     ...read.messages,
-                    ...(read.incomplete || read.truncated
-                        ? [`[thread partly read: ${read.incomplete ?? `cut at ${read.count} lines`}]`]
-                        : []),
+                    ...(read.truncated ? [`[thread partly read: cut at ${read.count} lines]`] : []),
                 ],
             };
         }
@@ -447,6 +449,11 @@ export class SlackChannel {
         // The turn ended either way; a 👀 left up by a failed send looks like work.
         await this.receipts.settleAfter(conversation, () => this.out.reply(channel, threadTs, reply), reply.meta);
     }
+    /** A web session's thread: the root is the one message Pier posts into a
+     *  channel's main flow (channels/handoff.ts). */
+    async openThread(chatId, note) {
+        return conversationId(chatId, await this.out.open(chatId, note));
+    }
     /** The 👀 goes on the note itself: the turn it triggers has no message of
      *  the user's to carry them. */
     async notify(conversation, note) {
@@ -457,6 +464,6 @@ export class SlackChannel {
         }
         const ts = await this.out.note(channel, threadTs, note);
         if (ts && awaitsTurn(note.origin))
-            this.receipts.mark(conversation, channel, ts);
+            this.receipts.mark(conversation, channel, ts, note.at);
     }
 }

package/dist/channels/types.js

@@ -2,7 +2,7 @@
 // adapters and the Console view (type-only, so no node builtins here). Defaults
 // are least-privilege, and platform values are seeds copied into a chat on
 // discovery, not a runtime fallback: a switch means what it says.
-const PLATFORMS = ["telegram", "slack", "lark"];
+const PLATFORMS = ["slack", "lark"];
 /** Validate at the boundary: an unknown platform is a 404, not a new row. */
 export const isChannelPlatform = (v) => typeof v === "string" && PLATFORMS.includes(v);
 /** Every adapter spells its ids `<chatId>` or `<chatId>/<thread>`, so the chat
@@ -12,10 +12,8 @@ export const defaultChannelConfig = () => ({
     enabled: false,
     token: "",
     appToken: "",
-    agentTool: true,
     requireMention: true,
     requireBind: true,
-    topicMode: true,
     cwd: "",
     model: null,
     thinking: null,