@timqi/pier 0.1.14 → 0.3.0

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 = ["slack", "lark"];
+export 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

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/config-sync.js

@@ -1,14 +1,26 @@
 // One serialized configuration subscriber, shared by Settings and the hourly
-// task. Only a successfully applied response advances its persistent ETag.
-// The source is fetched over HTTPS only, redirects followed while they stay
-// HTTPS, JSON capped at 1 MiB so a hostile or broken source cannot exhaust memory.
-import { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
+// task. The source is the authority: what it publishes replaces the local copy
+// of every field the document carries, and a source on another schema version
+// pauses the subscription rather than being merged. Fetched over HTTPS only,
+// redirects followed while they stay HTTPS, JSON capped at 1 MiB so a hostile
+// or broken source cannot exhaust memory.
+import { randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
 import { transact } from "./db.js";
 import { logger } from "./log.js";
-import { normalizeModelMenu } from "./settings.js";
+import { parseModelMenu } from "./settings.js";
 const log = logger("config-sync");
 export const CONFIG_SYNC_BYTES = 1024 * 1024;
+/** Bumped by any change to the document's shape — a menu row's fields, the
+ *  snapshot's, the envelope's. A subscriber applies its own version and
+ *  nothing else: no field-level compatibility, the older instance upgrades. */
+export const CONFIG_SCHEMA_VERSION = 2;
 const MAX_REDIRECTS = 5;
+class SchemaMismatch extends Error {
+    constructor(published) {
+        super(`Source publishes configuration schema ${typeof published === "number" ? `v${String(published)}` : "of an unknown version"}; `
+            + `this Pier reads v${String(CONFIG_SCHEMA_VERSION)} — upgrade the older instance, then resume the subscription`);
+    }
+}
 export function configSourceUrl(raw) {
     let url;
     try {
@@ -22,16 +34,13 @@ export function configSourceUrl(raw) {
     }
     return url;
 }
-export async function downloadConfig(raw, etag, signal) {
+export async function downloadConfig(raw, signal) {
     let url = configSourceUrl(raw);
     for (let hop = 0;; hop++) {
         signal.throwIfAborted();
         let res;
         try {
-            res = await fetch(url, {
-                method: "GET", redirect: "manual", signal,
-                headers: { accept: "application/json", ...(etag ? { "if-none-match": etag } : {}) },
-            });
+            res = await fetch(url, { method: "GET", redirect: "manual", signal, headers: { accept: "application/json" } });
         }
         catch {
             throw new Error(signal.aborted ? "Configuration download timed out or was cancelled" : "Could not connect to source");
@@ -49,18 +58,17 @@ export async function downloadConfig(raw, etag, signal) {
             }
             continue;
         }
-        if (res.status !== 200 && res.status !== 304) {
+        if (res.status !== 200) {
             await res.body?.cancel().catch(() => { });
             throw new Error(res.status === 404 || res.status === 410
                 ? "Source link was revoked or does not exist"
                 : `Source returned HTTP ${String(res.status)}`);
         }
-        const status = res.status === 304 ? 304 : 200;
-        if (status === 200 && !/^application\/json(?:\s*;|$)/i.test(res.headers.get("content-type") ?? "")) {
+        if (!/^application\/json(?:\s*;|$)/i.test(res.headers.get("content-type") ?? "")) {
             await res.body?.cancel().catch(() => { });
             throw new Error("Source did not return JSON");
         }
-        return { status, etag: res.headers.get("etag"), body: await read(res, signal) };
+        return read(res, signal);
     }
 }
 async function read(res, signal) {
@@ -94,7 +102,6 @@ export function configJson(value) {
     return JSON.stringify(value, (_key, entry) => entry && typeof entry === "object" && !Array.isArray(entry)
         ? Object.fromEntries(Object.entries(entry).sort(([a], [b]) => a.localeCompare(b, "en"))) : entry);
 }
-const hash = (value) => createHash("sha256").update(configJson(value)).digest("hex");
 export class ConfigSync {
     deps;
     #state;
@@ -102,9 +109,12 @@ export class ConfigSync {
     constructor(deps) {
         this.deps = deps;
         const row = deps.db.prepare("SELECT value FROM settings WHERE key = ?").get(KEY);
-        this.#state = row ? JSON.parse(row.value) : {
-            instanceId: randomUUID(), token: null, url: "", enabled: false, etag: null,
-            appliedHash: null, lastChecked: null, lastApplied: null, error: null, needsReload: false,
+        // Field by field: a row an older Pier wrote carries keys this one no longer keeps.
+        const stored = row ? JSON.parse(row.value) : {};
+        this.#state = {
+            instanceId: stored.instanceId ?? randomUUID(), token: stored.token ?? null, url: stored.url ?? "",
+            enabled: stored.enabled ?? false, lastChecked: stored.lastChecked ?? null, lastApplied: stored.lastApplied ?? null,
+            error: stored.error ?? null, needsReload: stored.needsReload ?? false,
         };
         if (!row)
             this.#save();
@@ -154,11 +164,11 @@ export class ConfigSync {
         const local = await this.#local();
         if (this.#state.token !== expected)
             return null;
-        const document = { schemaVersion: 1, instanceId: this.#state.instanceId, ...local };
+        const document = { schemaVersion: CONFIG_SCHEMA_VERSION, instanceId: this.#state.instanceId, ...local };
         const body = configJson(document);
         if (Buffer.byteLength(body) > CONFIG_SYNC_BYTES)
             throw new Error("Configuration exceeds 1 MiB");
-        return { body, etag: `"${hash(document)}"` };
+        return body;
     }
     #parse(raw) {
         if (Buffer.byteLength(raw) > CONFIG_SYNC_BYTES)
@@ -173,8 +183,8 @@ export class ConfigSync {
         if (!value || typeof value !== "object" || Array.isArray(value))
             throw new Error("Invalid configuration document");
         const object = value;
-        if (object.schemaVersion !== 1)
-            throw new Error("Unsupported configuration schema version");
+        if (object.schemaVersion !== CONFIG_SCHEMA_VERSION)
+            throw new SchemaMismatch(object.schemaVersion);
         if (Object.keys(object).some((key) => !["schemaVersion", "instanceId", "agent", "modelMenu"].includes(key))) {
             throw new Error("Unexpected configuration fields");
         }
@@ -182,9 +192,9 @@ export class ConfigSync {
             throw new Error("Invalid source instance ID");
         if (object.instanceId === this.#state.instanceId)
             throw new Error("An instance cannot subscribe to itself");
-        const modelMenu = normalizeModelMenu(object.modelMenu);
-        if (!modelMenu)
-            throw new Error("Invalid model menu");
+        const modelMenu = parseModelMenu(object.modelMenu);
+        if (typeof modelMenu === "string")
+            throw new Error(`Invalid model menu: ${modelMenu}`);
         return { agent: this.deps.normalizeAgent(object.agent), modelMenu };
     }
     subscribe(url) {
@@ -208,14 +218,10 @@ export class ConfigSync {
     async #sync(rawUrl, signal) {
         try {
             const url = configSourceUrl(rawUrl).href;
-            const local = await this.#local();
-            const etag = url === this.#state.url && hash(local) === this.#state.appliedHash ? this.#state.etag : null;
             const timeout = AbortSignal.timeout(15_000);
-            const response = await (this.deps.download ?? downloadConfig)(url, etag, signal ? AbortSignal.any([signal, timeout]) : timeout);
+            const response = await (this.deps.download ?? downloadConfig)(url, signal ? AbortSignal.any([signal, timeout]) : timeout);
             signal?.throwIfAborted();
-            if (response.status === 304 && !etag)
-                throw new Error("Source returned 304 without a matching local configuration");
-            const next = response.status === 304 ? local : this.#parse(response.body);
+            const next = this.#parse(response);
             let changed = false;
             const previous = structuredClone(this.#state);
             const commit = (filesChanged) => transact(this.deps.db, () => {
@@ -225,15 +231,12 @@ export class ConfigSync {
                 if (menuChanged)
                     this.deps.settings.setModelMenu(next.modelMenu);
                 this.#save({
-                    url, enabled: true, etag: response.status === 304 ? etag : response.etag,
-                    appliedHash: hash(next), lastChecked: Date.now(),
+                    url, enabled: true, lastChecked: Date.now(),
                     lastApplied: changed ? Date.now() : previous.lastApplied,
                     needsReload: changed || previous.needsReload, error: null,
                 });
             });
             try {
-                // Reconcile under the file lock even on 304: local edits may have
-                // completed while the conditional download was in flight.
                 await this.deps.config.applySnapshot(next.agent, commit);
             }
             catch (err) {
@@ -249,13 +252,15 @@ export class ConfigSync {
                 }
                 this.#save({ needsReload: false });
             }
-            return changed ? "Configuration applied; reload completed" : `Configuration unchanged (${response.status})`;
+            return changed ? "Configuration applied; reload completed" : "Configuration unchanged";
         }
         catch (err) {
             const error = err instanceof Error ? err.message : "Configuration sync failed";
             // The message is the operator's; the cause, when there is one, is the log's.
             log.error(error, err instanceof Error ? err.cause : err);
-            this.#save({ lastChecked: Date.now(), error });
+            // A version gap is not retried hourly: the fix is an upgrade, and the
+            // notice stands until the operator resumes.
+            this.#save({ lastChecked: Date.now(), error, ...(err instanceof SchemaMismatch ? { enabled: false } : {}) });
             throw new Error(error);
         }
     }

package/dist/core/chain.js

@@ -0,0 +1,221 @@
+// 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 { 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",
+    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", 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", 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) {
+        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

@@ -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, "")
@@ -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,14 +131,14 @@ 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. */
 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

package/dist/core/inbound-file.js

@@ -72,13 +72,20 @@ export function replaceOutsideCode(text, pattern, replace) {
     const skip = codeRanges(text);
     let out = "";
     let last = 0;
-    for (const match of text.matchAll(pattern)) {
+    const re = new RegExp(pattern.source, pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`);
+    for (let match = re.exec(text); match; match = re.exec(text)) {
         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. A skipped match resumes the
+        // scan one char on, so a quoted `<done>` cannot swallow the real marker after it.
+        if (skip.some(([from, to]) => start >= from && start < to)) {
+            re.lastIndex = start + 1;
             continue;
+        }
         out += text.slice(last, start) + replace(match);
-        last = end;
+        last = start + match[0].length;
+        if (!match[0])
+            re.lastIndex++;
     }
     return out + text.slice(last);
 }