@timqi/pier 0.0.1

package/README.md

@@ -0,0 +1,97 @@
+# Pier
+
+A self-hosted workspace for coding agents. Pier puts a web workbench and your
+IM channels in front of [Pi](https://github.com/earendil-works/pi) sessions:
+you talk to the same agent from a browser, from Slack or from Telegram, steer a
+running turn, schedule tasks, watch what every session is doing, and publish a
+static page when something is worth showing.
+
+One instance, one account, your own machine. The agent runs shell commands in
+directories you name, so Pier is meant for a machine you own and a boundary you
+control — not for a shared host.
+
+**Status: pre-release.** The version is `0.0.x` and the database schema is
+versioned from `0.0.1` on — earlier databases are not migrated. Read
+`docs/deploy.md` before putting it anywhere reachable.
+
+## Requirements
+
+- Node 24 or newer (`node:sqlite` is used unflagged)
+- A Pi provider key (Anthropic, OpenAI, …) — Pi's own config, in
+  `~/.pi/agent/settings.json`, editable from Console → Configuration
+- Optional: the `sqlite3` CLI, for backups and password resets
+
+## Run it
+
+```sh
+npm install -g @timqi/pier
+pier
+```
+
+It listens on `127.0.0.1:3141` (`PORT`, `HOST`) and keeps everything under
+`~/.pier` (`PIER_HOME`): one SQLite database and the boards it serves.
+
+**The first start generates a password and prints it once.** Every HTTP surface
+is behind it — there is no default password and no unclaimed window. Lost it?
+`sqlite3 ~/.pier/pier.db 'DELETE FROM auth'` and restart; a new one is printed.
+
+Open `http://localhost:3141`, sign in, then:
+
+- **Console → Configuration** — provider keys and model defaults (Pi's files)
+- **Console → Channels** — Slack (Socket Mode) or Telegram bot tokens; chats
+  are discovered when the bot first sees traffic, and stay gated by the
+  mention/bind rules you set
+- **New session** — pick a directory; that is where the agent's shell runs
+
+## Run it as a service
+
+```sh
+pier service install     # --port, --host, --pier-home, --force
+pier service status
+pier service uninstall
+```
+
+Linux only, because it is systemd. It writes `~/.config/systemd/user/pier.service`
+with the absolute path of the node you installed with (systemd's PATH would not
+find a version-managed one), a memory drop-in it never rewrites afterwards, and
+turns on linger so scheduled tasks survive your logout. On macOS run `pier` in
+a terminal, or under whatever supervisor you already use.
+
+`docs/deploy.md` is the same thing written out by hand, plus what the memory
+limits mean, how updates work (and why the updater is a second unit), how to
+read the first-run password out of the journal, and what to back up.
+
+Exposing it needs two things: a reverse proxy or tunnel that terminates TLS
+(Pier binds the loopback and expects `X-Forwarded-For`/`-Proto`), and the
+understanding that whoever gets past the password gets a shell.
+
+## Develop
+
+```sh
+git clone https://github.com/timqi/pier.git ~/pier
+cd ~/pier && npm ci && npm run build
+
+just dev          # build the web bundle, then tsx watch on PIER_HOME=~/.pier_test
+npm run check     # tsc, server and web
+npm run lint      # oxlint
+npm test          # vitest
+```
+
+- `AGENTS.md` — the principles this codebase is held to, and the budgets that
+  say when a change is too big. Read it before writing code here.
+- `docs/architecture.md` — the seams, the areas, and what is deliberately absent
+- `docs/design/` — one document per subsystem, written before it was built
+
+## Releases
+
+`main` is the only development line. `npm version minor` writes the tag, the
+tag builds and publishes a GitHub Release, and the version in the web footer is
+the one from `package.json` — so the number on screen always names a commit.
+Schema upgrades are one-way: a database migrated by a newer Pier is refused by
+an older one, so take the backup `docs/deploy.md` describes before upgrading.
+
+## License
+
+[AGPL-3.0-only](LICENSE). Run it, change it, deploy it. If you offer a modified
+Pier to other people over a network, they are entitled to your source — the
+version in the footer links to this repository for exactly that reason.

package/dist/agent/config.js

@@ -0,0 +1,133 @@
+// Pi configuration on disk, behind the ConfigStore seam. Knows Pi's directory
+// conventions (the Pier-managed global dir; <cwd>/AGENTS.md and <cwd>/.pi per
+// project) but not the Pi SDK — pure filesystem, unit-testable in a tmp dir.
+import { promises as fs } from "node:fs";
+import { join, resolve, sep } from "node:path";
+import { pierPath } from "../paths.js";
+const GLOBAL_FILES = ["SYSTEM.md", "AGENTS.md", "settings.json", "models.json"];
+const PROJECT_FILES = ["AGENTS.md"];
+const RESOURCE_DEPTH = 3; // extensions/skills nest at most a couple of levels
+/** Pier owns the Pi runtime dir: config lives in the syncable `~/.pier/pi`
+ * repo, not `~/.pi`. main.ts exports this as PI_CODING_AGENT_DIR so the SDK's
+ * own path resolution (auth.json, sessions, bin) lands in the same place. */
+export const defaultAgentDir = () => process.env.PI_CODING_AGENT_DIR ?? pierPath("pi");
+/** Stable mask: recomputable at write time, so "unchanged" is detectable. */
+const maskKey = (key) => key.length > 8 ? `${key.slice(0, 4)}…${key.slice(-4)}` : "•••";
+export class PiConfigStore {
+    agentDir;
+    constructor(agentDir = defaultAgentDir()) {
+        this.agentDir = agentDir;
+    }
+    /** Whitelist is the security boundary — nothing outside it is reachable. */
+    fileNames(scope) {
+        return scope.kind === "global" ? GLOBAL_FILES : PROJECT_FILES;
+    }
+    filePath(scope, name) {
+        if (!this.fileNames(scope).includes(name)) {
+            throw new Error(`not an editable config file: ${name}`);
+        }
+        return scope.kind === "global" ? join(this.agentDir, name) : join(scope.cwd, name);
+    }
+    resourceRoot(scope, kind) {
+        return scope.kind === "global"
+            ? join(this.agentDir, kind)
+            : join(scope.cwd, ".pi", kind);
+    }
+    async listFiles(scope) {
+        return Promise.all(this.fileNames(scope).map(async (name) => ({
+            name,
+            exists: await fs.access(this.filePath(scope, name)).then(() => true, () => false),
+        })));
+    }
+    async readFile(scope, name) {
+        const raw = await fs.readFile(this.filePath(scope, name), "utf8").catch(() => "");
+        return name === "models.json" ? maskModels(raw) : raw;
+    }
+    async writeFile(scope, name, content) {
+        const path = this.filePath(scope, name);
+        const data = name === "models.json"
+            ? unmaskModels(content, await fs.readFile(path, "utf8").catch(() => ""))
+            : content;
+        await fs.mkdir(scope.kind === "global" ? this.agentDir : scope.cwd, { recursive: true });
+        await fs.writeFile(path, data);
+    }
+    async listResources(scope) {
+        return {
+            extensions: await listDir(this.resourceRoot(scope, "extensions")),
+            skills: await listDir(this.resourceRoot(scope, "skills")),
+        };
+    }
+    async readResource(scope, kind, name) {
+        const root = this.resourceRoot(scope, kind);
+        const path = resolve(root, name);
+        // Containment check — the listing is relative paths, reject anything else.
+        if (!path.startsWith(root + sep))
+            throw new Error(`invalid resource path: ${name}`);
+        return fs.readFile(path, "utf8");
+    }
+}
+/**
+ * Relative paths of all files under root, bounded depth, sorted; [] if absent.
+ * Symlinks are followed (skills and extensions are routinely linked in from a
+ * checkout elsewhere) and everything reached through one is flagged, so the UI
+ * can say where it really came from. The depth bound is also the cycle guard.
+ */
+async function listDir(root, prefix = "", depth = RESOURCE_DEPTH, linked = false) {
+    if (depth === 0)
+        return [];
+    const entries = await fs.readdir(join(root, prefix), { withFileTypes: true }).catch(() => []);
+    const out = [];
+    for (const e of entries) {
+        const rel = prefix ? `${prefix}/${e.name}` : e.name;
+        const link = linked || e.isSymbolicLink();
+        // A Dirent for a symlink is neither file nor directory — stat through it.
+        const target = e.isSymbolicLink()
+            ? await fs.stat(join(root, rel)).catch(() => null) // dangling link → skip
+            : e;
+        if (target?.isDirectory())
+            out.push(...(await listDir(root, rel, depth - 1, link)));
+        else if (target?.isFile())
+            out.push({ name: rel, link });
+    }
+    return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+/**
+ * models.json carries provider API keys — the UI must never see them. A file
+ * that fails to parse is passed through untouched: the user needs to see the
+ * broken content to repair it, and the keys in it are their own.
+ */
+function maskModels(raw) {
+    const parsed = parseModels(raw);
+    if (!parsed)
+        return raw;
+    for (const p of Object.values(parsed.providers ?? {})) {
+        if (typeof p.apiKey === "string" && p.apiKey)
+            p.apiKey = maskKey(p.apiKey);
+    }
+    return JSON.stringify(parsed, null, 2);
+}
+/** Restore stored keys wherever the incoming value is still the mask. */
+function unmaskModels(content, currentRaw) {
+    const incoming = parseModels(content);
+    if (!incoming)
+        throw new Error("models.json must be valid JSON");
+    const current = parseModels(currentRaw);
+    for (const [name, p] of Object.entries(incoming.providers ?? {})) {
+        const stored = current?.providers?.[name]?.apiKey;
+        if (typeof p.apiKey === "string" &&
+            typeof stored === "string" &&
+            p.apiKey === maskKey(stored)) {
+            p.apiKey = stored;
+        }
+    }
+    return JSON.stringify(incoming, null, 2);
+}
+function parseModels(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed === "object" && parsed !== null ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/agent/credentials.js

@@ -0,0 +1,179 @@
+// Provider credentials — what Pi kept in <agentDir>/auth.json, and the
+// literal API keys models.json used to carry — at rest in pier.db, sealed by
+// Secrets. Implements pi-ai's CredentialStore contract structurally (shapes
+// mirrored below, no SDK import: only pi.ts names SDK modules), so
+// ModelRuntime reads through here and an OAuth refresh writes the rotated
+// token back through here instead of a file. A stored credential wins over a
+// models.json apiKey in pi-ai's resolution order, which is what lets the
+// sweep below leave models.json purely structural — and safely syncable.
+import { existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { logger } from "../log.js";
+import { defaultAgentDir } from "./config.js";
+const log = logger("credentials");
+/** Envelope from secrets.ts. A value that matches was sealed by us; anything
+ *  else is legacy plaintext, still honored and re-sealed on the next write. */
+const SEALED = /^v1:[0-9a-f]{8}:/;
+export class CredentialStore {
+    db;
+    secrets;
+    agentDir;
+    #imported = false;
+    /** Writes run one at a time: pi-ai refreshes OAuth tokens inside modify()
+     *  and relies on it being a serialized read-modify-write. */
+    #chain = Promise.resolve();
+    constructor(db, secrets, agentDir = defaultAgentDir()) {
+        this.db = db;
+        this.secrets = secrets;
+        this.agentDir = agentDir;
+    }
+    /** Locked Secrets must fail a session open loudly, with the reason — not
+     *  surface later as "provider is not configured". Called by pi.ts before
+     *  every open; encrypt() throws the `secrets locked: ...` error we want. */
+    assertUnlocked() {
+        if (this.secrets.state === "locked")
+            this.secrets.encrypt("");
+    }
+    async read(providerId, options) {
+        options?.signal?.throwIfAborted();
+        this.#ensureImported();
+        return this.#get(providerId);
+    }
+    async list(options) {
+        options?.signal?.throwIfAborted();
+        this.#ensureImported();
+        const rows = this.db.prepare("SELECT key, value FROM credentials").all();
+        return rows.map((row) => ({ providerId: row.key, type: this.#parse(row.value).type }));
+    }
+    async modify(providerId, fn, options) {
+        return this.#serialized(options, async () => {
+            const next = await fn(this.#get(providerId));
+            options?.signal?.throwIfAborted();
+            if (next === undefined)
+                return this.#get(providerId);
+            this.#put(providerId, next);
+            return next;
+        });
+    }
+    async delete(providerId, options) {
+        return this.#serialized(options, async () => {
+            this.db.prepare("DELETE FROM credentials WHERE key = ?").run(providerId);
+        });
+    }
+    #serialized(options, run) {
+        const op = this.#chain.then(() => {
+            options?.signal?.throwIfAborted();
+            this.#ensureImported();
+            return run();
+        }, 
+        // The chain only sequences; a predecessor's failure is its caller's news.
+        () => {
+            options?.signal?.throwIfAborted();
+            this.#ensureImported();
+            return run();
+        });
+        this.#chain = op.catch(() => { });
+        return op;
+    }
+    #get(providerId) {
+        const row = this.db.prepare("SELECT value FROM credentials WHERE key = ?").get(providerId);
+        return row ? this.#parse(row.value) : undefined;
+    }
+    #parse(value) {
+        const plain = SEALED.test(value) ? this.secrets.decrypt(value) : value;
+        return JSON.parse(plain);
+    }
+    #put(providerId, credential) {
+        this.db
+            .prepare("INSERT INTO credentials(key, value) VALUES (?, ?) " +
+            "ON CONFLICT(key) DO UPDATE SET value = excluded.value")
+            .run(providerId, this.secrets.encrypt(JSON.stringify(credential)));
+    }
+    /** One-time move of <agentDir>/auth.json into the database. Lazy because
+     *  sealing needs an unlocked Secrets; retried until it succeeds (the flag is
+     *  set only then, and #put is an idempotent upsert). The file is renamed,
+     *  never deleted: auth.json.imported is the operator's receipt and way back. */
+    #ensureImported() {
+        if (this.#imported)
+            return;
+        const path = join(this.agentDir, "auth.json");
+        if (existsSync(path)) {
+            let parsed;
+            try {
+                parsed = JSON.parse(readFileSync(path, "utf8"));
+            }
+            catch (err) {
+                throw new Error(`${path} exists but is not valid JSON — fix or move it: ${String(err)}`, {
+                    cause: err,
+                });
+            }
+            if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+                throw new Error(`${path} exists but is not an object — fix or move it`);
+            }
+            const entries = Object.entries(parsed);
+            for (const [providerId, credential] of entries)
+                this.#put(providerId, credential);
+            renameSync(path, `${path}.imported`);
+            log.info(`imported ${entries.length} provider credential(s) from ${path}, renamed to auth.json.imported`);
+        }
+        this.#sweepModelsJson();
+        this.#imported = true;
+    }
+    /**
+     * models.json apiKeys are secrets in a file that should be pure structure
+     * (it is what a config repo syncs between hosts). Literal keys move into the
+     * database; `!command` and `$ENV` references are already not plaintext and
+     * stay — the SDK resolves those forms itself, and a sealed copy of a
+     * reference would freeze its meaning. The pre-sweep file is kept whole as
+     * models.json.imported: keys leave the file only with a receipt.
+     */
+    #sweepModelsJson() {
+        const path = join(this.agentDir, "models.json");
+        if (!existsSync(path))
+            return;
+        const raw = readFileSync(path, "utf8");
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch (err) {
+            // Not this sweep's failure to own: the SDK will refuse the same file
+            // loudly. Named here so "my key is still in the file" has an explanation.
+            log.warn(`${path} is not valid JSON — API keys not swept: ${String(err)}`);
+            return;
+        }
+        const providers = typeof parsed === "object" && parsed !== null
+            ? parsed.providers
+            : undefined;
+        if (!providers)
+            return;
+        const moved = [];
+        const shadowed = [];
+        for (const [providerId, provider] of Object.entries(providers)) {
+            const key = provider.apiKey;
+            // Literals only: `!cmd` runs a command, `$` marks env expansion (`$$`
+            // escapes a literal dollar — rare enough to leave in place).
+            if (typeof key !== "string" || !key || key.startsWith("!") || key.includes("$"))
+                continue;
+            if (this.#get(providerId)) {
+                // A stored credential short-circuits resolution, so this file copy was
+                // already dead — removed, not imported, and the receipt keeps it.
+                shadowed.push(providerId);
+            }
+            else {
+                this.#put(providerId, { type: "api_key", key });
+                moved.push(providerId);
+            }
+            delete provider.apiKey;
+        }
+        if (moved.length === 0 && shadowed.length === 0)
+            return;
+        writeFileSync(`${path}.imported`, raw, { mode: 0o600 });
+        writeFileSync(path, `${JSON.stringify(parsed, null, 2)}\n`);
+        if (moved.length)
+            log.info(`moved ${moved.length} literal API key(s) from models.json into pier.db: ${moved.join(", ")}`);
+        if (shadowed.length)
+            log.info(`removed ${shadowed.length} shadowed models.json API key(s) (a stored credential already wins): ${shadowed.join(", ")}`);
+        log.info(`pre-sweep models.json kept as ${path}.imported`);
+    }
+}

package/dist/agent/events.js

@@ -0,0 +1,253 @@
+// Pure Pi-event → SessionEventPayload translation. Structurally typed on
+// purpose: no @earendil-works/pi-* imports, so it stays unit-testable without Pi
+// and Pi types never leak past the seam. The golden-table test in
+// events.test.ts is the mapping's spec; extend types.ts before adding events.
+export function textOf(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter((p) => p.type === "text" && typeof p.text === "string")
+        .map((p) => p.text)
+        .join("");
+}
+function imageParts(m) {
+    return Array.isArray(m.content) ? m.content.filter((p) => p.type === "image") : [];
+}
+/** Renderable text of a message, with an image marker (IM can't show them). */
+function displayText(m) {
+    const text = textOf(m.content);
+    const images = imageParts(m).length;
+    if (!images)
+        return text;
+    return `${text}${text ? " " : ""}[${images} image${images > 1 ? "s" : ""}]`;
+}
+function systemOrigin(message) {
+    if (message.role !== "custom" || message.customType !== "pier.system-input")
+        return null;
+    const value = message.details;
+    if (!value || typeof value !== "object")
+        return null;
+    const origin = value;
+    if (typeof origin.taskId !== "string" ||
+        typeof origin.runId !== "string" ||
+        (origin.sourceSessionId !== null && typeof origin.sourceSessionId !== "string"))
+        return null;
+    if (origin.kind === "task-delegation" || origin.kind === "task-callback") {
+        return origin;
+    }
+    if (origin.kind === "task-message" &&
+        typeof origin.messageId === "string" &&
+        (origin.messageKind === "steer" || origin.messageKind === "follow_up" ||
+            origin.messageKind === "progress" || origin.messageKind === "decision" || origin.messageKind === "reply"))
+        return origin;
+    return null;
+}
+/**
+ * Bytes of the ordinal-th transcript image. Walks user/assistant messages in
+ * the same order toChatTurns numbers them — the two must not drift.
+ */
+export function imageAt(messages, ordinal) {
+    let n = 0;
+    for (const m of messages) {
+        if (m.role !== "user" && m.role !== "assistant")
+            continue;
+        for (const p of imageParts(m)) {
+            if (n++ !== ordinal)
+                continue;
+            return p.data ? { data: p.data, mimeType: p.mimeType ?? "image/png" } : undefined;
+        }
+    }
+    return undefined;
+}
+function lastAssistant(messages) {
+    if (!messages)
+        return undefined;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i]?.role === "assistant")
+            return messages[i];
+    }
+    return undefined;
+}
+/**
+ * Completion metadata for the assistant message at `index` (bubble hover
+ * hints). `completedAt` defaults to the message's own timestamp — Pi stamps
+ * that at stream start, so callers with a real clock (live turn-end) pass
+ * their own; history accepts the approximation.
+ *
+ * `tokens` is the context size at that point, not a sum: each assistant
+ * message's `totalTokens` already covers the whole request (prompt + cache +
+ * output), so adding them up double-counts the context on every turn. Pi
+ * itself reads context usage off the last assistant message the same way.
+ */
+export function turnMetaAt(messages, index, completedAt) {
+    const m = messages[index];
+    if (m?.role !== "assistant" || typeof m.timestamp !== "number")
+        return undefined;
+    const end = completedAt ?? m.timestamp;
+    let started = end;
+    for (let i = index - 1; i >= 0; i--) {
+        const t = messages[i];
+        if (t && (t.role === "user" || systemOrigin(t) !== null) && typeof t.timestamp === "number") {
+            started = t.timestamp;
+            break;
+        }
+    }
+    let tokens = 0;
+    for (let i = index; i >= 0; i--) {
+        const t = messages[i];
+        if (t?.role === "assistant" && t.usage?.totalTokens) {
+            tokens = t.usage.totalTokens;
+            break;
+        }
+    }
+    return { completedAt: end, durationMs: Math.max(0, end - started), tokens };
+}
+/**
+ * Rebuild the renderable transcript: user/assistant turns plus the activity
+ * (thinking + tool calls) that preceded each assistant answer. This is what
+ * makes a page reload show the real step counts instead of restarting at zero.
+ */
+export function toChatTurns(messages) {
+    const turns = [];
+    let steps = []; // activity seen since the last emitted turn
+    const pendingTools = new Map();
+    let ordinal = 0; // must advance exactly like imageAt() walks the messages
+    const flush = (role, text, meta, origin, images) => {
+        const turn = { role, text };
+        if (meta)
+            turn.meta = meta;
+        if (origin)
+            turn.origin = origin;
+        if (steps.length) {
+            turn.steps = steps;
+            steps = [];
+        }
+        if (images?.length)
+            turn.images = images;
+        turns.push(turn);
+    };
+    for (const [i, m] of messages.entries()) {
+        if (m.role === "toolResult") {
+            const step = pendingTools.get(m.toolCallId ?? "");
+            if (step) {
+                step.output = textOf(m.content);
+                step.isError = m.isError ?? false;
+                pendingTools.delete(m.toolCallId ?? "");
+            }
+            continue;
+        }
+        const origin = systemOrigin(m);
+        if (origin) {
+            const text = displayText(m);
+            if (text)
+                flush("system", text, undefined, origin);
+            continue;
+        }
+        if (m.role !== "user" && m.role !== "assistant")
+            continue;
+        if (m.role === "assistant" && Array.isArray(m.content)) {
+            for (const part of m.content) {
+                if (part.type === "thinking" && part.thinking) {
+                    steps.push({ kind: "thinking", text: part.thinking });
+                }
+                else if (part.type === "toolCall") {
+                    const step = {
+                        kind: "tool",
+                        id: part.id,
+                        toolName: part.name ?? "",
+                        args: part.arguments,
+                    };
+                    steps.push(step);
+                    if (part.id)
+                        pendingTools.set(part.id, step);
+                }
+            }
+        }
+        // Refs, not bytes: the web fetches each image from its own route.
+        const images = imageParts(m).map((p) => ({
+            mimeType: p.mimeType ?? "image/png",
+            ordinal: ordinal++,
+        }));
+        const text = textOf(m.content);
+        // step-only assistant messages keep buffering activity
+        if (!text && !images.length)
+            continue;
+        flush(m.role, text, m.role === "assistant" ? turnMetaAt(messages, i) : undefined, undefined, images);
+    }
+    // Activity with no answer after it (aborted run) still belongs on the page.
+    if (steps.length)
+        flush("assistant", "");
+    return turns;
+}
+/** Translate one Pi session event into zero or more Pier payloads. */
+export function toSessionEvents(e) {
+    switch (e.type) {
+        case "agent_start":
+            return [{ type: "state", state: "streaming" }, { type: "turn-start" }];
+        case "agent_end": {
+            const final = lastAssistant(e.messages);
+            const out = [
+                { type: "turn-end", text: textOf(final?.content) },
+            ];
+            if (final?.stopReason === "error") {
+                out.push({ type: "error", message: final.errorMessage ?? "unknown agent error" });
+            }
+            out.push({ type: "state", state: "idle" });
+            return out;
+        }
+        case "message_start": {
+            // Pi emits this for every message entering the context; the user ones are
+            // what a client can't know about (queued/steered messages, IM traffic).
+            const m = e.message;
+            if (!m)
+                return [];
+            const origin = systemOrigin(m);
+            const text = displayText(m);
+            if (origin)
+                return text ? [{ type: "system-input", text, origin }] : [];
+            if (m.role !== "user")
+                return [];
+            return text ? [{ type: "user-message", text }] : [];
+        }
+        case "message_update": {
+            const ame = e.assistantMessageEvent;
+            if (ame?.type === "text_delta" && ame.delta) {
+                return [{ type: "text-delta", text: ame.delta }];
+            }
+            if (ame?.type === "thinking_delta" && ame.delta) {
+                return [{ type: "thinking-delta", text: ame.delta }];
+            }
+            return [];
+        }
+        case "tool_execution_start":
+            return [
+                {
+                    type: "tool-start",
+                    toolCallId: e.toolCallId ?? "",
+                    toolName: e.toolName ?? "",
+                    args: e.args,
+                },
+            ];
+        case "queue_update":
+            return [
+                {
+                    type: "queue-state",
+                    steering: [...(e.steering ?? [])],
+                    followUp: [...(e.followUp ?? [])],
+                },
+            ];
+        case "tool_execution_end":
+            return [
+                {
+                    type: "tool-end",
+                    toolCallId: e.toolCallId ?? "",
+                    isError: e.isError ?? false,
+                    output: textOf(e.result?.content),
+                },
+            ];
+        default:
+            return [];
+    }
+}

package/dist/agent/models.js

@@ -0,0 +1,15 @@
+// Pure model-list curation, unit-testable without Pi. The raw registry
+// returns every catalog entry per authed provider (legacy generations, dated
+// aliases, -latest aliases); the picker wants the common working set.
+export function curateModels(models) {
+    const ids = new Set(models.map((m) => `${m.provider}/${m.id}`));
+    return models
+        .filter((m) => m.reasoning) // agent work wants reasoning-capable models
+        .filter((m) => !m.id.endsWith("-latest")) // alias noise
+        .filter((m) => {
+        // Drop dated variants when the undated alias is also in the catalog.
+        const undated = m.id.replace(/-\d{8}$/, "");
+        return undated === m.id || !ids.has(`${m.provider}/${undated}`);
+    })
+        .map(({ provider, id }) => ({ provider, id }));
+}