@timqi/pier 0.2.0 → 0.3.1

package/dist/core/inbound-file.js

@@ -72,14 +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;
         // 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))
+        // (`<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 = start + match[0].length;
+        if (!match[0])
+            re.lastIndex++;
     }
     return out + text.slice(last);
 }

package/dist/core/reply.js

@@ -3,7 +3,7 @@
 // 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";
+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) {
@@ -30,7 +30,7 @@ const LIFTABLE = /[\u201c\u201d"\u2018\u2019'()\uff08\uff09\u300c\u300d\u300e\u3
  *  `**“怎么做”**：` 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, never touched. */
-export function cjkFriendly(markdown) {
+function cjkFriendly(markdown) {
     return replaceOutsideCode(markdown, /\*\*(\S|\S[\s\S]*?\S)\*\*/g, ([whole, inner = ""]) => {
         let lead = "";
         let trail = "";
@@ -75,6 +75,11 @@ export const agoLabel = (ts, now) => {
 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)
@@ -170,7 +175,16 @@ 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(replaceOutsideCode(markdown.replace(SILENT, ""), MARKER, () => "").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+[.)])/;

package/dist/core/search.js

@@ -0,0 +1,65 @@
+// `pier search`: the `/search` route's host and the verb's argv, on the search
+// seam core declares (`AgentFactory.search`); root keeps only the dispatch, as
+// for `pier task` and `pier web`. Argv shape is checked here, the host validates
+// the params, and its text reaches the shell verbatim (08 §Failure lines).
+import { parseArgs } from "node:util";
+import { readableTitle } from "./identity.js";
+const USAGE = "usage: pier search <q...> [--limit N] [--json]";
+// The match marks are the palette's to paint; a line is one line.
+const flat = (text) => text.replaceAll("\u0001", "").replaceAll("\u0002", "").replace(/\s+/g, " ").trim();
+// A title may be a whole first message; the snippet is what the line is for.
+const TITLE_CHARS = 30;
+const clip = (text) => {
+    const chars = [...text];
+    return chars.length > TITLE_CHARS ? `${chars.slice(0, TITLE_CHARS - 1).join("").trimEnd()}…` : text;
+};
+// sv-SE spells local time as YYYY-MM-DD HH:MM.
+const when = (at) => new Date(at).toLocaleString("sv-SE", { dateStyle: "short", timeStyle: "short" });
+const processIo = {
+    stdout: (line) => process.stdout.write(`${line}\n`),
+    stderr: (line) => process.stderr.write(`${line}\n`),
+};
+/** `/search`'s params to hits, each titled with its session's name as it is
+ *  now; a session gone from disk is named by its id. */
+export const searchSessions = (factory) => async (params) => {
+    const { q, limit = 20 } = (params ?? {});
+    const query = typeof q === "string" ? q.trim() : "";
+    if (!query)
+        throw new Error("q must be non-empty words to search for");
+    if (!Number.isInteger(limit))
+        throw new Error("limit must be an integer");
+    const hits = await factory.search(query, Math.min(50, Math.max(1, limit)));
+    return {
+        hits: await Promise.all(hits.map(async (hit) => ({ ...hit, title: readableTitle((await factory.find(hit.sessionId))?.title) ?? hit.sessionId }))),
+    };
+};
+/** One line per hit, or the answer's object with `--json`. */
+export async function runSearchCli(argv, post, io = processIo) {
+    let v = {};
+    let words = [];
+    try {
+        ({ values: v, positionals: words } = parseArgs({ args: argv, allowPositionals: true, strict: true, options: { limit: { type: "string" }, json: { type: "boolean" } } }));
+    }
+    catch (err) {
+        io.stderr(`search: ${err instanceof Error ? err.message : String(err)}\n${USAGE}`);
+        return 2;
+    }
+    if (!words.length) {
+        io.stderr(`search: say what to search for\n${USAGE}`);
+        return 2;
+    }
+    const { status, body } = await post({ q: words.join(" "), ...(v.limit === undefined ? {} : { limit: Number(v.limit) }) });
+    if (status !== 200 || !body.result) {
+        io.stderr(`search: ${body.error ?? `socket answered ${String(status)}`}`);
+        return 1;
+    }
+    const { hits } = body.result;
+    if (v.json)
+        io.stdout(JSON.stringify(body.result));
+    else if (!hits.length)
+        io.stdout("no hits");
+    else
+        for (const hit of hits)
+            io.stdout(`${hit.sessionId} · ${clip(flat(hit.title))} · ${hit.role} · ${when(hit.at)}: ${flat(hit.snippet)}`);
+    return 0;
+}

package/dist/core/types.js

@@ -26,6 +26,8 @@ export const CHAIN_FULL_TOKENS = 60_000;
 /** Declared here, not in tasks/, because `BackgroundRun`, the `task-status` event core carries, names it.
  *  In order: the Console lists them so, and a worker count reads so. */
 export const TASK_RUN_STATES = ["queued", "running", "succeeded", "failed", "cancelled", "interrupted", "skipped"];
+/** The `state` of a run an open item names that the ledger no longer holds; its `name` is the id. */
+export const NOT_IN_LEDGER = "not in the ledger";
 /** How much of a tool result any surface ever shows. A transcript replay
  *  carries no more than that: a session's tool output is most of its history
  *  payload, and the bytes past this point were downloaded to be sliced off. */

package/dist/db.js

@@ -348,6 +348,14 @@ const MIGRATIONS = [
     `
   ALTER TABLE session_state DROP COLUMN sort;
   ALTER TABLE session_state DROP COLUMN closed;
+  `,
+    // 33 — columns written and never read.
+    `
+  ALTER TABLE session_state DROP COLUMN cwd;
+  ALTER TABLE session_state DROP COLUMN project_sort;
+  ALTER TABLE conversations DROP COLUMN updated_at;
+  ALTER TABLE restart_ledger DROP COLUMN created_at;
+  ALTER TABLE push_identity DROP COLUMN created_at;
   `,
 ];
 /** `BEGIN IMMEDIATE`: taking the write lock up front turns a race with another

package/dist/drain.js

@@ -15,7 +15,7 @@ export class RestartLedger {
         this.db = db;
     }
     record(entry) {
-        this.db.prepare("INSERT INTO restart_ledger (channel_id, conversation_id, note, created_at) VALUES (?, ?, ?, ?)").run(entry.channelId, entry.conversationId, entry.note, Date.now());
+        this.db.prepare("INSERT INTO restart_ledger (channel_id, conversation_id, note) VALUES (?, ?, ?)").run(entry.channelId, entry.conversationId, entry.note);
     }
     list() {
         const rows = this.db.prepare("SELECT id, channel_id, conversation_id, note FROM restart_ledger ORDER BY id").all();

package/dist/main.js

@@ -20,13 +20,16 @@ import { ChannelRuntime } from "./channels/runtime.js";
 import { MainChain } from "./core/chain.js";
 import { EventHub } from "./core/hub.js";
 import { splitSpeaker } from "./core/identity.js";
+import { saidText } from "./core/reply.js";
 import { pierDb } from "./db.js";
 import { deliverLedger, drainForRestart, RestartLedger } from "./drain.js";
 import { surfacePrompt } from "./agent/roles.js";
 import { Router } from "./core/router.js";
+import { searchSessions } from "./core/search.js";
 import { acquireInstanceLock } from "./lock.js";
 import { parseWebParams, runWeb } from "./websearch/run.js";
 import { logger } from "./log.js";
+import { runResultText, runSource } from "./tasks/callbacks.js";
 import { openItemsStatus } from "./tasks/open-items.js";
 import { registerTaskRoutes } from "./tasks/routes.js";
 import { TaskService } from "./tasks/service.js";
@@ -100,8 +103,9 @@ const factory = new PiAgentFactory(
 () => surfacePrompt({ boardsDir: defaultBoardsDir(), publicUrl: settings.get().publicUrl }), 
 // Documents Pier's own tools, so it loads only inside a Pier session.
 [skillsDir], new CredentialStore(db, secrets), piConfig, () => settings.get().modelMenu, () => settings.get(), () => settings.get().titleModel, 
-// Transcripts carry the speaker header core wrote for the model.
-new IndexedListing(undefined, undefined, (text) => splitSpeaker(text).text), (id) => taskStore.roleOf(id));
+// Transcripts carry the speaker header core wrote for the model, and replies
+// the chat markup core strips before anyone sees them.
+new IndexedListing(undefined, undefined, (text) => splitSpeaker(text).text, saidText), (id) => taskStore.roleOf(id));
 const hub = new EventHub();
 const router = new Router(hub, (key) => {
     // Web conversation ids are session ids; an IM id is a chat, resolved through
@@ -132,6 +136,17 @@ tasks = new TaskService(taskStore, factory, router, hub, {
         },
     },
     continuous: chain,
+    // `channels` is assigned below, before any run can settle.
+    designLead: (run, state) => {
+        if (!run.targetSessionId)
+            return;
+        void channels.designLead({
+            sessionId: run.targetSessionId,
+            name: run.context.definition.name,
+            origin: { kind: "task-callback", taskId: run.taskId, runId: run.id, sourceSessionId: run.targetSessionId, source: runSource(run), state: run.state },
+            text: state === "failed" ? run.error ?? run.state : runResultText(run),
+        }, state).catch((err) => log.error(`lead ${run.targetSessionId ?? "?"}: its ${state} state did not reach the home chat`, err));
+    },
 });
 const configurationSync = configSyncTask(tasks, configSync);
 const managedTools = new ManagedTools();
@@ -149,7 +164,7 @@ const control = createControl({
     router, factory, conversations, store: channelStore,
     modelMenu: () => settings.get().modelMenu,
 });
-const channels = new ChannelRuntime(channelStore, router, chain, control);
+const channels = new ChannelRuntime(channelStore, router, chain, control, conversations);
 /** The head answers in the home chat while its adapter runs (docs/design/11), else on
  *  the web with Web Push; an older member gets no home key, or an adapter's start
  *  would re-key it over the head. Any other session: its conversations row. */
@@ -348,6 +363,7 @@ servePier({
         note(`done ${JSON.stringify(result.details)}`);
         return result;
     },
+    search: searchSessions(factory),
     // Live in the router, or on disk: the same two places a callback target is looked for.
     knows: async (id) => router.stateOf(id) !== undefined || (await factory.find(id)) !== undefined,
     login: () => `${settings.get().publicUrl || `http://127.0.0.1:${String(port)}`}/login/${auth.mintLink()}`,
@@ -383,8 +399,8 @@ const shutdown = (stopTasks = true) => {
     // 90-second wait for SIGKILL.
     setTimeout(() => process.exit(0), 3000).unref();
     stopEviction();
-    // The drain path leaves task runs alone: aborting would record them cancelled,
-    // when the boot-time interrupted marking is the recovery that was promised.
+    // Aborted runs end interrupted, as boot recovery records them; the drain path
+    // leaves the ones it outlasted to that recovery.
     if (stopTasks)
         tasks.stop();
     void channels.stop().finally(() => {

package/dist/settings.js

@@ -92,7 +92,7 @@ export function normalizeModelRef(raw) {
 }
 /** Shape only: tools.ts owns the catalog, and an unknown name is ignored
  *  there, so a downgrade cannot lose a setting it cannot explain. */
-export function normalizeTools(raw) {
+function normalizeTools(raw) {
     return normalizeNames(raw);
 }
 function normalizeNames(raw) {

package/dist/socket.js

@@ -33,6 +33,7 @@ const ROUTES = {
     },
     "/task": operation("task"),
     "/web": operation("web"),
+    "/search": operation("search"),
     async "/login"({ login }, _body, _sessionId, answer) {
         const url = login();
         log.info("sign-in link minted for pier login");

package/dist/tasks/agent.js

@@ -20,7 +20,7 @@ const preamble = (run, supervised, role) => {
             : "read by the operator";
     return `[Pier task run ${run.id} — "${run.context.definition.name}"] ` +
         `Your final reply is recorded verbatim as the run result, ${audience}; ` +
-        `next-step buttons and file:// attachments do not render there. Return the conclusion and the paths it rests on — no process, no log of attempts; a deliverable longer than a screen goes to a file the result names. A question only that reader can answer is your result: state it and end your turn; the answer resumes this session.` +
+        `next-step buttons and file:// attachments do not render there. Two parts: the conclusion — the paths it rests on, risks and unverified points one line each — then, only when something does, \`Needs your decision\`; no process, no log of attempts; a deliverable longer than a screen goes to a file the result names. A reversible choice on the way (how to push, a rebase strategy) is yours: take the recommended option and name it in the result. A destructive or irreversible step — force push, deleting what you did not create, a migration, a deploy, a restart — or a question only that reader can answer stops you: state it as your result and end your turn; the answer resumes this session.` +
         (role === "lead"
             ? " You are a feature lead: you may delegate to workers with `pier task run` (never `--role lead`), and their results come back to you."
             : supervised || role === "worker" ? " You cannot delegate from here — `pier task` is refused; if the work needs another agent, say so in your result and your supervisor will run it." : "") +

package/dist/tasks/callbacks.js

@@ -22,7 +22,7 @@ const oneRun = (run) => {
     return { source: runSource(run), state: run.state, ...(cwd ? { cwd } : {}) };
 };
 /** Heads a milestone resume's prompt: the lead's reply is what its supervisor reads. */
-export const MILESTONE = "[Pier: the last result you were waiting on follows; nothing owed to you is still running. Your reply is the milestone your supervisor reads: what is done, what is next, any decision you need.]";
+export const MILESTONE = "[Pier: the last result you were waiting on follows; nothing owed to you is still running. Your reply is the milestone your supervisor reads, in two parts: the conclusion (done, next, risks one line each), then `Needs your decision` only when something does.]";
 /** The line a design lead ends on once the user confirms: its milestone, whether a run's or a turn outside any. */
 export const DESIGN_FINAL = /^Design final:/m;
 /** On the record of a lead run that owed its supervisor nothing, so the run says why. */

package/dist/tasks/execution.js

@@ -3,7 +3,9 @@
 import { logger } from "../log.js";
 import { settleCallback } from "./callbacks.js";
 import { runBash } from "./command.js";
+import { INTERRUPTED } from "./store.js";
 const log = logger("tasks");
+const SHUTDOWN = Symbol("shutdown");
 export class TaskExecution {
     store;
     definitions;
@@ -21,9 +23,11 @@ export class TaskExecution {
     start(run) {
         void this.execute(run);
     }
+    /** Shutdown: the abort still kills each detached bash group, which boot
+     *  recovery could not, but the run ends as that recovery would record it. */
     stop() {
         for (const controller of this.controllers.values())
-            controller.abort();
+            controller.abort(SHUTDOWN);
     }
     cancel(id) {
         log.info(`run ${id} cancel requested`);
@@ -75,9 +79,11 @@ export class TaskExecution {
         }
         catch (error) {
             // A killed child reports `exited null`; report why we aborted instead.
+            // The first abort's reason wins: a shutdown after a user cancel stays cancelled.
             const aborted = controller.signal.aborted;
-            run.state = aborted ? (timedOut ? "failed" : "cancelled") : "failed";
-            run.error = timedOut ? "task timed out" : aborted ? "cancelled" : String(error);
+            const interrupted = aborted && !timedOut && controller.signal.reason === SHUTDOWN;
+            run.state = aborted ? (timedOut ? "failed" : interrupted ? "interrupted" : "cancelled") : "failed";
+            run.error = timedOut ? "task timed out" : interrupted ? INTERRUPTED : aborted ? "cancelled" : String(error);
             cause = timedOut ? run.error : error;
         }
         finally {

package/dist/tasks/open-items.js

@@ -1,26 +1,21 @@
 // The continuous conversation's open items in task-run words: main's markers
 // joined to the run ledger by session, a lead's workers counted by state, and
 // the one text every surface shows (docs/design/10-continuous-session.md#open-items).
-import { openItemMarkers, runStatus, workerCounts } from "../core/reply.js";
-import { LEDGER_WINDOW_MS, TASK_RUN_STATES } from "../core/types.js";
+import { openItemMarkers, openRunText } from "../core/reply.js";
+import { LEDGER_WINDOW_MS, NOT_IN_LEDGER, TASK_RUN_STATES } from "../core/types.js";
 import { logger } from "../log.js";
-import { NOT_IN_LEDGER } from "./types.js";
 const log = logger("tasks");
 const IN_FLIGHT = new Set(["queued", "running"]);
 /** `members`: the chain, newest first; `designs`: the open designs of sessions not closed. */
 export function openItems(tasks, router, members, designs, now) {
     const since = now - LEDGER_WINDOW_MS;
     const runs = members.length ? tasks.ledger(members, since) : [];
-    const withWorkers = (r) => {
-        if (!r.targetSessionId || tasks.store.roleOf(r.targetSessionId) !== "lead")
-            return r;
-        const workers = Object.fromEntries(TASK_RUN_STATES.map((s) => [s, 0]));
-        for (const w of tasks.ledger([r.targetSessionId], since)) {
-            if (w.state in workers)
-                workers[w.state] += 1;
-        }
-        return { ...r, workers };
-    };
+    const awaiting = new Set(designs.flatMap((d) => (d.targetSessionId ? [d.targetSessionId] : [])));
+    const statusOf = (named) => named.some((r) => IN_FLIGHT.has(r.state) || (r.targetSessionId && router.stateOf(r.targetSessionId) === "streaming"))
+        ? "running"
+        : named.some((r) => r.targetSessionId && awaiting.has(r.targetSessionId))
+            ? "waiting on you"
+            : named.length && named.every((r) => r.state === "succeeded") ? "pending release" : "waiting on you";
     // An item names a session through any of its runs: the session's newest run stands for it.
     const tracked = new Set();
     const items = tasks.store.openItems().map((row) => {
@@ -28,15 +23,36 @@ export function openItems(tasks, router, members, designs, now) {
             const session = runs.find((r) => r.runId === id)?.targetSessionId ?? tasks.store.getRun(id)?.targetSessionId ?? null;
             tracked.add(session ?? id);
             const run = runs.find((r) => (session ? r.targetSessionId === session : r.runId === id));
-            return run
-                ? withWorkers(run)
-                : { runId: id, name: id, state: NOT_IN_LEDGER, targetSessionId: session, cwd: null, queuedAt: 0, finishedAt: null };
+            return run ?? { runId: id, name: id, state: NOT_IN_LEDGER, targetSessionId: session, cwd: null, queuedAt: 0, finishedAt: null };
         }).filter((r, i, all) => all.findIndex((o) => o.runId === r.runId) === i);
-        const busy = named.some((r) => IN_FLIGHT.has(r.state) || (r.targetSessionId && router.stateOf(r.targetSessionId) === "streaming"));
-        return { problem: row.problem, stage: row.stage, runs: named, ...(named.length ? { live: busy ? "running" : "idle" } : {}) };
+        return { problem: row.problem, stage: row.stage, runs: named, status: statusOf(named) };
+    });
+    const unlisted = runs.filter((r) => IN_FLIGHT.has(r.state) && !tracked.has(r.targetSessionId ?? r.runId));
+    for (const r of unlisted)
+        tracked.add(r.targetSessionId ?? r.runId);
+    const unheld = designs.filter((d) => !tracked.has(d.targetSessionId ?? d.runId)).map((d) => {
+        const named = [runs.find((r) => d.targetSessionId && r.targetSessionId === d.targetSessionId) ?? d];
+        return { problem: d.name, stage: "", runs: named, status: statusOf(named) };
     });
-    const unlisted = runs.filter((r) => IN_FLIGHT.has(r.state) && !tracked.has(r.targetSessionId ?? r.runId)).map(withWorkers);
-    return { items, unlisted, designs };
+    const all = [...items, ...unheld];
+    // Every shown lead's workers in one read: a ledger call per lead grows with the list.
+    const leads = tasks.store.leads();
+    const leadOf = (r) => (r.state !== NOT_IN_LEDGER && r.targetSessionId && leads.has(r.targetSessionId) ? r.targetSessionId : null);
+    const shown = new Set([...all.flatMap((i) => i.runs), ...unlisted].flatMap((r) => leadOf(r) ?? []));
+    const counts = new Map([...shown].map((id) => [id, Object.fromEntries(TASK_RUN_STATES.map((s) => [s, 0]))]));
+    for (const w of shown.size ? tasks.store.ledgerRuns([...shown], since) : []) {
+        const c = w.invokedBySessionId ? counts.get(w.invokedBySessionId) : undefined;
+        if (c)
+            c[w.state] += 1;
+    }
+    const withWorkers = (r) => {
+        const workers = counts.get(leadOf(r) ?? "");
+        return workers ? { ...r, workers: { ...workers } } : r;
+    };
+    return {
+        items: all.map((i) => ({ ...i, runs: i.runs.map(withWorkers) })),
+        unlisted: unlisted.map(withWorkers),
+    };
 }
 /** The head's reply's markers, written; answers whether a row changed. */
 export function recordOpenItems(store, text, now) {
@@ -45,26 +61,28 @@ export function recordOpenItems(store, text, now) {
         log.warn(`open items: dropped a marker with no problem text: ${marker}`);
     return markers.length > 0 && store.markOpenItems(markers, now) > 0;
 }
-const workersText = (workers) => workers ? ` · workers: ${workerCounts(workers)}` : "";
-const runText = (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)}${workersText(r.workers)}`;
-/** The one string every surface shows for the open items: `/status` and the seed. */
-export function renderOpenItems({ items, unlisted, designs }, now) {
-    if (!items.length && !unlisted.length && !designs.length)
+/** An `unlisted` run's stage: main named it in no item. */
+const UNLISTED = "not on the list";
+/** `status` is an item's, or `queued` for an unlisted run not started, as the panel tags it. */
+const itemLine = (i, now) => `- ${i.problem}${i.stage ? ` — ${i.stage}` : ""} (${i.status})${i.runs.map((r) => ` · ${openRunText(r, now)}`).join("")}`;
+/** The one string every surface shows for the open items: `/status` and the seed.
+ *  Grouped as the status panel groups them (web/ui/drawer.ts): what waits on the user first. */
+function renderOpenItems({ items, unlisted }, now) {
+    if (!items.length && !unlisted.length)
         return "Nothing open.";
-    const open = items.map((i) => `- ${i.problem}${i.stage ? ` — ${i.stage}` : ""}${i.live ? ` (${i.live})` : ""}${i.runs.map((r) => ` · ${runText(r, now)}`).join("")}`);
-    const rest = unlisted.map((r) => `- ${r.name} — ${runStatus(r, now)}${workersText(r.workers)}`);
-    const decide = designs.map((r) => `- ${r.name} · ${runText(r, now)}`);
+    const waiting = items.filter((i) => i.status !== "running").map((i) => itemLine(i, now));
+    const running = [
+        ...items.filter((i) => i.status === "running").map((i) => itemLine(i, now)),
+        ...unlisted.map((r) => itemLine({ problem: r.name, stage: UNLISTED, runs: [r], status: r.state === "queued" ? "queued" : "running" }, now)),
+    ];
     return [
-        ...(open.length ? ["Open", ...open] : []),
-        ...(rest.length ? ["Not on the list", ...rest] : []),
-        ...(decide.length ? ["Designs for you to finalize", ...decide] : []),
+        ...(waiting.length ? ["Waiting on you", ...waiting] : []),
+        ...(running.length ? ["In progress", ...running] : []),
     ].join("\n");
 }
-/** `/status`'s card: the text, and run id → session id for every named run and listed design that has one. */
+/** `/status`'s card: the text, and run id → session id for every run it names that has one. */
 export function openItemsStatus(open, now) {
-    const sessions = Object.fromEntries([...open.items.flatMap((i) => i.runs), ...open.designs]
+    const sessions = Object.fromEntries([...open.items.flatMap((i) => i.runs), ...open.unlisted]
         .flatMap((r) => (r.targetSessionId ? [[r.runId, r.targetSessionId]] : [])));
     return { text: renderOpenItems(open, now), sessions };
 }

package/dist/tasks/service.js

@@ -3,7 +3,7 @@
 // drain needs. Decisions belong to the files beside it.
 import { logger } from "../log.js";
 import { AgentTaskRunner } from "./agent.js";
-import { DESIGN_FINAL, MILESTONE, runCwd, settleCallback, TaskCallbacks } from "./callbacks.js";
+import { DESIGN_FINAL, LEAD_TURN, MILESTONE, runCwd, settleCallback, TaskCallbacks } from "./callbacks.js";
 import { TaskDefinitions, requiredString } from "./definitions.js";
 import { TaskExecution } from "./execution.js";
 import { TaskGroups } from "./groups.js";
@@ -138,6 +138,26 @@ export class TaskService {
         else
             log.info(`lead ${sessionId}: Design final: outside any run, recorded as run ${run.id} for ${run.callbackSessionId}`);
         this.runs.start(run);
+        this.designLead(run);
+    }
+    /** What a settled run of a design lead means to whoever shows the lead to
+     *  the user (channels/runtime.ts); a reporter that throws must not unwind the settle. */
+    designLead(run) {
+        const lead = run.targetSessionId;
+        if (!this.instance.designLead || lead === null || this.store.leadPhaseOf(lead) !== "design")
+            return;
+        const state = run.callbackError === LEAD_TURN ? "waiting"
+            : run.state !== "succeeded" ? "failed"
+                : run.result?.type === "agent" && DESIGN_FINAL.test(run.result.text) ? "final"
+                    : undefined;
+        if (!state)
+            return;
+        try {
+            this.instance.designLead(run, state);
+        }
+        catch (err) {
+            log.error(`lead ${lead}: its ${state} state could not be reported`, err);
+        }
     }
     start(tickMs = 1000) {
         if (this.timer)
@@ -445,6 +465,7 @@ export class TaskService {
                 resolve(run);
         this.waiters.delete(run.id);
         this.groups.onSettled(run);
+        this.designLead(run);
     }
     backgroundRun(run) {
         return {

package/dist/tasks/store.js

@@ -6,6 +6,8 @@ const clamp = (limit, cap) => Math.min(Math.max(limit, 1), cap);
 /** Kept unmatched probes per watch: one page of history, which is all any
  *  surface lists of a probe that found nothing. */
 const KEPT_PROBES = 50;
+/** The error of a run a restart or shutdown stopped: not a result, not a cancel. */
+export const INTERRUPTED = "Pier restarted while the run was active";
 export class TaskStore {
     db;
     /** Every query below is a fixed string, so each is compiled once. */
@@ -194,8 +196,9 @@ export class TaskStore {
     }
     /** What a milestone resumes, and whose supervisor it reports to. */
     latestRunForTarget(sessionId) {
+        // Two runs queued in one millisecond are common (a turn and the run it records); ids are random, rowid is insertion order.
         return this.#one(`
-      SELECT json FROM task_runs WHERE json_extract(json, '$.targetSessionId') = ? ORDER BY queued_at DESC, id DESC LIMIT 1
+      SELECT json FROM task_runs WHERE json_extract(json, '$.targetSessionId') = ? ORDER BY queued_at DESC, rowid DESC LIMIT 1
     `, sessionId);
     }
     /** Runs in flight whose result is owed to the session, their own or their
@@ -316,7 +319,7 @@ export class TaskStore {
     interruptRunning(now = Date.now()) {
         return this.#many("SELECT json FROM task_runs WHERE state IN ('queued', 'running')").map((run) => {
             run.state = "interrupted";
-            run.error = "Pier restarted while the run was active";
+            run.error = INTERRUPTED;
             run.finishedAt = now;
             if (run.callbackSessionId)
                 run.callbackState = "pending";

package/dist/tasks/types.js

@@ -17,5 +17,3 @@ export const isTerminal = (state) => state === "succeeded" ||
 /** The role a fresh run's session is created with and keeps: a lead's, or a
  *  worker's when a session launched it; a cron or watch run's has none. */
 export const createdRole = ({ context: { definition: { action } }, invokedBySessionId }) => action.type === "agent" && action.launch?.role === "lead" ? "lead" : invokedBySessionId !== null ? "worker" : undefined;
-/** The `state` of a run an item names that the ledger no longer holds; its `name` is the id. */
-export const NOT_IN_LEDGER = "not in the ledger";

package/dist/tools.js

@@ -392,6 +392,8 @@ export class ManagedTools {
     #fetch;
     #root;
     #lock;
+    /** Why a tool is absent lives only here: `ubix list` never names one that failed to install. */
+    #lastSync;
     #db;
     constructor(options = {}) {
         this.#exec = options.exec ?? spawnExec;
@@ -459,7 +461,8 @@ export class ManagedTools {
             // The only thing that changes what `list` answers; drop the memo both sides.
             this.#listed = undefined;
             try {
-                return await this.#converge(tools, customTools, fence);
+                this.#lastSync = await this.#converge(tools, customTools, fence);
+                return this.#lastSync;
             }
             finally {
                 this.#listed = undefined;
@@ -527,8 +530,12 @@ export class ManagedTools {
         }
         return base.map((entry) => {
             const state = states.find((s) => s.name === entry.name);
-            if (!state)
-                return entry;
+            if (!state) {
+                if (!entry.enabled)
+                    return entry;
+                const synced = this.#lastSync?.entries.find((e) => e.name === entry.name);
+                return withBinary(entry, { error: synced?.error ?? "not installed — the last sync did not reach it" });
+            }
             const gone = state.installed === true && state.exists === false;
             // `npm:` lands in fnm's node prefix and `pixi:` in its own: installed,
             // but not where Pier's PATH points, and the row has to say so.

package/dist/web/public/assets/{code-BZwvPani.js → code-CWT27KH1.js}

@@ -1,2 +1,2 @@
-import{J as e,r as t}from"./highlight-5Bl8zZ8q.js";var n=2e4;function r(e){let t=e.split(`
+import{J as e,r as t}from"./highlight-CDSk2hRJ.js";var n=2e4;function r(e){let t=e.split(`
 `);return t.at(-1)===``&&t.pop(),t.map((e,t)=>({nums:[t+1],text:e,tone:``}))}function i(t,r){let i=t.length<=n?r:null,o=Math.max(2,...t.map(e=>e.nums.reduce((e,t)=>Math.max(e,String(t).length),0))),s=e(`div`,`py-2 font-mono text-[12px] leading-[1.5]`);for(let n of t){let t=e(`div`,`flex pl-2 pr-4 ${n.tone===`add`?`bg-emerald-50`:n.tone===`del`?`bg-red-50`:``}`);for(let r of n.nums){let n=e(`span`,`flex-none select-none pr-1.5 text-right text-neutral-300`,r===``?``:String(r));n.style.width=`calc(${o}ch + 0.375rem)`,t.append(n)}let r=n.nums.at(-1);typeof r==`number`&&(t.dataset.line=String(r)),t.append(a(n,i)),s.append(t)}return s}function a(n,r){let i=`min-w-0 flex-1 whitespace-pre-wrap [overflow-wrap:anywhere]`;if(!n.mark||n.mark[0]>=n.mark[1]){let e=t(n.text,r);return e.className=i,e}let[a,o]=n.mark,s=t(n.text.slice(a,o),r);return s.className=`rounded-xs ${n.tone===`add`?`bg-emerald-200/80`:`bg-red-200/70`}`,e(`span`,i,t(n.text.slice(0,a),r),s,t(n.text.slice(o),r))}export{r as n,i as t};