@timqi/pier 0.1.4 → 0.1.5

package/dist/channels/routes.js

@@ -1,5 +1,7 @@
-// Settings → Channels HTTP surface: one document per platform.
+// Settings → Channels HTTP surface: one document per platform, and the
+// web → IM handoff beside it.
 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)}` : "";
@@ -35,14 +37,13 @@ function parseChats(raw, known) {
             enabled: asBool(edit.enabled),
             requireMention: asBool(edit.requireMention),
             requireBind: asBool(edit.requireBind),
-            topicMode: asBool(edit.topicMode),
             cwd: asString(edit.cwd),
             model: asModel(edit.model),
             thinking: asThinking(edit.thinking),
         };
     });
 }
-export function registerChannelRoutes(app, store, runtime) {
+export function registerChannelRoutes(app, store, runtime, handoff) {
     app.get("/api/channels/:platform", (c) => {
         const platform = c.req.param("platform");
         if (!isChannelPlatform(platform))
@@ -72,7 +73,6 @@ export function registerChannelRoutes(app, store, runtime) {
             appToken: kept(asString(body.appToken), current.appToken),
             requireMention: asBool(body.requireMention),
             requireBind: asBool(body.requireBind),
-            topicMode: asBool(body.topicMode),
             cwd: asString(body.cwd),
             model: asModel(body.model),
             thinking: asThinking(body.thinking),
@@ -97,4 +97,21 @@ export function registerChannelRoutes(app, store, runtime) {
         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;
+        }
+    });
 }

package/dist/channels/runtime.js

@@ -3,12 +3,10 @@
 import { logger } from "../log.js";
 import { LarkChannel } from "./lark.js";
 import { SlackChannel } from "./slack.js";
-import { TelegramChannel } from "./telegram.js";
 const ADAPTERS = [
-    { platform: "telegram", needsAppToken: false, build: (deps) => new TelegramChannel(deps) },
-    { platform: "slack", needsAppToken: true, build: (deps) => new SlackChannel(deps) },
+    { platform: "slack", build: (deps) => new SlackChannel(deps) },
     // Lark's "token" is the App ID and "appToken" the App Secret.
-    { platform: "lark", needsAppToken: true, build: (deps) => new LarkChannel(deps) },
+    { platform: "lark", build: (deps) => new LarkChannel(deps) },
 ];
 // The injected sink is for warnings; "slack started" is not one.
 const log = logger("channels");
@@ -18,14 +16,18 @@ export class ChannelRuntime {
     store;
     router;
     control;
+    handoff;
     log;
     live = new Map();
     reloading = Promise.resolve();
     stopped = false;
-    constructor(store, router, control, log = warn) {
+    constructor(store, router, control, 
+    /** The pull half only; the push half needs this runtime, so main.ts closes the loop. */
+    handoff, log = warn) {
         this.store = store;
         this.router = router;
         this.control = control;
+        this.handoff = handoff;
         this.log = log;
     }
     /** Serialized: two concurrent Console saves would race into duplicate live
@@ -45,7 +47,7 @@ export class ChannelRuntime {
         return run;
     }
     async restart(adapter) {
-        const { platform, needsAppToken, build } = adapter;
+        const { platform, build } = adapter;
         const existing = this.live.get(platform);
         if (existing) {
             this.live.delete(platform);
@@ -55,7 +57,7 @@ export class ChannelRuntime {
         const config = this.store.get(platform);
         if (!config.enabled || !config.token)
             return;
-        if (needsAppToken && !config.appToken) {
+        if (!config.appToken) {
             // "Enabled but nothing happens" is indistinguishable from a broken adapter.
             this.log(`${platform}: enabled but no app token, not starting`);
             return;
@@ -64,6 +66,7 @@ export class ChannelRuntime {
             store: this.store,
             log: (m) => this.log(`${platform}: ${m}`),
             control: this.control,
+            handoff: this.handoff,
         });
         try {
             await channel.start((msg) => {
@@ -87,6 +90,17 @@ export class ChannelRuntime {
         await channel.notify(conversationId, { text, origin: { kind: "error" } });
         return true;
     }
+    running() {
+        return [...this.live.keys()];
+    }
+    /** Throws by name when the platform is not running: the caller's answer is
+     *  "enable it in Settings", not a silent no-op. */
+    async openThread(platform, chatId, note) {
+        const channel = this.live.get(platform);
+        if (!channel)
+            throw new Error(`${platform} is not running`);
+        return channel.openThread(chatId, note);
+    }
     async stop() {
         // An in-flight restart could otherwise register an adapter after `live`
         // was cleared — running, unstoppable.

package/dist/channels/slack-outbound.js

@@ -50,6 +50,16 @@ export class SlackOutbound {
         }
         return ts;
     }
+    /** The one root Pier posts (no `thread_ts`): the thread a web session is
+     *  continued in has no user message to hang from. Answers the root's `ts`. */
+    async open(channel, note) {
+        const link = note.url || "_(no public URL set — Settings → Instance)_";
+        const sent = await this.api.postMessage({
+            channel,
+            text: `Continued from web: *${escapeMrkdwn(note.title)}*\n${link}\n_Reply in this thread to continue._`,
+        });
+        return sent.ts;
+    }
     budget() {
         return this.markdownBlocks ? MARKDOWN_MAX : MRKDWN_MAX;
     }

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.js

@@ -10,7 +10,7 @@ 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";
@@ -24,7 +24,8 @@ 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;
@@ -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
@@ -439,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) {
@@ -449,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
@@ -14,7 +14,6 @@ export const defaultChannelConfig = () => ({
     appToken: "",
     requireMention: true,
     requireBind: true,
-    topicMode: true,
     cwd: "",
     model: null,
     thinking: null,

package/dist/cli.js

@@ -27,6 +27,7 @@ Usage
                               run a command with named secrets in its env
   pier slack <subcommand> ... Slack from a shell, token from the vault (pier slack --help)
   pier task <command> ...     subagents and scheduled tasks from a shell (pier task --help)
+  pier web search|fetch ...   the public web through the provider's hosted tools (pier web --help)
   pier --version | --help
 
 Options for "service install"
@@ -42,6 +43,9 @@ const say = (message) => void process.stdout.write(`${message}\n`);
 /** Every socket route answers from memory and the database, so a Pier that
  *  takes longer than this is stuck, and an agent's shell must not hang with it. */
 const SOCKET_TIMEOUT_MS = 30_000;
+/** `/web` is the one route that waits on a provider: its own 90 s ceiling
+ *  (`websearch/run.ts`) answers first, so this only catches a stuck Pier. */
+const WEB_TIMEOUT_MS = 120_000;
 /** Typed on the binding: only then does a call narrow the code after it. */
 const die = (message) => {
     process.stderr.write(`${message}\n`);
@@ -52,8 +56,8 @@ const argv = process.argv.slice(2);
 const parsed = (() => {
     try {
         return parseArgs({
-            // `slack` and `task` own their options; only the name is parsed here.
-            args: argv[0] === "slack" || argv[0] === "task" ? [argv[0]] : argv,
+            // `slack`, `task` and `web` own their options; only the name is parsed here.
+            args: argv[0] === "slack" || argv[0] === "task" || argv[0] === "web" ? [argv[0]] : argv,
             allowPositionals: true,
             strict: true,
             options: {
@@ -125,6 +129,10 @@ else if (command === "task") {
     const { runTaskCli } = await import("./tasks/cli.js");
     process.exitCode = await runTaskCli(argv.slice(1), (params) => askPier("/task", { params }));
 }
+else if (command === "web") {
+    const { runWebCli } = await import("./websearch/cli.js");
+    process.exitCode = await runWebCli(argv.slice(1), (params) => askPier("/web", { params }, WEB_TIMEOUT_MS));
+}
 else if (command === "restart" || command === "reload") {
     if (subcommand)
         fail(`unexpected argument "${subcommand}"`);
@@ -277,11 +285,11 @@ function inject(wanted, values, cmd) {
  *  session (`PIER_SESSION_ID`, the harness variable mapped by the shim). Not
  *  running, silent, unreadable, or an identity or body Pier refuses, is one
  *  `pier:` line and exit 2 before any route reads the answer. */
-async function askPier(path, body) {
+async function askPier(path, body, timeout = SOCKET_TIMEOUT_MS) {
     const { PIER_SOCK } = await import("./paths.js");
     const answer = await new Promise((done, reject) => {
         let responded = false;
-        const req = request({ socketPath: PIER_SOCK, method: "POST", path, headers: { "content-type": "application/json" }, timeout: SOCKET_TIMEOUT_MS }, (res) => {
+        const req = request({ socketPath: PIER_SOCK, method: "POST", path, headers: { "content-type": "application/json" }, timeout }, (res) => {
             responded = true;
             let raw = "";
             const unreadable = () => reject(new Error(`unreadable answer from ${PIER_SOCK} (status ${String(res.statusCode ?? 0)})`));
@@ -297,7 +305,7 @@ async function askPier(path, body) {
                 }
             });
         });
-        req.on("timeout", () => req.destroy(new Error(`Pier did not answer within ${String(SOCKET_TIMEOUT_MS / 1000)} s`)));
+        req.on("timeout", () => req.destroy(new Error(`Pier did not answer within ${String(timeout / 1000)} s`)));
         // A 413 arrives while the body is still being written; the EPIPE after it is not the news.
         req.on("error", (err) => responded || reject(err));
         req.end(JSON.stringify({ ...body, sessionId: process.env.PIER_SESSION_ID }));

package/dist/core/identity.js

@@ -26,8 +26,9 @@ export class SenderPrefix {
     seen = new Map();
     /** The line to put above this message, or `""` when the session already
      *  knows. `conversation` is the chat's `<channelId>:<conversationId>`, told
-     *  once: a session never moves, but the rule stays the same as the rest. */
-    next(sessionId, sender, at = Date.now(), conversation) {
+     *  once: a session never moves, but the rule stays the same as the rest.
+     *  `opaqueIds` is the platform's (`core/types.ts`): its ids buy nothing. */
+    next(sessionId, sender, at = Date.now(), conversation, opaqueIds = false) {
         if (!sender?.id)
             return "";
         const last = this.seen.get(sessionId);
@@ -43,9 +44,14 @@ export class SenderPrefix {
         // is the id, and `U123<U123>` would read as a broken record.
         const id = sanitizeIdentity(sender.id);
         const label = sanitizeIdentity(sender.name);
-        const who = newSpeaker ? (label === id ? `<${id}>` : `${label}<${id}>`) : "";
-        const when = gap || newDay ? `${newDay ? `${day(now)} ` : ""}${hhmm(now)}` : "";
-        const where = newPlace ? sanitizePlace(conversation) : "";
+        const named = opaqueIds ? label : label === id ? `<${id}>` : `${label}<${id}>`;
+        const who = newSpeaker ? named : "";
+        // A bare name has no `<>` to be told apart by, so it is only unambiguous
+        // next to the time: with opaque ids the clock is written whenever it is.
+        const clock = gap || newDay || (opaqueIds && !!who);
+        const when = clock ? `${newDay ? `${day(now)} ` : ""}${hhmm(now)}` : "";
+        const place = opaqueIds ? conversation?.split(":")[0] : conversation;
+        const where = newPlace && place ? sanitizePlace(place) : "";
         return `[${[who, when, where].filter(Boolean).join(" ")}]`;
     }
     forget(sessionId) {
@@ -55,18 +61,26 @@ export class SenderPrefix {
 export const withPrefix = (prefix, text) => prefix ? `${prefix}\n${text}` : text;
 // Only the shapes `next()` emits, newline included: a human typing
 // `[14:23] on my way` is body text and must come back untouched.
-const HEADER = /^\[(?:([^\n[\]<>]*)<([^\n[\]<>]+)>)? ?((?:\d{4}-\d{2}-\d{2} )?\d{1,2}:\d{2})? ?([a-z]+:[^\s[\]<>]+)?\]\n/;
+const TIME = String.raw `(?<when>(?:\d{4}-\d{2}-\d{2} )?\d{1,2}:\d{2})`;
+const WITH_ID = new RegExp(String.raw `^\[(?:(?<name>[^\n[\]<>]*)<(?<id>[^\n[\]<>]+)>)? ?${TIME}? ?(?<where>[a-z]+:[^\s[\]<>]+)?\]\n`);
+/** The opaque-ids shape: a name with no `<>`, told apart from body text by the
+ *  time that always follows it, and a platform with no conversation after it.
+ *  A line of its own reading `[meeting 14:23]` is the price. */
+const NAMED = new RegExp(String.raw `^\[(?<name>[^\n[\]<>]*?) ${TIME}(?: (?<where>[a-z]+))?\]\n`);
 /** Read back a header this module wrote: the prefix is for the model, and a
  *  surface showing a stored message renders the speaker its own way. */
 export function splitSpeaker(text) {
-    const m = HEADER.exec(text);
-    if (!m?.[2] && !m?.[3] && !m?.[4])
+    const head = WITH_ID.exec(text);
+    const { id, when, where } = head?.groups ?? {};
+    // A name on its own proves nothing: try the shape that requires a time.
+    const m = id || when || where ? head : NAMED.exec(text);
+    if (!m?.groups)
         return { text };
     return {
-        ...(m[1] ? { name: m[1] } : {}),
-        ...(m[2] ? { id: m[2] } : {}),
-        ...(m[3] ? { when: m[3] } : {}),
-        ...(m[4] ? { where: m[4] } : {}),
+        ...(m.groups.name ? { name: m.groups.name } : {}),
+        ...(m.groups.id ? { id: m.groups.id } : {}),
+        ...(m.groups.when ? { when: m.groups.when } : {}),
+        ...(m.groups.where ? { where: m.groups.where } : {}),
         text: text.slice(m[0].length),
     };
 }
@@ -94,3 +108,24 @@ export function readableTitle(title) {
         .trim();
     return said || title;
 }
+/** How a session is named where it is announced (a push, a handoff): its
+ *  readable title, else its directory. Never empty — a listing that could
+ *  not answer must not silence the message. One line: every caller puts it
+ *  inside emphasis or a button, where a newline breaks the markup. */
+export const sessionLabel = (s) => readableTitle(s?.title)?.replace(/\s+/g, " ").trim() || s?.cwd.split("/").filter(Boolean).at(-1) || "Pier session";
+/** Distinct directories, newest session first: the ground `projectCwds` picks
+ *  from. */
+export const distinctCwds = (list) => [...new Set([...list].sort((a, b) => b.createdAt - a.createdAt).map((s) => s.cwd))];
+/** The distinct directories less the worktrees: `wt` puts a checkout beside its
+ *  repository as `<repo>.<branch>`, and the next conversation about a project
+ *  belongs in the project. A worktree with no such sibling stays. What every
+ *  directory picker — web New-session menu, Settings scope, IM panel — offers. */
+export function projectCwds(list) {
+    const all = distinctCwds(list);
+    const known = new Set(all);
+    return all.filter((cwd) => {
+        const slash = cwd.lastIndexOf("/");
+        const dot = cwd.indexOf(".", slash + 2); // not a leading dot: `.pier` is a name
+        return dot < 0 || !known.has(cwd.slice(0, dot));
+    });
+}