@timqi/pier 0.1.14 → 0.2.0

package/dist/core/chain.js

@@ -0,0 +1,202 @@
+// Which session takes the user's message: an ordered chain of main sessions in
+// `$PIER_HOME/home`, whose newest — the head — takes every one, rotated lazily
+// once idle past an hour or full (docs/design/10-continuous-session.md).
+import { mkdirSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { transact } from "../db.js";
+import { logger } from "../log.js";
+import { day } from "./identity.js";
+import { CHAIN_FULL_TOKENS, CHAIN_IDLE_MS, isChatCommand } from "./types.js";
+const log = logger("core");
+const EXCHANGES = 3;
+const WHY = {
+    first: "the first one",
+    idle: "the previous one was idle for an hour",
+    lost: "the previous one is gone from Pi",
+    full: `the previous one reached ${String(CHAIN_FULL_TOKENS / 1000)}K tokens`,
+    new: "you asked for one with /new",
+};
+/** A `/new` sent to a head mid-reply: a 409 to the composer, never a card the
+ *  head's queue would only deliver after the turn it refuses for. */
+export class ChatCommandRefused extends Error {
+}
+const webKey = (sessionId) => ({ channelId: "web", conversationId: sessionId });
+/** The last `n` user turns and the replies after them, text only. */
+function lastExchanges(turns, n) {
+    const users = turns.flatMap((t, i) => (t.role === "user" ? [i] : []));
+    const from = users[Math.max(0, users.length - n)];
+    if (from === undefined)
+        return "";
+    return turns.slice(from).filter((t) => t.role !== "system" && t.text)
+        .map((t) => `${t.role}: ${t.text}`).join("\n\n");
+}
+const ledgerLine = (r) => `${r.runId} · ${r.name} · ${r.state} · session ${r.targetSessionId ?? "—"} · ${r.cwd ?? "—"}`;
+/** `/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. */
+function chatCommand(text) {
+    const draft = text.trim().toLowerCase();
+    const word = draft.slice(1);
+    return /^[/%]/.test(draft) && isChatCommand(word) ? word : undefined;
+}
+export class MainChain {
+    db;
+    deps;
+    /** Sends pass one at a time, so two cannot both find the head idle and rotate twice. */
+    queue = Promise.resolve();
+    /** The chat the send in flight came from, if any: the head is attached under
+     *  it before anything is appended, so the seed reaches the chat too. */
+    chat;
+    constructor(db, deps) {
+        this.db = db;
+        this.deps = deps;
+    }
+    /** Newest first. */
+    members() {
+        const rows = this.db.prepare("SELECT session_id, started_at, reason FROM main_chain ORDER BY started_at DESC, rowid DESC")
+            .all();
+        return rows.map((r) => ({ sessionId: r.session_id, startedAt: r.started_at, reason: r.reason }));
+    }
+    /** Every member's id, newest first, when `sessionId` is one: a member's
+     *  launches are the whole chain's, and a result owed to it goes to the head. */
+    chainOf(sessionId) {
+        const ids = this.members().map((m) => m.sessionId);
+        return ids.includes(sessionId) ? ids : undefined;
+    }
+    /** What `/status` answers, now: the Status panel shows this same text. */
+    status() {
+        return this.deps.status(this.now());
+    }
+    /** Resolve the head, rotating it first when due, then dispatch to `key` (a
+     *  chat's) or else the head's own; `command` names a chat command, answered
+     *  without a turn. */
+    send(message, key) {
+        const command = chatCommand(message.text);
+        if (command)
+            return this.serial(key, (session, rotated) => this.command(command, session, rotated)).then((head) => ({ ...head, command }));
+        return this.serial(key, async (session) => {
+            await this.deps.router.dispatch({ ...message, key: key ?? webKey(session.id) });
+        });
+    }
+    /** `status`, `stop` and `skills` answer with a card on the head; `new` answers with the
+     *  next head's seed card — a head just rotated for its own reason is that answer. */
+    async command(command, session, rotated) {
+        const origin = { kind: "chat-command", command };
+        if (command === "new") {
+            if (session.state === "streaming")
+                throw new ChatCommandRefused("the conversation is replying — /stop first");
+            if (rotated)
+                return undefined;
+            return { session: await this.rotate("new", this.members()[0], session), rotated: "new" };
+        }
+        if (command === "skills") {
+            await session.systemInput(skillsText(session.skills()), origin, "append");
+            return undefined;
+        }
+        if (command === "stop") {
+            const running = session.state === "streaming";
+            if (running)
+                await session.abort();
+            await session.systemInput(running ? "stopped" : "nothing running", origin, "append");
+            return undefined;
+        }
+        const { text, sessions } = this.status();
+        await session.systemInput(text, { ...origin, sessions }, "append");
+        return undefined;
+    }
+    /** `then` may rotate again and return the head it made; the caller's answer is that one. */
+    serial(key, then) {
+        const done = this.queue.then(async () => {
+            this.chat = key;
+            const found = await this.current();
+            if (key)
+                this.deps.router.attach(key, found.session);
+            const { session, rotated } = (await then(found.session, found.rotated)) ?? found;
+            return { sessionId: session.id, ...(rotated ? { rotated } : {}) };
+        });
+        this.queue = done.catch(() => undefined);
+        return done;
+    }
+    now() {
+        return this.deps.now?.() ?? Date.now();
+    }
+    async current() {
+        const head = this.members()[0];
+        if (!head)
+            return { session: await this.rotate("first"), rotated: "first" };
+        const live = this.deps.router.stateOf(head.sessionId) !== undefined;
+        if (!live && !(await this.deps.factory.find(head.sessionId))) {
+            log.warn(`main session ${head.sessionId} is gone from Pi — starting the next one`);
+            return { session: await this.rotate("lost", head), rotated: "lost" };
+        }
+        const session = await this.deps.router.ensure(webKey(head.sessionId));
+        // A head with no user message yet counts from its start: its seed is not the user speaking.
+        const spoke = (await session.history()).reduce((at, t) => (t.role === "user" && t.at ? t.at : at), head.startedAt);
+        if (session.state === "streaming")
+            return { session };
+        if (this.now() - spoke >= CHAIN_IDLE_MS)
+            return { session: await this.rotate("idle", head, session), rotated: "idle" };
+        // Unknown right after a compaction: that head is small again, not full.
+        if ((session.contextUsage?.tokens ?? 0) <= CHAIN_FULL_TOKENS)
+            return { session };
+        return { session: await this.rotate("full", head, session), rotated: "full" };
+    }
+    async rotate(reason, previous, open) {
+        // Built before anything is created: a seed that fails leaves no orphan session.
+        const seed = await this.seed(reason, previous, open).catch((err) => {
+            log.warn("the continuous conversation's next session could not be seeded", err);
+            throw new Error(`a new session could not start — its seed failed: ${String(err)}`);
+        });
+        // An unset or unreadable default keeps the previous head's choice, then Pi's model at low effort.
+        const defaults = await this.deps.defaults().catch((err) => {
+            log.warn("the Settings defaults could not be read — the next main session keeps the previous one's model", err);
+            return { defaultModel: null, defaultThinkingLevel: null };
+        });
+        const model = defaults.defaultModel ?? open?.model;
+        mkdirSync(this.deps.home, { recursive: true });
+        const session = await this.deps.factory.create({
+            cwd: this.deps.home,
+            ...(model ? { model } : {}),
+            thinking: defaults.defaultThinkingLevel ?? open?.thinkingLevel ?? "low",
+        });
+        transact(this.db, () => {
+            this.db.prepare("INSERT INTO main_chain(session_id, started_at, reason) VALUES (?, ?, ?)").run(session.id, this.now(), reason);
+            // A lost head has no transcript to page back to; the new head's reason says it went.
+            if (reason === "lost" && previous)
+                this.db.prepare("DELETE FROM main_chain WHERE session_id = ?").run(previous.sessionId);
+        });
+        this.deps.router.attach(webKey(session.id), session);
+        if (this.chat)
+            this.deps.router.attach(this.chat, session);
+        await session.systemInput(seed, { kind: "session-seed", reason, previousSessionId: previous?.sessionId ?? null }, "append");
+        log.info(`main session ${session.id} started (${reason})`);
+        return session;
+    }
+    /** Read fresh at every rotation; a part that cannot be read says so in the seed. */
+    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 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("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) : ""),
+        ].filter(Boolean).join("\n\n");
+    }
+    async read(name) {
+        try {
+            return (await readFile(join(this.deps.home, name), "utf8")).trim();
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                return "";
+            log.warn(`seed: could not read ${name}`, err);
+            return `(could not be read: ${String(err)})`;
+        }
+    }
+}

package/dist/core/identity.js

@@ -19,7 +19,24 @@ export function sanitizeIdentity(value) {
 const sanitizePlace = (value) => value.replace(/[[\]<>\s]+/g, "").slice(0, 120);
 const two = (n) => String(n).padStart(2, "0");
 const hhmm = (d) => `${two(d.getHours())}:${two(d.getMinutes())}`;
-const day = (d) => `${d.getFullYear()}-${two(d.getMonth() + 1)}-${two(d.getDate())}`;
+export const day = (d) => `${d.getFullYear()}-${two(d.getMonth() + 1)}-${two(d.getDate())}`;
+/** Pasted code, links and paths are English whatever the speaker writes in. */
+const NOT_PROSE = /```[\s\S]*?(?:```|$)|`[^`\n]*`|\[[^\]\n]*\]\([^)\n]*\)|[!-~]*[/\\][!-~]*/g;
+/** The language a message is written in, or `undefined` when it is too short
+ *  to tell (`ok`, `👍`) and the last one still applies. A CJK character counts
+ *  as two Latin words: a short question under a pasted English log is still
+ *  the speaker's language. */
+export function detectLanguage(text) {
+    const prose = text.replace(NOT_PROSE, " ");
+    const han = prose.match(/\p{Script=Han}/gu)?.length ?? 0;
+    const kana = prose.match(/[\p{Script=Hiragana}\p{Script=Katakana}]/gu)?.length ?? 0;
+    const hangul = prose.match(/\p{Script=Hangul}/gu)?.length ?? 0;
+    const words = prose.match(/[A-Za-z]{2,}/g)?.length ?? 0;
+    const cjk = han + kana + hangul;
+    if (cjk > 0 && cjk * 2 >= words)
+        return kana ? "ja" : hangul > han ? "ko" : "zh";
+    return words >= 3 ? "en" : undefined;
+}
 /** What each session has already been told. In memory: after a restart one
  *  redundant header is a rounding error. */
 export class SenderPrefix {
@@ -27,18 +44,22 @@ export class SenderPrefix {
     /** 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.
-     *  `opaqueIds` is the platform's (`core/types.ts`): its ids buy nothing. */
-    next(sessionId, sender, at = Date.now(), conversation, opaqueIds = false) {
+     *  `opaqueIds` is the platform's (`core/types.ts`): its ids buy nothing.
+     *  `text` is the message, for its language: `lang=zh` tells the model which
+     *  language to answer in, since an English-heavy context drags replies there. */
+    next(sessionId, sender, at = Date.now(), conversation, opaqueIds = false, text = "") {
         if (!sender?.id)
             return "";
         const last = this.seen.get(sessionId);
-        this.seen.set(sessionId, { senderId: sender.id, at, conversation });
+        const lang = detectLanguage(text) ?? last?.lang;
+        this.seen.set(sessionId, { senderId: sender.id, at, conversation, lang });
         const now = new Date(at);
         const newSpeaker = last?.senderId !== sender.id;
         const gap = !last || at - last.at >= GAP_MS;
         const newDay = !last || day(new Date(last.at)) !== day(now);
         const newPlace = !!conversation && last?.conversation !== conversation;
-        if (!newSpeaker && !gap && !newDay && !newPlace)
+        const newLang = !!lang && last?.lang !== lang;
+        if (!newSpeaker && !gap && !newDay && !newPlace && !newLang)
             return "";
         // The id is the only thing a mention can be built from; an unresolved name
         // is the id, and `U123<U123>` would read as a broken record.
@@ -52,7 +73,7 @@ export class SenderPrefix {
         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(" ")}]`;
+        return `[${[who, when, where, newLang ? `lang=${lang}` : ""].filter(Boolean).join(" ")}]`;
     }
     forget(sessionId) {
         this.seen.delete(sessionId);
@@ -62,18 +83,19 @@ 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 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`);
+const LANG = String.raw `lang=(?<lang>[a-z]{2})`;
+const WITH_ID = new RegExp(String.raw `^\[(?:(?<name>[^\n[\]<>]*)<(?<id>[^\n[\]<>]+)>)? ?${TIME}? ?(?<where>[a-z]+:[^\s[\]<>]+)? ?(?:${LANG})?\]\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`);
+const NAMED = new RegExp(String.raw `^\[(?<name>[^\n[\]<>]*?) ${TIME}(?: (?<where>[a-z]+))?(?: ${LANG})?\]\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 head = WITH_ID.exec(text);
-    const { id, when, where } = head?.groups ?? {};
+    const { id, when, where, lang } = 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);
+    const m = id || when || where || lang ? head : NAMED.exec(text);
     if (!m?.groups)
         return { text };
     return {
@@ -81,6 +103,7 @@ export function splitSpeaker(text) {
         ...(m.groups.id ? { id: m.groups.id } : {}),
         ...(m.groups.when ? { when: m.groups.when } : {}),
         ...(m.groups.where ? { where: m.groups.where } : {}),
+        ...(m.groups.lang ? { lang: m.groups.lang } : {}),
         text: text.slice(m[0].length),
     };
 }
@@ -108,7 +131,7 @@ export function readableTitle(title) {
         .trim();
     return said || title;
 }
-/** How a session is named where it is announced (a push, a handoff): its
+/** How a session is named where it is announced (a push): 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. */

package/dist/core/inbound-file.js

@@ -74,11 +74,12 @@ export function replaceOutsideCode(text, pattern, replace) {
     let last = 0;
     for (const match of text.matchAll(pattern)) {
         const start = match.index;
-        const end = start + match[0].length;
-        if (skip.some(([from, to]) => start < to && end > from))
+        // A match is code when it begins in code; one that merely holds a span
+        // (`<open>run \`x\`</open>`) is prose around it.
+        if (skip.some(([from, to]) => start >= from && start < to))
             continue;
         out += text.slice(last, start) + replace(match);
-        last = end;
+        last = start + match[0].length;
     }
     return out + text.slice(last);
 }

package/dist/core/reply.js

@@ -1,71 +1,27 @@
 // Assistant-reply presentation, computed once for every surface: the next-step
-// block syntax, silence, completion stats and the emphasis repair. Web chat and
-// every IM adapter render these, so the wording and units live here.
-/** The surface contract handed to every agent Pier launches (main.ts); the
- *  syntax the agent is told to emit sits beside the parser that reads it back. */
-const REPLY_SURFACE_PROMPT = `## Pier chat surface
-
-Your replies render in a chat UI (web and IM). Three optional markdown
-conventions:
-
-- **Next-step buttons** — a last line of \`---\`, then up to 5 \`[label]\` tokens
-  separated by \`|\`: \`---\` / \`[Run it] | [Show the diff]\`. A click sends that
-  label as the user's next message. Only for short, obvious next moves, never
-  for anything destructive.
-- **Attachments** — link a file you produced by absolute \`file://\` URL:
-  \`[report.md](file:///abs/path/report.md)\`. Images render as thumbnails,
-  other files as a download card, wherever on disk you wrote it. The same
-  convention runs inbound: a user message ending in \`[name](file:///…)\`
-  lines is carrying files the sender attached, already saved to disk — read
-  one only when it matters to the task; every read puts its content in your
-  context for good.
-- **Staying silent** — \`<silent>why</silent>\` is stripped, and if nothing else
-  remains no message is sent. In a group chat you are handed every message,
-  including humans talking to each other: stay silent rather than acknowledge
-  what was not addressed to you.
-
-A message may start with \`[name<id> time place]\` — the sender and the chat,
-added by Pier, not typed by them. It appears only on a change — new speaker, a
-~10-minute gap, a new day — so the last one still applies; a gap alone shows as
-time only, like \`[14:23]\`. Use that \`id\` to mention someone; never ask for
-their own. \`place\` is \`<platform>:<conversation>\` (Slack:
-\`slack:<channel>/<thread_ts>\`), said once per session: the channel and thread a
-script takes. Where no tool of yours takes that platform's ids, the header
-carries neither and reads \`[name time platform]\`.
-`;
-/** Deployment facts an agent cannot discover: a guessed path is wrong wherever
- *  `PIER_HOME` moved and fails as "nothing is configured"; GPT models carry
- *  `apply_patch` from post-training and go hunting for it in the shell. */
-export function surfacePrompt(instance) {
-    const reach = instance.publicUrl
-        ? `Address: ${instance.publicUrl} — a board's link is that plus ` +
-            "`/boards/<slug>/`, or `/p/<slug>-<token>/` once published, where `token` " +
-            "is the random field the manifest carries beside `public`."
-        : "No public address is configured (the user sets one in Console → Settings), " +
-            "so give paths and never guess a host.";
-    return `${REPLY_SURFACE_PROMPT}
-## This Pier instance
-
-Boards: \`${instance.boardsDir}/<slug>/\` — this path, not \`~/.pier\`. ${reach}
-
-Editing: files change through the \`edit\` tool (exact text replacement) or
-\`write\`. There is no \`apply_patch\` here — not as a tool, not as a command —
-so do not call one or go looking for one in the shell.
-`;
-}
+// block syntax, silence, the open-item markers, completion stats and the
+// emphasis repair. Web chat and every IM adapter render these, so the wording
+// and units live here.
+import { replaceOutsideCode } from "./inbound-file.js";
+import { TASK_RUN_STATES } from "./types.js";
+// The syntax is told in agent/roles.ts; this file parses it back.
 /** Where a system input came from; wording every surface must spell the same. */
 export function originLabel(origin) {
-    if (origin.kind === "error")
-        return "\u26a0 failed";
-    if (origin.kind !== "task-message") {
-        return origin.kind === "task-delegation" ? "\u25b6 delegated task" : "\u21a9 task callback";
+    switch (origin.kind) {
+        case "error": return "\u26a0 failed";
+        case "task-delegation": return "\u25b6 delegated task";
+        case "task-callback": return "\u21a9 task callback";
+        case "session-seed": return `\u21ba new session \u00b7 ${origin.reason}`;
+        case "chat-command": return `/${origin.command}`;
+        case "task-message":
+            return `from a supervisor \u00b7 ${origin.messageKind === "steer" ? "\u270e steer" : "\uff0b follow-up"}`;
     }
-    return `from a supervisor \u00b7 ${origin.messageKind === "steer" ? "\u270e steer" : "\uff0b follow-up"}`;
 }
 /** Is a turn coming once this note is posted? On IM the note is the only
- *  message that turn has to wear the 👀; an error note reports a turn that
- *  already ended, and a receipt on it would hang until the stale sweep. */
-export const awaitsTurn = (origin) => origin.kind !== "error";
+ *  message that turn has to wear the 👀; a receipt on any other would hang
+ *  until the stale sweep: an error reports a turn that already ended, a chat
+ *  command's answer starts none, and the message that made a seed wears its own. */
+export const awaitsTurn = (origin) => origin.kind !== "error" && origin.kind !== "chat-command" && origin.kind !== "session-seed";
 /** Punctuation that may be lifted out of a `**strong**` run: nothing a reader
  *  can see changes, and the delimiter comes off a character the parser refuses
  *  to close on. */
@@ -73,14 +29,9 @@ const LIFTABLE = /[\u201c\u201d"\u2018\u2019'()\uff08\uff09\u300c\u300d\u300e\u3
 /** CommonMark's right-flanking rule does not count CJK punctuation, so
  *  `**“怎么做”**：` never closes (a spec hole, not a platform bug, and constant
  *  in model output). Moving the punctuation outside — `“**怎么做**”：` — lands
- *  the `**` against a letter. Fences and code spans are content, protected first. */
+ *  the `**` against a letter. Fences and code spans are content, never touched. */
 export function cjkFriendly(markdown) {
-    const stash = [];
-    const keep = (text) => `\uE010${stash.push(text) - 1}\uE011`;
-    let out = markdown
-        .replace(/```[\s\S]*?```/g, (m) => keep(m))
-        .replace(/`[^`\n]+`/g, (m) => keep(m));
-    out = out.replace(/\*\*(\S|\S[\s\S]*?\S)\*\*/g, (whole, inner) => {
+    return replaceOutsideCode(markdown, /\*\*(\S|\S[\s\S]*?\S)\*\*/g, ([whole, inner = ""]) => {
         let lead = "";
         let trail = "";
         let body = inner;
@@ -94,7 +45,6 @@ export function cjkFriendly(markdown) {
         }
         return lead || trail ? `${lead}**${body}**${trail}` : whole;
     });
-    return out.replace(/\uE010(\d+)\uE011/g, (_m, i) => stash[Number(i)] ?? "");
 }
 /** The reason arrives pre-escaped: each surface escapes for its own markup,
  *  and the label itself contains nothing any of them escape. */
@@ -105,6 +55,26 @@ export const isSilentReply = (reply) => !reply.text.trim() && reply.suggestions.
 export const thinkingLabel = (level) => level === "xhigh" ? "Extra high" : level[0].toUpperCase() + level.slice(1);
 /** `max` characters, the last one an ellipsis when something was cut. */
 export const cut = (text, max) => (text.length > max ? `${text.slice(0, max - 1)}…` : text);
+/** Compact age of `ts` at `now` ("now", "12m", "3h", "2d"): every surface ages things the same way. */
+export function relTime(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`;
+}
+/** The age as it reads beside a wall clock, where "now" would be a fragment. */
+export const agoLabel = (ts, now) => {
+    const age = relTime(ts, now);
+    return age === "now" ? "just now" : `${age} ago`;
+};
+/** A run's state and its age: how long it has been going, or how long ago it ended. */
+export const runStatus = (r, now) => r.finishedAt === null ? `${r.state} ${relTime(r.queuedAt, now)}` : `${r.state} ${agoLabel(r.finishedAt, now)}`;
+/** A lead's launches by state, in the states' own order: "2 running, 1 failed". */
+export const workerCounts = (workers) => TASK_RUN_STATES.filter((s) => workers[s] > 0).map((s) => `${String(workers[s])} ${s}`).join(", ") || "none";
 /** 1200 → "1.2K", 12_000 → "12K" — absolute token counts read badly inline. */
 export const compact = (n) => {
     if (n < 1000)
@@ -134,7 +104,47 @@ const MAX_SUGGESTIONS = 5;
 const ZW = String.raw `[\u200B-\u200D\u2060\uFEFF]*`;
 const tag = (literal) => literal.split("").join(ZW);
 const SILENT = new RegExp(`${tag("<silent>")}([\\s\\S]*?)${tag("</silent>")}`, "gi");
-const SILENT_TAG = new RegExp(`<(\\/?)${tag("silent>")}`, "gi");
+/** A tag that hides what it wraps: a streaming renderer never cuts inside one. */
+const HIDDEN_TAG = new RegExp(`<(\\/?)(${["silent", "open", "done"].map(tag).join("|")})${ZW}>`, "gi");
+const ZW_CHARS = new RegExp(ZW.slice(0, -1), "g");
+/** Main's open-item markers (docs/design/10-continuous-session.md): stripped like
+ *  `<silent>`, and read back by core/chain.ts on the head's turn end. Code is
+ *  content, so a marker inside a fence or a code span is neither. Group 1 is an
+ *  `<open>` body, group 2 a `<done>` body. */
+const MARKER = new RegExp(`${tag("<open>")}([\\s\\S]*?)${tag("</open>")}[ \\t]*\\n?|${tag("<done>")}([\\s\\S]*?)${tag("</done>")}[ \\t]*\\n?`, "gi");
+const RUN_TOKEN = /\s*\(run\s+([^\s()]+)\)\s*$/i;
+const oneLine = (text) => text.replace(/\s+/g, " ").trim();
+/** The markers in reply order; `dropped` holds the ones with no problem text,
+ *  for the caller to log. */
+export function openItemMarkers(markdown) {
+    const markers = [];
+    const dropped = [];
+    replaceOutsideCode(markdown, MARKER, (m) => {
+        if (m[1] === undefined) {
+            const problem = oneLine(m[2] ?? "");
+            if (problem)
+                markers.push({ op: "done", problem });
+            else
+                dropped.push(m[0].trim());
+            return "";
+        }
+        let rest = oneLine(m[1]);
+        const runIds = [];
+        for (let run = RUN_TOKEN.exec(rest); run; run = RUN_TOKEN.exec(rest)) {
+            runIds.unshift(run[1]);
+            rest = rest.slice(0, run.index);
+        }
+        const dash = rest.indexOf("\u2014");
+        const problem = (dash < 0 ? rest : rest.slice(0, dash)).trim();
+        const stage = dash < 0 ? "" : rest.slice(dash + 1).trim();
+        if (problem)
+            markers.push({ op: "open", problem, stage, runIds });
+        else
+            dropped.push(m[0].trim());
+        return "";
+    });
+    return { markers, dropped };
+}
 /** Why the agent stayed quiet; hidden from the chat, shown on the workbench,
  *  where a silent turn must not look like a broken one. */
 export function silentReason(markdown) {
@@ -160,21 +170,22 @@ export function splitReply(rawMarkdown, meta) {
 }
 /** For rendering mid-turn: everything `splitReply` repairs, minus the
  *  next-step block, which is only one at the very end of a turn. */
-export const streamBody = (markdown) => cjkFriendly(markdown.replace(SILENT, "").trim());
+export const streamBody = (markdown) => cjkFriendly(replaceOutsideCode(markdown.replace(SILENT, ""), MARKER, () => "").trim());
 /** Lines a blank line does not necessarily separate (a loose list is still one
  *  list). Over-matching is fine: one boundary too few costs only a repaint. */
 const CONTINUES = /^(?:\s|[-*+>]|\d+[.)])/;
 /** Offset past the last blank line after `from` that closes a block, so a
  *  streaming renderer can parse each closed prefix once (whole-reply reparse is
  *  O(N²) over a turn). A boundary is claimed only where the two sides render the
- *  same apart as together: never inside a fence, a `<silent>` block, or a loose
+ *  same apart as together: never inside a fence, a `<silent>`/`<open>`/`<done>` block, or a loose
  *  list/quote. A ```` fence is not closed by the ``` it quotes. */
 export function stableBlockEnd(markdown, from = 0) {
     // The last line is still growing, so it decides nothing.
     const end = markdown.lastIndexOf("\n") + 1;
     /** Marker run of the fence currently open; empty = closed. */
     let open = "";
-    let silent = false;
+    /** The hiding tag currently open; empty = none. */
+    let hidden = "";
     let cut = from;
     /** Start of the block after a blank line, waiting for its first line. */
     let pending = -1;
@@ -184,21 +195,26 @@ export function stableBlockEnd(markdown, from = 0) {
         const line = markdown.slice(at, nl);
         at = nl + 1;
         const fence = /^\s*(`{3,}|~{3,})(.*)$/.exec(line);
-        if (!open && !silent && !line.trim()) {
+        if (!open && !hidden && !line.trim()) {
             if (pending < 0 && prev)
                 pending = at;
             continue;
         }
-        if (!open && !silent && pending >= 0 && !(CONTINUES.test(prev) && CONTINUES.test(line)))
+        if (!open && !hidden && pending >= 0 && !(CONTINUES.test(prev) && CONTINUES.test(line)))
             cut = pending;
         const run = fence?.[1] ?? "";
-        if (!open && run && !silent)
+        if (!open && run && !hidden)
             open = run;
         else if (open && run[0] === open[0] && run.length >= open.length && !fence?.[2]?.trim())
             open = "";
-        if (!open && (!run || silent)) {
-            for (const t of line.matchAll(SILENT_TAG))
-                silent = !t[1];
+        if (!open && (!run || hidden)) {
+            for (const t of line.matchAll(HIDDEN_TAG)) {
+                const name = t[2].replace(ZW_CHARS, "").toLowerCase();
+                if (!t[1] && !hidden)
+                    hidden = name;
+                else if (t[1] && name === hidden)
+                    hidden = "";
+            }
         }
         pending = -1;
         prev = line;