@timqi/pier 0.2.0 → 0.3.1

package/dist/agent/listing.js

@@ -80,16 +80,15 @@ function fold(acc, line, clean) {
 }
 /** A picker, not a results page. */
 const SEARCH_LIMIT = 8;
-/** A trigram token is one character, so `snippet()` is asked for its ceiling
- *  of 64 tokens; the default 12 fits one word. */
+/** Characters of context a snippet keeps around its first match. */
 const SNIPPET_CHARS = 64;
 /** Whitespace splits a query: a space is "and this too", not a character to
  *  find. A term is quoted where it has to be, so a phrase is still findable. */
 const termsOf = (query) => query.split(/\s+/).filter(Boolean);
-/** Delimited like `snippet()` (\u0001 … \u0002, `…` for a cut), so a surface
- *  draws one shape for both paths. Every term is marked where it first
- *  appears inside the window, as `snippet()` marks every phrase it kept.
- *  ASCII case folding: LIKE found the row by the same rule. */
+/** Cut here rather than by FTS `snippet()`, which can only cut the indexed
+ *  text, markup and all. Each match delimited \u0001 … \u0002, `…` for a cut;
+ *  every term is marked where it first appears inside the window. A match only
+ *  inside stripped markup leaves the message's opening. */
 function around(text, terms) {
     const lower = text.toLowerCase();
     const found = terms
@@ -98,7 +97,7 @@ function around(text, terms) {
         .sort((a, b) => a.at - b.at);
     const first = found[0];
     if (!first)
-        return text.slice(0, SNIPPET_CHARS);
+        return text.length > SNIPPET_CHARS ? `${text.slice(0, SNIPPET_CHARS)}…` : text;
     const start = Math.max(0, first.at - SNIPPET_CHARS / 2);
     const end = Math.min(text.length, first.at + first.length + SNIPPET_CHARS / 2);
     let out = start ? "…" : "";
@@ -115,14 +114,19 @@ function around(text, terms) {
 export class IndexedListing {
     dir;
     clean;
+    plain;
     #db;
     #statements;
     constructor(dir = join(defaultAgentDir(), "sessions"), db, 
     /** Handed in rather than imported: the header rule is core's, and agent/
      *  does not import core at runtime. */
-    clean = (text) => text) {
+    clean = (text) => text, 
+    /** Chat markup off what was said, before a snippet is cut (core/reply.ts):
+     *  applied at search time, so rows indexed before it are covered too. */
+    plain = (text) => text) {
         this.dir = dir;
         this.clean = clean;
+        this.plain = plain;
         this.#db = db;
     }
     /** Opened on the first scan: building a factory must not open the database. */
@@ -231,7 +235,7 @@ export class IndexedListing {
             return [];
         const rows = terms.every((term) => [...term].length >= 3)
             // Quoted: a term is a string to find, never FTS syntax.
-            ? sql(`SELECT session_id, role, at, snippet(session_fts, 0, char(1), char(2), '…', ${SNIPPET_CHARS}) AS snippet
+            ? sql(`SELECT session_id, role, at, text
          FROM session_fts WHERE text MATCH ? ORDER BY bm25(session_fts), at DESC`).iterate(terms.map((term) => `"${term.replaceAll('"', '""')}"`).join(" AND "))
             : sql(`SELECT session_id, role, at, text FROM session_fts WHERE ${terms.map(() => "text LIKE ? ESCAPE '\\'").join(" AND ")} ORDER BY at DESC`).iterate(...terms.map((term) => `%${term.replaceAll(/[\\%_]/g, "\\$&")}%`));
         const hits = [];
@@ -245,7 +249,7 @@ export class IndexedListing {
                 sessionId: row.session_id,
                 role: row.role,
                 at: row.at,
-                snippet: row.snippet ?? around(row.text ?? "", terms),
+                snippet: around(this.plain(row.text), terms),
             });
             if (hits.length >= limit)
                 break;

package/dist/agent/pi.js

@@ -757,8 +757,8 @@ export class PiAgentFactory {
         return (await this.listed()).map(summaryOf);
     }
     /** After a listing, so a transcript that grew is indexed before it is asked about. */
-    async search(query) {
+    async search(query, limit) {
         await this.listed();
-        return this.listings.search?.(query) ?? [];
+        return this.listings.search?.(query, limit) ?? [];
     }
 }

package/dist/agent/roles.js

@@ -18,10 +18,11 @@ The user talks to Pier as one conversation; you are its current session, in the
 
 ## Memory
 - \`MEMORY.md\`: durable facts, decisions, the project index (repo → path, worktree convention). \`memory/YYYY-MM-DD.md\`: daily notes, local date.
-- MEMORY.md is re-read in full at every session open: a list of facts, one line each. Rationale, narrative and working notes go in the daily note. Never record what this contract, AGENTS.md or a skill already says.
+- MEMORY.md is re-read in full at every session open: a list of facts, one line each. Never record what this contract, AGENTS.md or a skill already says.
 - Edit MEMORY.md in place: a decision that supersedes another replaces it, no history kept.
-- A callback is the ledger's and the transcript's record already: it writes no note. A note records a decision, or a fact the ledger does not hold. Repo knowledge belongs in that repo's own AGENTS.md, written by a child.
-- Recall is files plus transcripts: \`rg\` over \`memory/\` and the Pi session directory.
+- A daily-note line holds only a decision (what + one clause why) or a fact git, the ledger and transcripts do not hold: a live-verified result, a user preference, a flaky test, a manual step the user owes. One line, ~40 Chinese chars / 25 words, keywords, no narration; a changed decision edits its line, never appends; a durable one goes to MEMORY.md, not the note.
+- Never noted: dispatches, run ids, merges, commit hashes, test counts, restarts — git log, \`pier task runs\` and transcripts hold them; read them on demand. Repo knowledge belongs in that repo's own AGENTS.md, written by a child.
+- Recall is files plus transcripts: \`rg\` over \`memory/\`, \`pier search <words>\` over the earlier sessions (skills/pier-search).
 - A new session of this conversation opens with a seed: MEMORY.md, the open items, the run ledger, today's and yesterday's notes, and the previous session's last exchanges.
 
 ## Open items
@@ -44,7 +45,7 @@ You own one feature, in this worktree. The design doc you keep here is the state
 - Decompose it into worker runs: \`pier task run --name "<a few words>" --prompt … --cwd <worker worktree>\`, one \`wt\` worktree each (\`wt switch -c <branch> --no-cd -y --format json\` in the repo). The prompt is the worker's whole handoff; a worker never delegates.
 - Workers run on \`--model balanced\` for code, \`--model cheap\` for research and mechanical work.
 - Never launch another lead (\`--role lead\` is refused).
-- Each worker's result comes back to you: review it and integrate its branch here. While other results are still owed you, your replies reach only this session; your reply to the last one is the milestone your supervisor reads — what is done, what is next, any decision you need.
+- Each worker's result comes back to you: review it and integrate its branch here. While other results are still owed you, your replies reach only this session; your reply to the last one is the milestone your supervisor reads, in the run result's two parts: the conclusion (done, next, risks one line each), then \`Needs your decision\` only when something does. A worker takes reversible choices itself and names them in its result; it stops only on a destructive step or a question only you or the user can answer — answer with \`--run <id> --prompt\`, or carry it up.
 - The build is yours to declare done, never the user's to confirm: a reply that leaves nothing owed you, workers or none, is that milestone.
 - \`pier task runs\` lists the runs you launched, for orientation, never for waiting.`;
 /** The surface contract handed to every agent Pier launches (main.ts); the

package/dist/channels/conversations.js

@@ -18,11 +18,11 @@ export class ConversationStore {
      *  one launched from the chat defaults, which a re-create reads again. */
     set(key, sessionId, launch) {
         this.db.prepare(`
-      INSERT INTO conversations(channel_id, conversation_id, session_id, updated_at, launch)
-      VALUES (?, ?, ?, ?, ?)
+      INSERT INTO conversations(channel_id, conversation_id, session_id, launch)
+      VALUES (?, ?, ?, ?)
       ON CONFLICT(channel_id, conversation_id) DO UPDATE SET
-        session_id = excluded.session_id, updated_at = excluded.updated_at, launch = excluded.launch
-    `).run(key.channelId, key.conversationId, sessionId, Date.now(), launch ? JSON.stringify(launch) : null);
+        session_id = excluded.session_id, launch = excluded.launch
+    `).run(key.channelId, key.conversationId, sessionId, launch ? JSON.stringify(launch) : null);
     }
     launchOf(key) {
         const row = this.db.prepare(`

package/dist/channels/lark-outbound.js

@@ -68,6 +68,11 @@ export class LarkOutbound {
         const kept = withoutButtons(known);
         await this.api.patchCard(messageId, kept.body.elements.length ? kept : card([footer("Option taken.")])).catch((err) => this.log(`retiring options failed: ${String(err)}`));
     }
+    /** A note's root rewritten in place (a child thread's state); one card, so
+     *  the body is cut to the budget rather than split. */
+    async edit(messageId, note) {
+        await this.api.patchCard(messageId, card([markdown(chunk(noteBody(note, "*"), LARK_MAX)[0] ?? "")]));
+    }
     remember(messageId, sent) {
         this.sent.set(messageId, sent);
         while (this.sent.size > SENT_CACHE) {

package/dist/channels/lark.js

@@ -160,8 +160,9 @@ export class LarkChannel {
         const text = raw.trim();
         const command = parseCommand(text);
         const root = threadOf(msg);
-        // Every message in the home chat, in a topic or not, is the head's, under one key.
-        const home = this.isHome(msg.chatId);
+        // 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, {
@@ -308,9 +309,9 @@ export class LarkChannel {
             ? action.name.slice(CWD_SUBMIT_PREFIX.length)
             : "";
         const root = action.value?.root ?? formRoot;
-        // Any tap in the home chat is the head's, echoed where the card was;
-        // anywhere else only a topic's card is Pier's.
-        const home = this.isHome(action.chatId);
+        // 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;
@@ -398,6 +399,11 @@ export class LarkChannel {
     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);
@@ -451,4 +457,18 @@ export class LarkChannel {
             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/runtime.js

@@ -1,5 +1,6 @@
 // Channel lifecycle: which adapters are running; one call for the Console to
 // apply a config change.
+import { splitReply } from "../core/reply.js";
 import { Refused } from "../core/router.js";
 import { logger } from "../log.js";
 import { LarkChannel } from "./lark.js";
@@ -10,6 +11,9 @@ const ADAPTERS = [
     // Lark's "token" is the App ID and "appToken" the App Secret.
     { platform: "lark", build: (deps) => new LarkChannel(deps) },
 ];
+const rootLine = (lead, state) => state === "waiting" ? `▷ ${lead.name} · design — waiting for you`
+    : state === "final" ? `✓ ${lead.name} · design final`
+        : `⚠ ${lead.name} · design — ${lead.text}`;
 // The injected sink is for warnings; "slack started" is not one.
 const log = logger("channels");
 // The parameter below shadows `log` inside its own default expression.
@@ -19,15 +23,17 @@ export class ChannelRuntime {
     router;
     chain;
     control;
+    conversations;
     log;
     running = new Map();
     reloading = Promise.resolve();
     stopped = false;
-    constructor(store, router, chain, control, log = warn) {
+    constructor(store, router, chain, control, conversations, log = warn) {
         this.store = store;
         this.router = router;
         this.chain = chain;
         this.control = control;
+        this.conversations = conversations;
         this.log = log;
     }
     /** Serialized: two concurrent Console saves would race into duplicate live
@@ -70,7 +76,8 @@ export class ChannelRuntime {
         });
         try {
             await channel.start((msg) => {
-                if (this.control.isHome(msg.key))
+                // A thread of the home chat bound to a child (§Child threads) is that session's.
+                if (this.control.isHome(msg.key) && !this.control.knows(msg.key))
                     return this.toHead(channel, msg);
                 void this.router.dispatch(msg).catch((err) => this.log(`dispatch failed: ${String(err)}`));
             });
@@ -100,6 +107,44 @@ export class ChannelRuntime {
     live(platform) {
         return this.running.has(platform);
     }
+    /** A design lead waiting on the user gets a thread in the home DM bound to
+     *  its session (docs/design/11 §Child threads); its later states edit the
+     *  root. No home, its adapter down, or the session already in a chat: nothing
+     *  — the web's needs-you carries it. Every failure is a note in the chat. */
+    async designLead(lead, state) {
+        const home = this.store.home();
+        const channel = home && this.running.get(home.platform);
+        if (!home || !channel)
+            return;
+        const note = { text: rootLine(lead, state), origin: lead.origin };
+        const bound = this.conversations.keyOf(lead.sessionId);
+        if (state === "waiting") {
+            if (bound)
+                return;
+            let thread;
+            try {
+                thread = await channel.openThread(home.chatId, note);
+                // The row first: `ensure` resolves the thread through it, as any thread's message would.
+                this.conversations.set({ channelId: home.platform, conversationId: thread }, lead.sessionId);
+                await this.router.ensure({ channelId: home.platform, conversationId: thread });
+                await channel.send(thread, splitReply(lead.text));
+            }
+            catch (err) {
+                // A root already posted is the thread's failure to report; none, the main flow's.
+                await this.report(channel, thread ?? home.chatId, `"${lead.name}" waits for you on the web; ${thread ? "its turn did not reach this thread" : "its thread could not be opened"}: ${String(err)}`);
+            }
+            return;
+        }
+        // Only a thread of the home chat has a root of ours to edit.
+        if (!bound || bound.channelId !== home.platform || chatOf(bound.conversationId) !== home.chatId)
+            return;
+        await channel.editRoot(bound.conversationId, note).catch((err) => this.report(channel, bound.conversationId, `the thread's root could not be updated to "${note.text}": ${String(err)}`));
+    }
+    async report(channel, conversationId, text) {
+        this.log(text);
+        await channel.notify(conversationId, { text, origin: { kind: "error" } })
+            .catch((e) => this.log(`could not report it to ${channel.id}: ${String(e)}`));
+    }
     /** For restart-note delivery (src/drain.ts), which has no session to report
      *  through; false means the platform is not running. */
     async notify(platform, conversationId, text) {

package/dist/channels/slack-outbound.js

@@ -51,6 +51,13 @@ export class SlackOutbound {
         }
         return ts;
     }
+    /** A note's root rewritten in place (a child thread's state); one message,
+     *  so the body is cut to the smaller budget rather than split. */
+    async edit(channel, ts, note) {
+        const body = chunk(noteBody(note, "_"), MRKDWN_MAX)[0] ?? "";
+        const blocks = this.markdownBlocks ? [markdown(body)] : sections(toMrkdwn(body));
+        await this.api.updateMessage({ channel, ts, text: body, blocks });
+    }
     budget() {
         return this.markdownBlocks ? MARKDOWN_MAX : MRKDWN_MAX;
     }

package/dist/channels/slack-thread.js

@@ -39,3 +39,68 @@ export async function readThread(directory, client, channel, threadTs, limit) {
         messages: transcript(window, names, { ts: true, ids: true, thread: true }),
     };
 }
+/** A token budget, not a Slack limit: past this the agent gets the
+ *  coordinates and decides for itself. */
+const INLINE_REPLY_MAX = 30;
+/** The eager thread read is not gated: a human handing the agent a message
+ *  is the same act as an upload. */
+export async function sharedBlock(directory, api, log, share) {
+    const source = share.original_message;
+    const ts = share.ts ?? source?.ts;
+    const threadTs = share.thread_ts ?? source?.thread_ts ?? ts;
+    const replies = share.reply_count ?? source?.reply_count;
+    // A share of a reply is one message; only a parent has a thread.
+    const parent = share.channel_id && ts && threadTs === ts && replies
+        ? { channel: share.channel_id, ts, replies }
+        : null;
+    // `name<id>` is the sender prefix's grammar (core/identity.ts).
+    const author = share.author_id
+        ? `${await directory.user(api, share.author_id)}<${share.author_id}>`
+        : share.author_name || share.author_subname;
+    const where = share.channel_name
+        ? `#${share.channel_name}${share.channel_id ? `<${share.channel_id}>` : ""}`
+        : share.channel_id;
+    const head = [
+        "shared message",
+        author && `from ${author}`,
+        where && `in ${where}`,
+        ts && `at ${ts}`,
+    ].filter(Boolean).join(" ");
+    // `fallback` is Slack's plain-text rendering when a share's `text` is
+    // empty (a file-only forward, or a body that is all blocks); "" is normal.
+    const body = (share.text || share.fallback || source?.text || "").trim();
+    const thread = parent && parent.replies <= INLINE_REPLY_MAX
+        ? await sharedThread(directory, api, log, parent.channel, parent.ts, parent.replies)
+        : { transcript: false, lines: [] };
+    // The coordinates in `pier slack`'s own words (skills/pier-slack).
+    const hint = parent && !thread.transcript
+        ? `[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");
+}
+/** A read that fails or comes back cut says so in the prompt (§5). */
+export async function sharedThread(directory, api, log, channel, ts, replies) {
+    try {
+        // One over the budget, so an undercounting reply_count still reports as cut.
+        const read = await readThread(directory, api, channel, ts, INLINE_REPLY_MAX + 2);
+        if (!read.messages.length)
+            return { transcript: false, lines: [] };
+        return {
+            transcript: true,
+            lines: [
+                `[thread: ${replies} replies, oldest first — ${read.format}]`,
+                ...read.messages,
+                ...(read.truncated ? [`[thread partly read: cut at ${read.count} lines]`] : []),
+            ],
+        };
+    }
+    catch (err) {
+        log(`shared thread ${channel}/${ts} not read: ${String(err)}`);
+        return {
+            transcript: false,
+            lines: [`[thread not read: ${err instanceof Error ? err.message : String(err)}]`],
+        };
+    }
+}

package/dist/channels/slack.js

@@ -21,7 +21,7 @@ import { SlackDirectory } from "./slack-directory.js";
 import { SlackApi, } from "./slack-api.js";
 import { SlackOutbound } from "./slack-outbound.js";
 import { SlackPanel } from "./slack-panel.js";
-import { readThread } from "./slack-thread.js";
+import { sharedBlock } 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,
@@ -51,9 +51,6 @@ const READABLE_SUBTYPES = new Set(["file_share", "thread_broadcast", "message_sh
  *  sender did not choose to forward; a real share carries both flags. */
 const sharesOf = (event) => (event.attachments ?? []).filter((a) => a.is_share === true || (event.subtype === "message_share" && !a.is_msg_unfurl));
 const sharedFiles = (share) => share.files ?? share.original_message?.files ?? [];
-/** A token budget, not a Slack limit: past this the agent gets the
- *  coordinates and decides for itself. */
-const INLINE_REPLY_MAX = 30;
 export class SlackChannel {
     deps;
     id = "slack";
@@ -188,8 +185,9 @@ export class SlackChannel {
         const text = this.stripMention(raw);
         const command = parseCommand(text);
         const threadTs = threadOf(event);
-        // Every message in the home DM, in a thread or not, is the head's, under one key.
-        const home = this.isHome(channel);
+        // The home DM is the head's, in a thread or not, under one key — except a
+        // child's thread (docs/design/11 §Child threads), which is that session's.
+        const home = this.isHead(channel, event.thread_ts);
         const here = { channelId: this.id, conversationId: home ? channel : conversationId(channel, threadTs) };
         const bindRequest = command?.name === "bind" && isDm;
         const admitted = this.gate.admit("message", channel, {
@@ -215,7 +213,7 @@ export class SlackChannel {
         // 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)));
+        const shared = await Promise.all(shares.map((share) => sharedBlock(this.directory, this.api, this.log, share)));
         // `/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;
@@ -259,9 +257,9 @@ export class SlackChannel {
             this.log("incomplete block_actions payload, dropped");
             return;
         }
-        // Any click in the home DM is the head's, echoed where the button was;
-        // anywhere else a top-level message roots a thread.
-        const home = this.isHome(channel);
+        // Any click in the home DM is the head's, echoed where the button was,
+        // unless a child's thread; anywhere else a top-level message roots a thread.
+        const home = this.isHead(channel, message.thread_ts);
         const threadTs = home ? message.thread_ts : message.thread_ts ?? message.ts;
         const key = {
             channelId: this.id,
@@ -357,6 +355,11 @@ export class SlackChannel {
     isHome(channel) {
         return this.deps.control?.isHome({ channelId: this.id, conversationId: channel }) ?? false;
     }
+    /** The head's: the home DM, outside any thread a session of its own is bound to. */
+    isHead(channel, threadTs) {
+        return this.isHome(channel) &&
+            !(threadTs && this.deps.control?.knows({ channelId: this.id, conversationId: conversationId(channel, threadTs) }));
+    }
     /** A thread, or the home DM's main flow (no `threadTs`); undefined for any other channel's. */
     target(conversation) {
         const { channel, threadTs } = parseConversation(conversation);
@@ -378,68 +381,6 @@ export class SlackChannel {
         }
         return name ?? channel;
     }
-    /** 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;
-        const threadTs = share.thread_ts ?? source?.thread_ts ?? ts;
-        const replies = share.reply_count ?? source?.reply_count;
-        // A share of a reply is one message; only a parent has a thread.
-        const parent = share.channel_id && ts && threadTs === ts && replies
-            ? { channel: share.channel_id, ts, replies }
-            : null;
-        // `name<id>` is the sender prefix's grammar (core/identity.ts).
-        const author = share.author_id
-            ? `${await this.directory.user(this.api, share.author_id)}<${share.author_id}>`
-            : share.author_name || share.author_subname;
-        const where = share.channel_name
-            ? `#${share.channel_name}${share.channel_id ? `<${share.channel_id}>` : ""}`
-            : share.channel_id;
-        const head = [
-            "shared message",
-            author && `from ${author}`,
-            where && `in ${where}`,
-            ts && `at ${ts}`,
-        ].filter(Boolean).join(" ");
-        // `fallback` is Slack's plain-text rendering when a share's `text` is
-        // empty (a file-only forward, or a body that is all blocks); "" is normal.
-        const body = (share.text || share.fallback || source?.text || "").trim();
-        const thread = parent && parent.replies <= INLINE_REPLY_MAX
-            ? await this.sharedThread(parent.channel, parent.ts, parent.replies)
-            : { transcript: false, lines: [] };
-        // The coordinates in `pier slack`'s own words (skills/pier-slack).
-        const hint = parent && !thread.transcript
-            ? `[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");
-    }
-    /** A read that fails or comes back cut says so in the prompt (§5). */
-    async sharedThread(channel, ts, replies) {
-        try {
-            // One over the budget, so an undercounting reply_count still reports as cut.
-            const read = await readThread(this.directory, this.api, channel, ts, INLINE_REPLY_MAX + 2);
-            if (!read.messages.length)
-                return { transcript: false, lines: [] };
-            return {
-                transcript: true,
-                lines: [
-                    `[thread: ${replies} replies, oldest first — ${read.format}]`,
-                    ...read.messages,
-                    ...(read.truncated ? [`[thread partly read: cut at ${read.count} lines]`] : []),
-                ],
-            };
-        }
-        catch (err) {
-            this.log(`shared thread ${channel}/${ts} not read: ${String(err)}`);
-            return {
-                transcript: false,
-                lines: [`[thread not read: ${err instanceof Error ? err.message : String(err)}]`],
-            };
-        }
-    }
     saveAttachments(files) {
         return saveInboundAll(this.id, files.map((file) => ({
             label: file.name ?? "attachment",
@@ -475,4 +416,18 @@ export class SlackChannel {
         if (ts && awaitsTurn(note.origin))
             this.receipts.mark(conversation, to.channel, ts, note.at);
     }
+    async openThread(channel, note) {
+        if (!this.isHome(channel))
+            throw new Error(`refusing to open a thread in ${channel}: not the home DM`);
+        const ts = await this.out.note(channel, undefined, note);
+        if (!ts)
+            throw new Error(`Slack returned no ts for the root in ${channel}`);
+        return conversationId(channel, ts);
+    }
+    async editRoot(conversation, note) {
+        const { channel, threadTs } = parseConversation(conversation);
+        if (!threadTs)
+            throw new Error(`refusing to edit ${conversation}: no thread in the conversation id`);
+        await this.out.edit(channel, threadTs, note);
+    }
 }

package/dist/cli.js

@@ -29,6 +29,7 @@ Usage
   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 search <q...> ...      earlier sessions by what was said in them (skills/pier-search)
   pier --version | --help
 
 Options for "service install"
@@ -57,8 +58,8 @@ const argv = process.argv.slice(2);
 const parsed = (() => {
     try {
         return parseArgs({
-            // `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,
+            // `slack`, `task`, `web` and `search` own their options; only the name is parsed here.
+            args: ["slack", "task", "web", "search"].includes(argv[0] ?? "") ? [argv[0]] : argv,
             allowPositionals: true,
             strict: true,
             options: {
@@ -134,6 +135,10 @@ 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 === "search") {
+    const { runSearchCli } = await import("./core/search.js");
+    process.exitCode = await runSearchCli(argv.slice(1), (params) => askPier("/search", { params }));
+}
 else if (command === "login") {
     if (subcommand)
         fail(`unexpected argument "${subcommand}"`);

package/dist/core/chain.js

@@ -7,9 +7,28 @@ import { join } from "node:path";
 import { transact } from "../db.js";
 import { logger } from "../log.js";
 import { day } from "./identity.js";
+import { cut } from "./reply.js";
 import { CHAIN_FULL_TOKENS, CHAIN_IDLE_MS, isChatCommand } from "./types.js";
 const log = logger("core");
 const EXCHANGES = 3;
+// Seed budgets in chars (10 §Head lifecycle); the ledger is newest first, so its oldest lines go.
+const MEMORY_CHARS = 12_000;
+const NOTES_CHARS = 6_000;
+const EXCHANGES_CHARS = 4_000;
+const LEDGER_CHARS = 4_000;
+/** `cut` from the front, whole lines: notes and exchanges grow at the end,
+ *  so the newest part stays; the marker says how much went and where it is. */
+function tail(text, max, rest) {
+    if (text.length <= max)
+        return text;
+    const lines = text.split("\n");
+    let kept = 0;
+    let size = 0;
+    for (let i = lines.length - 1; i >= 0 && size + lines[i].length + 1 <= max; i--, kept++)
+        size += lines[i].length + 1;
+    const dropped = lines.length - kept;
+    return `… ${String(dropped)} lines omitted, the rest in ${rest}\n${lines.slice(dropped).join("\n")}`;
+}
 const WHY = {
     first: "the first one",
     idle: "the previous one was idle for an hour",
@@ -32,6 +51,8 @@ function lastExchanges(turns, n) {
         .map((t) => `${t.role}: ${t.text}`).join("\n\n");
 }
 const ledgerLine = (r) => `${r.runId} · ${r.name} · ${r.state} · session ${r.targetSessionId ?? "—"} · ${r.cwd ?? "—"}`;
+/** The seed lists what still needs the head: a run that ended well is `pier task runs`' to show. */
+const SEED_RUNS_HIDDEN = new Set(["succeeded", "skipped"]);
 /** `/skills`' answer on every surface, the head's and a thread's (channels/). */
 export const skillsText = (skills) => skills.map((s) => `${s.name} — ${s.description}`).join("\n") || "no skills";
 /** Only the exact word is a command: the composer is not a shell. */
@@ -177,15 +198,16 @@ export class MainChain {
     async seed(reason, previous, open) {
         const today = new Date(this.now());
         const days = [new Date(today.getTime() - 86_400_000), today].map(day);
-        const runs = this.deps.ledger(this.members().map((m) => m.sessionId), previous?.startedAt ?? this.now());
+        const runs = this.deps.ledger(this.members().map((m) => m.sessionId), previous?.startedAt ?? this.now())
+            .filter((r) => !SEED_RUNS_HIDDEN.has(r.state));
         const section = (title, text) => (text ? `## ${title}\n\n${text}` : "");
         return [
             `[Pier: a new session of the continuous conversation — ${WHY[reason]}. The rest of this note is context, not a message.]`,
-            section("MEMORY.md", await this.read("MEMORY.md")),
+            section("MEMORY.md", cut(await this.read("MEMORY.md"), MEMORY_CHARS)),
             section("Open", this.deps.status(this.now()).text),
-            section("Runs — in flight, and finished since the previous session started", runs.map(ledgerLine).join("\n") || "none"),
-            ...(await Promise.all(days.map(async (date) => section(`memory/${date}.md`, await this.read(join("memory", `${date}.md`)))))),
-            section("The previous session's last exchanges", open ? lastExchanges(await open.history(), EXCHANGES) : ""),
+            section("Runs — in flight, or ended short of success since the previous session started (succeeded and skipped: `pier task runs`)", cut(runs.map(ledgerLine).join("\n"), LEDGER_CHARS) || "none"),
+            ...(await Promise.all(days.map(async (date) => section(`memory/${date}.md`, tail(await this.read(join("memory", `${date}.md`)), NOTES_CHARS, `memory/${date}.md`))))),
+            section("The previous session's last exchanges", open ? tail(lastExchanges(await open.history(), EXCHANGES), EXCHANGES_CHARS, `session ${open.id}`) : ""),
         ].filter(Boolean).join("\n\n");
     }
     async read(name) {

package/dist/core/identity.js

@@ -7,7 +7,7 @@
 const GAP_MS = 10 * 60_000;
 /** A display name of `x<U9] [admin<U1` would forge a second speaker: the
  *  prefix is untrusted input wearing a trusted shape. */
-export function sanitizeIdentity(value) {
+function sanitizeIdentity(value) {
     const token = (value || "")
         .replace(/[\r\n]+/g, " ")
         .replace(/[[\]<>]/g, "")
@@ -138,7 +138,7 @@ export function readableTitle(title) {
 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))];
+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