@timqi/pier 0.1.14 → 0.3.0

package/dist/channels/lark.js

@@ -1,13 +1,16 @@
 // Lark (Feishu) adapter: normalize long-connection events, render outbound
-// turns as cards. As on Slack, Pier never posts into a chat's main flow: a
-// conversation is `<chatId>/<rootMessageId>` (`reply_in_thread`; DMs thread
-// too). Lark-specific: `content` is a double-encoded JSON string and a mention
+// turns as cards. As on Slack, Pier never posts into a chat's main flow but the
+// home chat's (docs/design/11-im-conversation.md), which is one conversation
+// keyed `<chatId>`: any other is `<chatId>/<rootMessageId>` (`reply_in_thread`;
+// DMs thread too). Lark-specific: `content` is a double-encoded JSON string and a mention
 // is a `@_user_N` placeholder resolved through `mentions[]`; 👀 is the reaction
 // key `OnIt`, removed by reaction_id; a card callback does not say which thread
 // its message lives in, so every button value carries the root; delivery is
 // at-least-once and acked when the handler returns, so handlers queue and return.
+import { isChatCommand } from "../core/types.js";
 import { saveInboundAll } from "../core/inbox.js";
 import { MAX_INBOUND_BYTES } from "../core/inbound-file.js";
+import { skillsText } from "../core/chain.js";
 import { awaitsTurn } from "../core/reply.js";
 import { bindHint, bindResult, picked, STALE_OPTION, STOPPED } from "./lines.js";
 import { logger } from "../log.js";
@@ -31,7 +34,7 @@ const DEDUP_TTL_MS = 5 * 60_000;
 const DEDUP_MAX = 2000;
 /** The only definition of the conversation id format; control.ts decodes with it. */
 const conversationId = (chatId, root) => `${chatId}/${root}`;
-export const parseConversation = (id) => {
+const parseConversation = (id) => {
     const at = id.indexOf("/");
     return at < 0
         ? { chatId: id, root: "" }
@@ -75,13 +78,8 @@ export class LarkChannel {
                 ? this.api.addReaction(messageId, emoji)
                 : this.api.removeReaction(messageId, WORKING),
         }, deps.receipts ?? new ReceiptLedger("lark"), this.log, WORKING, RECEIPT_STALE_MS, (conversationId) => deps.control?.working({ channelId: this.id, conversationId }) ?? false);
-        if (deps.control && deps.handoff) {
-            this.panel = new LarkPanel({
-                api: this.api,
-                control: deps.control,
-                handoff: deps.handoff,
-                log: this.log,
-            });
+        if (deps.control) {
+            this.panel = new LarkPanel({ api: this.api, control: deps.control, log: this.log });
         }
     }
     async start(onMessage) {
@@ -162,13 +160,16 @@ export class LarkChannel {
         const text = raw.trim();
         const command = parseCommand(text);
         const root = threadOf(msg);
-        const here = { channelId: this.id, conversationId: conversationId(msg.chatId, root) };
+        // The home chat is the head's, in a topic or not, under one key — except a
+        // child's topic (docs/design/11 §Child threads), which is that session's.
+        const home = this.isHead(msg.chatId, msg.rootId);
+        const here = { channelId: this.id, conversationId: home ? msg.chatId : conversationId(msg.chatId, root) };
         const bindRequest = command?.name === "bind" && isDm;
         const admitted = this.gate.admit("message", msg.chatId, {
             isDm,
             // Mentioned, or continuing a topic Pier already owns — durable, so it
             // holds after a restart.
-            addressed: mentioned || (!!msg.rootId && !!this.deps.control?.knows(here)),
+            addressed: mentioned || (!home && !!msg.rootId && !!this.deps.control?.knows(here)),
             userId: senderId,
             bindRequest,
         });
@@ -179,22 +180,29 @@ export class LarkChannel {
         }
         if (bindRequest)
             return this.bind(senderId, msg.messageId, command?.args ?? "");
-        if (command?.name === "stop")
+        // The head has no panel and takes `/stop` and `/skills` as chat commands (core/chain.ts).
+        if (!text && !attachments.length)
+            return this.log(`empty message in ${here.conversationId}, dropped`);
+        if (!home && command?.name === "stop")
             return this.abortTurn(here, msg.messageId);
+        if (!home && command?.name === "skills")
+            return this.listSkills(here);
         // Downloading only past the gate: an unauthorized sender must not make the
         // bot pull bytes on their behalf.
         const markers = await this.saveAttachments(msg.messageId, attachments);
-        // A bare `@bot` and `/settings` are the same request; `s <text>` drafts a
-        // session, so only where this message would start one: outside any topic.
-        // The held question carries its markers, so Start sends what the user sent.
+        // `/s <text>` drafts a session, so only where this message would start one:
+        // outside any topic. The held question carries its markers, so Start sends what the user sent.
         const question = msg.rootId ? undefined : settingsDraft(text);
-        if (this.panel && (question || command?.name === "settings" || (!text && !attachments.length && mentioned))) {
+        if (this.panel && !home && (question || command?.name === "settings")) {
             return this.panel.open(here, root, question && [question, ...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: senderId, name: await this.userName(senderId) };
-        this.receipts.mark(here.conversationId, msg.chatId, msg.messageId);
+        // The head answers a chat command with a note, not a turn: nothing would take a 👀 off it.
+        const answered = home && command && !command.args && isChatCommand(command.name);
+        if (!answered)
+            this.receipts.mark(here.conversationId, msg.chatId, msg.messageId);
         // Steer: a follow-up is the wrong default when the human is watching a 👀.
         onMessage({
             key: here,
@@ -301,14 +309,18 @@ export class LarkChannel {
             ? action.name.slice(CWD_SUBMIT_PREFIX.length)
             : "";
         const root = action.value?.root ?? formRoot;
-        if (!root) {
+        // Any tap in the home chat is the head's, echoed where the card was,
+        // unless a child's topic; anywhere else only a topic's card is Pier's.
+        const home = this.isHead(action.chatId, root);
+        if (!root && !(home && payload.startsWith(OFFER_PREFIX))) {
             this.log(`card action without a thread root in ${action.chatId}, dropped`);
             return;
         }
         const key = {
             channelId: this.id,
-            conversationId: conversationId(action.chatId, root),
+            conversationId: home ? action.chatId : conversationId(action.chatId, root),
         };
+        const to = root ? { root } : { chatId: action.chatId };
         const admitted = this.gate.admit("action", action.chatId, {
             isDm: this.deps.store.chat("lark", action.chatId)?.kind === "dm",
             addressed: true, // clicking the bot's own button is addressing it
@@ -316,11 +328,12 @@ export class LarkChannel {
         });
         if (!admitted)
             return;
-        if (formRoot && action.formValue) {
+        // The head has no panel: a card left in the chat before it became the home is stale.
+        if (!home && formRoot && action.formValue) {
             await this.panel?.onCwdSubmit(key, action, root);
             return;
         }
-        if (payload.startsWith(PANEL_PREFIX)) {
+        if (!home && payload.startsWith(PANEL_PREFIX)) {
             // Start's question: the card is the message the tap was on, so it carries the 👀.
             const run = (text) => this.deliver(key, action, action.messageId, text, onMessage);
             if (!(await this.panel?.onAction(action, key, payload, root, run))) {
@@ -336,14 +349,14 @@ export class LarkChannel {
             : undefined;
         if (label === undefined) {
             this.log(`unknown or stale action ${payload} in chat ${action.chatId}`);
-            await this.api.replyCard(root, card([markdown(STALE_OPTION)]))
+            await this.out.post(to, card([markdown(STALE_OPTION)]))
                 .catch((err) => this.log(`stale-option notice failed: ${String(err)}`));
             return;
         }
         // A bot cannot post as the user, so the pick is echoed: otherwise the
         // topic shows an answer to a request nobody can see, with nothing to carry the eyes.
         await this.out.retire(action.messageId);
-        const echo = await this.api.replyCard(root, card([markdown(picked(label))]))
+        const echo = await this.out.post(to, card([markdown(picked(label))]))
             .catch((err) => {
             this.log(`option echo failed: ${String(err)}`);
             return undefined;
@@ -363,6 +376,11 @@ export class LarkChannel {
         await this.deps.control?.abort(key);
         await this.api.replyCard(messageId, card([markdown(STOPPED)]));
     }
+    /** The head's `/skills` is MainChain's; a thread has no chain, so it is answered here. */
+    async listSkills(key) {
+        const text = skillsText((await this.deps.control?.skills(key)) ?? []);
+        await this.notify(key.conversationId, { text, origin: { kind: "chat-command", command: "skills" } });
+    }
     // --- bind ------------------------------------------------------------------
     /** Groups stay silent, but a DM that swallows every message looks broken
      *  rather than locked. */
@@ -378,6 +396,21 @@ export class LarkChannel {
         await this.api.replyCard(messageId, card([markdown(bindResult(outcome, name))]));
     }
     // --- lookups ---------------------------------------------------------------
+    isHome(chatId) {
+        return this.deps.control?.isHome({ channelId: this.id, conversationId: chatId }) ?? false;
+    }
+    /** The head's: the home chat, outside any topic a session of its own is bound to. */
+    isHead(chatId, root) {
+        return this.isHome(chatId) &&
+            !(root && this.deps.control?.knows({ channelId: this.id, conversationId: conversationId(chatId, root) }));
+    }
+    /** A topic, or the home chat's main flow; undefined for any other chat's. */
+    target(conversation) {
+        const { chatId, root } = parseConversation(conversation);
+        if (root)
+            return { root };
+        return this.isHome(chatId) ? { chatId } : undefined;
+    }
     async userName(openId) {
         const hit = this.names.get(openId);
         if (hit)
@@ -400,33 +433,42 @@ export class LarkChannel {
     }
     // --- outbound --------------------------------------------------------------
     async send(conversation, reply) {
-        const { root } = parseConversation(conversation);
-        // No root is a foreign id; posting it would put a turn in the chat's main
-        // flow. Refused loudly, receipts still cleared.
-        if (!root) {
+        const to = this.target(conversation);
+        // No root outside the home chat is a foreign id; posting it would put a
+        // turn in the chat's main flow. Refused loudly, receipts still cleared.
+        if (!to) {
             this.log(`refusing to answer ${conversation}: no thread root in the conversation id`);
             await this.receipts.settle(conversation);
             return;
         }
         // The turn ended either way; a 👀 left up by a failed send looks like work.
-        await this.receipts.settleAfter(conversation, () => this.out.reply(root, reply), reply.meta);
-    }
-    /** A web session's topic: the root is the one card Pier posts into a
-     *  chat's main flow (channels/handoff.ts). */
-    async openThread(chatId, note) {
-        return conversationId(chatId, await this.out.open(chatId, note));
+        await this.receipts.settleAfter(conversation, () => this.out.reply(to, reply), reply.meta);
     }
     /** The 👀 goes on the note itself: the turn it triggers has no message of
      *  the user's to carry them. */
     async notify(conversation, note) {
-        const { chatId, root } = parseConversation(conversation);
-        if (!root) {
+        const to = this.target(conversation);
+        if (!to) {
             this.log(`refusing to post a system note to ${conversation}: no thread root in the conversation id`);
             return;
         }
-        const messageId = await this.out.note(root, note);
+        const messageId = await this.out.note(to, note);
         if (messageId && awaitsTurn(note.origin)) {
-            this.receipts.mark(conversation, chatId, messageId, note.at);
+            this.receipts.mark(conversation, parseConversation(conversation).chatId, messageId, note.at);
         }
     }
+    async openThread(chatId, note) {
+        if (!this.isHome(chatId))
+            throw new Error(`refusing to open a topic in ${chatId}: not the home chat`);
+        const messageId = await this.out.note({ chatId }, note);
+        if (!messageId)
+            throw new Error(`Lark returned no message id for the root in ${chatId}`);
+        return conversationId(chatId, messageId);
+    }
+    async editRoot(conversation, note) {
+        const { root } = parseConversation(conversation);
+        if (!root)
+            throw new Error(`refusing to edit ${conversation}: no thread root in the conversation id`);
+        await this.out.edit(root, note);
+    }
 }

package/dist/channels/lines.js

@@ -1,5 +1,7 @@
 // What the shared control moments say — one spelling for both platforms. The
-// only legitimate variation is the spelling of the bind command, so it is the parameter.
+// only legitimate variations are platform spellings (the bind command, a label's
+// emphasis), so they are the parameters.
+import { originLabel } from "../core/reply.js";
 export const bindHint = (command) => `You are not bound yet. Ask the operator for a bind code, then send ${command}.`;
 /** The name arrives escaped by the caller. */
 export const bindResult = (outcome, name) => {
@@ -15,3 +17,33 @@ export const STOPPED = "\u23f9 Stopped.";
 export const picked = (label) => `\u25b8 ${label}`;
 /** Said in the chat: the person clicked and would otherwise see nothing happen (§5). */
 export const STALE_OPTION = "⚠ That option is no longer available — please type the choice instead.";
+/** What a chat window gets of a system input; a task callback carries up to
+ *  8000 characters of result text (tasks/callbacks.ts). */
+const NOTE_CHARS = 200;
+const NOTE_LINES = 4;
+function digest(text) {
+    const body = text.trimEnd();
+    let head = body.split("\n").slice(0, NOTE_LINES).join("\n");
+    if (head.length > NOTE_CHARS) {
+        const capped = head.slice(0, NOTE_CHARS);
+        // A boundary before the midpoint loses more than the ragged edge costs.
+        const boundary = Math.max(capped.lastIndexOf("\n"), capped.lastIndexOf(" "));
+        head = capped.slice(0, boundary > NOTE_CHARS / 2 ? boundary : NOTE_CHARS);
+    }
+    const rest = body.slice(head.length).trim();
+    if (!rest)
+        return body;
+    const dropped = rest.split("\n").length;
+    return `${head.trimEnd()}\n… +${String(dropped)} more line${dropped === 1 ? "" : "s"}`;
+}
+/** The origin label in the platform's `emphasis` over the quoted body. A system
+ *  input is context for the turn it precedes: pasted whole, a run result buries
+ *  a chat that cannot collapse it, so it is digested (the hub keeps it all). An
+ *  error is quoted whole, core already capped it; so is a chat command's
+ *  answer, bounded and the reason it was asked. */
+export function noteBody(note, emphasis) {
+    const whole = note.origin.kind === "error" || note.origin.kind === "chat-command";
+    const text = whole ? note.text : digest(note.text);
+    const body = text.split("\n").map((line) => `> ${line}`).join("\n");
+    return `${emphasis}${originLabel(note.origin)}${emphasis}\n${body}`;
+}

package/dist/channels/panel.js

@@ -4,54 +4,26 @@
 // 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 { compact, cut, 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 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"]);
+const DRAFT_ONLY = new Set(["cwd", "cwdtype"]);
 export const CWD_DRAFT_TAIL = "Start creates the session there.";
 export const CWD_PLACEHOLDER = "/path/to/project";
 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 segment; the numbered line above has the whole path. */
 const shortDir = (path) => path.split("/").filter(Boolean).at(-1) ?? 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));
@@ -64,9 +36,9 @@ const pager = (action, at, pages) => [
     ...(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))
+/** A refusal's sentence (a control refusal) is the whole answer; any other
+ *  failure names what was attempted. */
+const failed = (what, err) => 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. */
@@ -124,8 +96,7 @@ export class ChatPanel {
         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.
+        // The conversation is right above the card; a second session is a new thread.
         return {
             groups: [{ title: "Session", lines: this.sessionLines(status) }],
             rows: [[
@@ -148,7 +119,7 @@ export class ChatPanel {
                     ],
                 }],
             rows: [
-                [btn("Model & reasoning", "pins:0"), btn("Directory…", "cwd"), btn("Continue web session…", "sessions:0")],
+                [btn("Model & reasoning", "pins:0"), btn("Directory…", "cwd")],
                 [btn("Start", "start"), btn("Close", "close")],
             ],
         };
@@ -163,8 +134,8 @@ export class ChatPanel {
         };
     }
     sessionLines(status) {
-        const usage = status.tokens !== null && status.contextWindow
-            ? `${compact(status.tokens)}/${compact(status.contextWindow)} tok`
+        const usage = status.tokens !== null && status.compactAt
+            ? `${compact(status.tokens)}/${compact(status.compactAt)} tok`
             : "not measured yet";
         const fresh = status.empty && status.state === "idle";
         return [
@@ -186,21 +157,6 @@ export class ChatPanel {
             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)
@@ -209,17 +165,12 @@ export class ChatPanel {
     }
     /** 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) {
+     *  and the card stays as a record; another `/settings` opens a fresh one. */
+    async settle(key, state, note) {
         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);
+        await this.draw(state, { groups: [{ title: "Session", lines: this.sessionLines(status) }], rows: [] }, note);
         this.panels.delete(key.conversationId);
     }
     // --- actions -----------------------------------------------------------------
@@ -254,12 +205,6 @@ export class ChatPanel {
             case "pin":
                 await this.pickPin(key, Number(arg));
                 return true;
-            case "sessions":
-                await this.showSessions(key, Number(arg) || 0);
-                return true;
-            case "session":
-                await this.pickSession(key, Number(arg));
-                return true;
             case "cwd":
                 if (arg)
                     await this.pickDir(key, Number(arg));
@@ -274,7 +219,7 @@ export class ChatPanel {
                 return true;
             case "stop":
                 await this.deps.control.abort(key);
-                await this.settle(key, state, "Stop requested.", false);
+                await this.settle(key, state, "Stop requested.");
                 return true;
             default:
                 this.deps.log(`unknown panel action: ${action}`);
@@ -299,7 +244,7 @@ export class ChatPanel {
                         ? 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)}` : ""}`;
+                            return `${String(from + i + 1)}. ${ticked ? "✓ " : ""}${this.esc(pin.id)} · ${thinkingLabel(pin.thinking)}`;
                         })
                         : ["No pinned models — Settings → Models → Model menu."],
                 }],
@@ -308,41 +253,6 @@ export class ChatPanel {
             rows: [pager("pins", at, pages)],
         });
     }
-    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(shortDir(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];
@@ -356,7 +266,7 @@ export class ChatPanel {
         try {
             await this.deps.control.setModel(key, model);
             await this.deps.control.setThinking(key, pin.thinking);
-            await this.settle(key, state, `Model set to ${pin.id} · ${thinkingLabel(pin.thinking)}.`, false);
+            await this.settle(key, state, `Model set to ${pin.id} · ${thinkingLabel(pin.thinking)}.`);
         }
         catch (err) {
             await this.refresh(key, failed("Could not set that model", err));
@@ -415,9 +325,9 @@ export class ChatPanel {
         state.draft = {};
         if (q) {
             await run(q);
-            return this.settle(key, state, `Started ${id.slice(0, 8)} — running your question.`, false);
+            return this.settle(key, state, `Started ${id.slice(0, 8)} — running your question.`);
         }
         const cwd = (await this.deps.control.status(key))?.cwd ?? launch.cwd ?? "?";
-        await this.settle(key, state, `Started ${id.slice(0, 8)} in ${cwd}.`, false);
+        await this.settle(key, state, `Started ${id.slice(0, 8)} in ${cwd}.`);
     }
 }

package/dist/channels/routes.js

@@ -1,7 +1,5 @@
-// Settings → Channels HTTP surface: one document per platform, and the
-// web → IM handoff beside it.
+// Settings → Channels HTTP surface: one document per platform.
 import { isThinkingLevel } from "../core/types.js";
-import { HandoffError } from "./handoff.js";
 import { defaultChannelConfig, isChannelPlatform, } from "./types.js";
 /** Stable mask: recomputable at write time, so "unchanged" is detectable. */
 const maskToken = (token) => token ? `${"•".repeat(8)}${token.slice(-4)}` : "";
@@ -34,6 +32,7 @@ function parseChats(raw, known) {
             return base;
         return {
             ...base,
+            home: edit.home === true && base.kind === "dm" ? true : undefined,
             enabled: asBool(edit.enabled),
             requireMention: asBool(edit.requireMention),
             requireBind: asBool(edit.requireBind),
@@ -43,7 +42,7 @@ function parseChats(raw, known) {
         };
     });
 }
-export function registerChannelRoutes(app, store, runtime, handoff, conversations) {
+export function registerChannelRoutes(app, store, runtime, conversations) {
     app.get("/api/channels/:platform", (c) => {
         const platform = c.req.param("platform");
         if (!isChannelPlatform(platform))
@@ -83,7 +82,15 @@ export function registerChannelRoutes(app, store, runtime, handoff, conversation
             // next start read as the first one and skip the swapped bot's cleanup.
             botId: current.botId,
         };
+        const before = store.home();
         store.save(platform, next);
+        const home = next.chats.find((chat) => chat.home);
+        if (home) {
+            store.setHome(platform, home.id);
+            // A thread session opened here before is unreachable once the chat is the head's.
+            if (before?.platform !== platform || before.chatId !== home.id)
+                conversations.forgetChat(platform, home.id);
+        }
         await runtime.reload();
         return c.json({ ok: true });
     });
@@ -112,21 +119,4 @@ export function registerChannelRoutes(app, store, runtime, handoff, conversation
         store.unbind(platform, c.req.param("id"));
         return c.json({ ok: true });
     });
-    app.get("/api/handoff/targets", (c) => c.json({ targets: handoff.targets() }));
-    app.post("/api/handoff", async (c) => {
-        const body = (await c.req.json().catch(() => null));
-        const sessionId = asString(body?.sessionId);
-        const chatId = asString(body?.chatId);
-        const platform = body?.platform;
-        if (!sessionId || !chatId || !isChannelPlatform(platform))
-            return c.json({ error: "invalid body" }, 400);
-        try {
-            return c.json(await handoff.continueIn({ sessionId, platform, chatId }), 201);
-        }
-        catch (err) {
-            if (err instanceof HandoffError)
-                return c.json({ error: err.message }, err.status);
-            throw err;
-        }
-    });
 }