@timqi/pier 0.1.14 → 0.3.0

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 { NOT_IN_LEDGER, 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. */
-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) => {
+ *  the `**` against a letter. Fences and code spans are content, never touched. */
+function cjkFriendly(markdown) {
+    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,31 @@ 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";
+/** A run behind an open item, `run <id8>… <state> <age>`, a lead's with its workers;
+ *  web/ui/turn-activity.ts `linkRuns` reads the token back. */
+export const openRunText = (r, now) => r.state === NOT_IN_LEDGER
+    ? `run ${r.runId} — ${NOT_IN_LEDGER}`
+    : `run ${r.runId.length > 8 ? `${r.runId.slice(0, 8)}…` : r.runId} ${runStatus(r, now)}${r.workers ? ` · workers: ${workerCounts(r.workers)}` : ""}`;
 /** 1200 → "1.2K", 12_000 → "12K" — absolute token counts read badly inline. */
 export const compact = (n) => {
     if (n < 1000)
@@ -134,7 +109,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 +175,31 @@ 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(unmarked(markdown));
+const unmarked = (markdown) => replaceOutsideCode(markdown.replace(SILENT, ""), MARKER, () => "").trim();
+/** What a message says with Pier's markup off — `<silent>`, the open-item
+ *  markers, the next-step block — and otherwise untouched: search cuts its
+ *  snippets from this. */
+export function saidText(markdown) {
+    const body = unmarked(markdown);
+    const m = BLOCK.exec(body);
+    return m?.[1] ? body.slice(0, m.index).trimEnd() : body;
+}
 /** 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 +209,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;