@timqi/pier 0.0.21 → 0.0.23

package/README.md

@@ -17,7 +17,6 @@ versioned from `0.0.1` on — earlier databases are not migrated. Read
 ## Requirements
 
 - Node 24 or newer (`node:sqlite` is used unflagged)
-- Linux: Python 3, `make` and a C/C++ compiler for `node-pty`
 - A provider account (Anthropic, OpenAI, …) — configure its API key or OAuth
   login from Console → Settings → Models after signing in
 - A user-writable global npm prefix if `pier update` should update a service
@@ -61,8 +60,8 @@ an existing Pi setup:
 PI_CODING_AGENT_DIR="$HOME/.pi/agent" pier serve
 ```
 
-Pier exports that variable for the SDK, so anything it starts inherits it — a
-shell in the Web Terminal included. A second Pier launched from there with its
+Pier exports that variable for the SDK, so anything it starts inherits it — an
+agent's shell included. A second Pier launched from there with its
 own `PIER_HOME` derives its own agent directory rather than adopting the first
 one's; setting `PI_CODING_AGENT_DIR` again on that command line still wins.
 
@@ -92,8 +91,8 @@ Console → Settings is the normal setup path:
   Below it, the same tab switches on the command-line tools Pier manages —
   `rtk`, `rg`, `fd`, `wt`, `jq`, or a tool of your own written as a
   [ubix](https://github.com/timqi/ubix) block. A switch installs the binary
-  into `~/.pier/tools/bin`, which is first on the PATH every session, task and
-  terminal inherits, and a task you can read keeps them current.
+  into `~/.pier/tools/bin`, which is first on the PATH every session and task
+  inherits, and a task you can read keeps them current.
 
 On first credential access, Pier imports an existing `auth.json` into its sealed
 store and renames the source to `auth.json.imported`. Literal provider keys left

package/dist/agent/config-sync.js

@@ -1,54 +1,98 @@
 // Credential-blind projection of the portable agent configuration.
-const MODEL_KEYS = ["id", "name", "reasoning", "input", "cost", "contextWindow", "maxTokens", "api"];
-const COST_KEYS = ["input", "output", "cacheRead", "cacheWrite"];
+/** Never leaves the instance, at any depth of a models.json provider: the
+ *  credentials, and the endpoint they authenticate against — a sharing link is
+ *  public. Every other field is metadata Pi's own schema already validates, so
+ *  it travels as-is instead of through a field list chasing Pi's versions. */
+const PRIVATE_KEYS = ["apiKey", "headers", "baseUrl"];
+/** The catalog is the part of a provider sync owns outright: absent on the
+ *  source means deleted here, while a field the source never states stays. */
+const CATALOG_KEYS = ["models", "modelOverrides"];
+/** Dropped strings shorter than this ("", "Bearer") collide with legitimate
+ *  metadata; a credential or an endpoint does not. */
+const SECRET_CHARS = 8;
+const asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
 function record(value, where) {
-    if (!value || typeof value !== "object" || Array.isArray(value) ||
-        ![Object.prototype, null].includes(Object.getPrototypeOf(value))) {
+    const plain = asRecord(value);
+    if (!plain || ![Object.prototype, null].includes(Object.getPrototypeOf(plain))) {
         throw new Error(`${where} must be an object`);
     }
-    return value;
+    return plain;
 }
 function only(value, keys, where) {
     if (Object.keys(value).some((key) => !keys.includes(key))) {
         throw new Error(`${where} contains unsupported fields`);
     }
 }
-function modelDefinition(value) {
-    const model = record(value, "model");
-    only(model, MODEL_KEYS, "model");
-    if (typeof model.id !== "string" || !model.id.trim() || model.id !== model.id.trim()) {
-        throw new Error("model id must be a non-empty trimmed string");
-    }
-    if (model.name !== undefined && (typeof model.name !== "string" || !model.name.length))
-        throw new Error("model name must be a non-empty string");
-    if (model.reasoning !== undefined && typeof model.reasoning !== "boolean") {
-        throw new Error("model reasoning must be a boolean");
-    }
-    if (model.api !== undefined && (typeof model.api !== "string" || !/^[a-z][a-z0-9-]*$/.test(model.api))) {
-        throw new Error("model api must be a protocol name");
+/** Every string in a JSON value, so one containment test covers the whole
+ *  projection however deeply Pi nests a future field. */
+function strings(value, found = []) {
+    const nested = asRecord(value);
+    if (typeof value === "string")
+        found.push(value);
+    else if (Array.isArray(value))
+        for (const entry of value)
+            strings(entry, found);
+    else if (nested)
+        for (const entry of Object.values(nested))
+            strings(entry, found);
+    return found;
+}
+/** Deep copy of JSON-only data; the private fields are dropped and handed to
+ *  `onPrivate` — collected on the way out, refused on the way in. */
+function project(value, where, onPrivate) {
+    if (value === null || ["string", "boolean", "number"].includes(typeof value))
+        return value;
+    if (Array.isArray(value))
+        return value.map((entry) => project(entry, where, onPrivate));
+    return Object.fromEntries(Object.entries(record(value, where)).flatMap(([key, entry]) => {
+        if (PRIVATE_KEYS.includes(key)) {
+            onPrivate(key, entry);
+            return [];
+        }
+        return [[key, project(entry, `${where} ${key}`, onPrivate)]];
+    }));
+}
+/** The shape both sides must agree on: a provider id that cannot address
+ *  anything but its own record, and a catalog addressable by model id. */
+function portable(id, value, onPrivate) {
+    if (id.length > 100 || !/^[a-z0-9][a-z0-9._-]*$/.test(id) || ["constructor", "prototype"].includes(id)) {
+        throw new Error("invalid snapshot provider id");
     }
-    if (model.input !== undefined && (!Array.isArray(model.input) || !model.input.length ||
-        model.input.some((input) => input !== "text" && input !== "image") ||
-        new Set(model.input).size !== model.input.length)) {
-        throw new Error("model input must contain text or image without duplicates");
+    const provider = record(project(value, `provider ${id}`, onPrivate), `provider ${id}`);
+    const models = provider.models ?? [];
+    if (!Array.isArray(models))
+        throw new Error("models must be an array");
+    const ids = models.map((model) => record(model, "model").id);
+    if (ids.some((modelId) => typeof modelId !== "string" || !modelId.trim() || modelId !== modelId.trim())) {
+        throw new Error("model id must be a non-empty trimmed string");
     }
-    for (const key of ["contextWindow", "maxTokens"]) {
-        if (model[key] !== undefined && (typeof model[key] !== "number" || !Number.isSafeInteger(model[key]) || model[key] <= 0)) {
-            throw new Error(`model ${key} must be a positive integer`);
-        }
+    if (new Set(ids).size !== ids.length)
+        throw new Error("duplicate model ids");
+    const overrides = provider.modelOverrides ?? {};
+    for (const [overrideId, override] of Object.entries(record(overrides, "modelOverrides"))) {
+        record(override, `modelOverrides ${overrideId}`);
     }
-    if (model.cost !== undefined) {
-        const cost = record(model.cost, "model cost");
-        only(cost, COST_KEYS, "model cost");
-        for (const key of COST_KEYS) {
-            if (typeof cost[key] !== "number" || !Number.isFinite(cost[key]) || cost[key] < 0) {
-                throw new Error(`model cost ${key} must be a non-negative finite number`);
-            }
-        }
+    return provider;
+}
+/** Project disk metadata before validation, then fail closed if anything the
+ *  projection removed still appears in it: a deny list cannot foresee the field
+ *  Pi adds next, but it can refuse to publish a value it just dropped. */
+export function snapshotProviders(providers = {}) {
+    const dropped = [];
+    const shared = Object.fromEntries(Object.entries(providers).flatMap(([id, provider]) => {
+        const value = portable(id, provider, (_key, entry) => {
+            dropped.push(...strings(entry).filter((secret) => secret.length >= SECRET_CHARS));
+        });
+        return Object.keys(value).length ? [[id, value]] : [];
+    }));
+    const exported = strings(shared);
+    if (dropped.some((secret) => exported.some((value) => value.includes(secret)))) {
+        throw new Error("models.json repeats a credential or endpoint in a shared field; remove it before sharing");
     }
-    return structuredClone(model);
+    return shared;
 }
-/** Strict import boundary: unknown fields are rejected, never treated as masked secrets. */
+/** Strict import boundary: a source that states a private field is refused,
+ *  never trusted as a mask over the local one. */
 export function normalizeAgentSnapshot(raw) {
     const snapshot = record(raw, "agent snapshot");
     only(snapshot, ["files", "providers"], "agent snapshot");
@@ -59,65 +103,53 @@ export function normalizeAgentSnapshot(raw) {
             throw new Error(`${name} must be a string or null`);
         }
     }
-    const providers = Object.fromEntries(Object.entries(record(snapshot.providers, "snapshot providers")).map(([id, value]) => {
-        if (id.length > 100 || !/^[a-z0-9][a-z0-9._-]*$/.test(id) || ["constructor", "prototype"].includes(id)) {
-            throw new Error("invalid snapshot provider id");
-        }
-        const provider = record(value, "snapshot provider");
-        only(provider, ["models"], "snapshot provider");
-        if (!Array.isArray(provider.models))
-            throw new Error("snapshot provider models must be an array");
-        const models = provider.models.map(modelDefinition);
-        if (new Set(models.map((model) => model.id)).size !== models.length)
-            throw new Error("duplicate model ids");
-        return [id, { models }];
-    }));
-    return { files: { "SYSTEM.md": files["SYSTEM.md"], "AGENTS.md": files["AGENTS.md"] }, providers };
+    const providers = Object.fromEntries(Object.entries(record(snapshot.providers, "snapshot providers"))
+        .map(([id, provider]) => [id, portable(id, provider, (key) => {
+            throw new Error(`snapshot provider must not carry ${key}`);
+        })]));
+    return {
+        files: { "SYSTEM.md": files["SYSTEM.md"], "AGENTS.md": files["AGENTS.md"] },
+        providers,
+    };
 }
-/** Project disk metadata before validation, so no nested transport object can escape. */
-export function snapshotProviders(providers = {}) {
-    return Object.fromEntries(Object.entries(providers).flatMap(([id, provider]) => {
-        if (provider.models === undefined)
-            return [];
-        if (!Array.isArray(provider.models))
-            throw new Error("models.json models must be an array");
-        const models = provider.models.map((value) => {
-            const source = record(value, "models.json model");
-            const model = Object.fromEntries(MODEL_KEYS.flatMap((key) => source[key] === undefined ? [] : [[key, source[key]]]));
-            if (source.cost !== undefined) {
-                const cost = record(source.cost, "models.json model cost");
-                model.cost = Object.fromEntries(COST_KEYS.flatMap((key) => cost[key] === undefined ? [] : [[key, cost[key]]]));
-            }
-            return modelDefinition(model);
-        });
-        return [[id, { models }]];
-    }));
+/** A model or override arrives whole; only the local private fields survive it. */
+function withLocalPrivate(incoming, local) {
+    const merged = { ...incoming };
+    for (const key of PRIVATE_KEYS)
+        if (local && Object.hasOwn(local, key))
+            merged[key] = local[key];
+    return merged;
 }
-/** Replace only portable fields, retaining excluded fields for matching local model ids. */
+const modelsById = (models) => new Map((Array.isArray(models) ? models : []).flatMap((model) => {
+    const value = asRecord(model);
+    return value ? [[value.id, value]] : [];
+}));
+/** The source sets what it states and replaces the catalog; credentials and
+ *  endpoints stay local, matched by provider, model id and override id. */
 export function mergeSnapshotProviders(local = {}, incoming) {
-    const providers = structuredClone(local);
-    for (const [id, provider] of Object.entries(providers)) {
-        if (!Object.hasOwn(incoming, id)) {
-            delete provider.models;
-        }
-    }
-    for (const [id, { models }] of Object.entries(incoming)) {
-        if (!Object.hasOwn(local, id)) {
+    for (const id of Object.keys(incoming)) {
+        if (!Object.hasOwn(local, id))
             throw new Error(`provider ${id} must be configured locally before importing models`);
-        }
-        const provider = providers[id];
-        if (provider.models !== undefined && !Array.isArray(provider.models))
-            throw new Error("models.json models must be an array");
-        const existing = new Map((provider.models ?? []).map((value) => {
-            const model = record(value, "models.json model");
-            return [model.id, model];
-        }));
-        provider.models = models.map((model) => {
-            const retained = { ...existing.get(model.id) };
-            for (const key of MODEL_KEYS)
-                delete retained[key];
-            return { ...retained, ...model };
-        });
     }
-    return providers;
+    return Object.fromEntries(Object.entries(local).map(([id, provider]) => {
+        const current = record(provider, "models.json provider");
+        const source = incoming[id];
+        if (!source)
+            return [id, Object.fromEntries(Object.entries(current).filter(([key]) => !CATALOG_KEYS.includes(key)))];
+        // The catalog shapes are the ones normalizeAgentSnapshot already proved.
+        const merged = { ...current, ...structuredClone(source) };
+        for (const key of CATALOG_KEYS)
+            if (!Object.hasOwn(source, key))
+                delete merged[key];
+        if (merged.models !== undefined) {
+            const previous = modelsById(current.models);
+            merged.models = merged.models.map((model) => withLocalPrivate(model, previous.get(model.id)));
+        }
+        if (merged.modelOverrides !== undefined) {
+            const previous = asRecord(current.modelOverrides) ?? {};
+            merged.modelOverrides = Object.fromEntries(Object.entries(merged.modelOverrides)
+                .map(([key, override]) => [key, withLocalPrivate(override, asRecord(previous[key]))]));
+        }
+        return [id, merged];
+    }));
 }

package/dist/boards/boards.js

@@ -124,14 +124,18 @@ export async function listBoards(dir) {
     }
     // One board's manifest says nothing about the next one's, so the scan waits
     // once for all of them rather than once per board.
-    const boards = await Promise.all(entries.sort().map(async (slug) => {
+    const boards = await Promise.all(entries.map(async (slug) => {
         const manifest = await readManifest(dir, slug);
         if (!manifest)
             return null;
         const { title, description, sessions, public: isPublic, token } = manifest;
         return { slug, title, description, sessions, public: isPublic, token, updatedAt: await updatedAt(dir, slug) };
     }));
-    return boards.filter((board) => board !== null);
+    // Freshest first: the board someone just wrote is the one they came to see.
+    // Slug breaks ties so equal mtimes still list in a stable order.
+    return boards
+        .filter((board) => board !== null)
+        .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt) || a.slug.localeCompare(b.slug));
 }
 /** Containment, not normalization: the resolved realpath must sit inside the
  *  board's own site dir or nothing is served. */

package/dist/db.js

@@ -316,6 +316,13 @@ const MIGRATIONS = [
   CREATE INDEX task_runs_visible_time ON task_runs(queued_at DESC, id DESC)
     WHERE NOT (state = 'succeeded' AND json_extract(json, '$.matched') IS 0);
   `,
+    // 18 — opening a session lists every run it delegated, not the last hour's.
+    `
+  -- The run cards are the messages a session sent, so the transcript wants
+  -- all of them: the query is by the delegating session, which lived only in
+  -- the JSON — without this every session open was a full scan of task_runs.
+  CREATE INDEX task_runs_invoked_by ON task_runs(json_extract(json, '$.invokedBySessionId'), queued_at DESC);
+  `,
 ];
 /**
  * Several writes as one, or none. `BEGIN IMMEDIATE` because every writer here
@@ -361,9 +368,11 @@ let shared;
  * defaults to it; a test passes `openDb(":memory:")` instead.
  */
 export const pierDb = () => (shared ??= openDb(PIER_DB));
-/** A release-level restore point, taken while the service is stopped even when
- * the release has no schema migration. The previous complete copies stay put if
- * writing this one fails.
+/** A release-level restore point, taken for every release even when it has no
+ * schema migration. The previous complete copies stay put if writing this one
+ * fails, and the service may be running while it is written: `copyDatabase`
+ * reads through a read-only connection, so what it writes is one consistent
+ * snapshot of a live database rather than a torn `cp`.
  *
  * `version` is the Pier that produced this database, not the one being
  * installed: the updater runs this from the tree it is about to replace, and

package/dist/main.js

@@ -42,14 +42,13 @@ import { registerConfigShareRoute, registerConfigSyncRoutes } from "./web/config
 import { PushStore, registerPushRoutes } from "./web/push.js";
 import { SessionStateStore } from "./web/session-state.js";
 import { createServer } from "./web/server.js";
-import { attachTerminal } from "./web/terminal.js";
 const log = logger("pier");
 // Pier owns the Pi runtime dir. Set before any SDK call resolves a path, so
 // everything Pi derives from its agent dir (auth.json, models.json, sessions,
 // bin) lands under PIER_HOME instead of ~/.pi.
 //
 // An operator override wins — but only a human's. Everything Pier spawns (the
-// Web Terminal, the agent's own shell) inherits this variable, so a second
+// agent's own shell, task sessions) inherits this variable, so a second
 // Pier started from inside the first with its own PIER_HOME would adopt the
 // first one's agent dir and write its sessions, SYSTEM.md and models.json
 // there: two instances sharing a directory neither was told to share, and
@@ -58,8 +57,8 @@ const log = logger("pier");
 // again from this instance's own PIER_HOME.
 process.env.PI_CODING_AGENT_DIR = resolveAgentDir(process.env);
 process.env.PIER_AGENT_DIR = process.env.PI_CODING_AGENT_DIR;
-// Ahead of everything Pier spawns — sessions, tasks, the Web Terminal all
-// inherit this process's env. A tool switched on in the Console is Pier's
+// Ahead of everything Pier spawns — sessions and tasks all inherit this
+// process's env. A tool switched on in the Console is Pier's
 // copy at Pier's version, so it goes first, not last.
 prependPath(process.env);
 // First, and explicitly: every store below shares this one connection, and a
@@ -205,8 +204,9 @@ await configurationSync.reconcile();
 tasks.start();
 readyForConfigReload = true;
 void secrets.unlock().then(startChannels, (err) => log.error("secrets locked — channels not started; unlock from Console → Settings → Security, or repair master.key", err));
-// Replacing Pier is systemd's job, not this process's: the oneshot unit stops
-// the service, snapshots the database, installs and starts it again. Without
+// Replacing Pier is systemd's job, not this process's: the oneshot unit
+// snapshots the database, installs, then stops the service and starts it again
+// on the new version — in that order, so only the last two are downtime. Without
 // that unit there is nothing to hand the work to, and the Console says so
 // instead of offering a button that cannot work.
 const updates = new UpdateCheck();
@@ -247,8 +247,14 @@ const takeWorkAgain = (why) => {
 };
 /** How long the handover has to actually stop us. `systemctl start --no-block`
  *  returns when the job is *queued*, so "started" is not proof of anything;
- *  the real outcome is a SIGTERM a second or two later. */
-const HANDOVER_GRACE_MS = 60_000;
+ *  the real outcome is a SIGTERM — but only after the updater has snapshotted
+ *  the database and installed the new version, which is a registry download on
+ *  someone else's network — ten seconds on a good day, minutes on a bad one.
+ *  So this waits far longer than the stop itself needs, because reopening the
+ *  gate mid-install would take work we are about to be SIGTERM'd out of, and
+ *  still short enough that a handover which never happens does not refuse
+ *  messages all afternoon. */
+const HANDOVER_GRACE_MS = 5 * 60_000;
 const handOverToUpdater = async () => {
     // One handover at a time, and never on top of a restart: the Console button,
     // the auto-update tick and SIGUSR2 would otherwise drain the same Pier
@@ -389,11 +395,6 @@ const server = serve({ fetch: app.fetch, port, hostname }, () => {
         log.info(`agent dir ${process.env.PI_CODING_AGENT_DIR} (PI_CODING_AGENT_DIR)`);
     }
 });
-// The one WebSocket surface (see web/terminal.ts); `serve` above builds a
-// plain node:http server, which is the only shape with an upgrade event.
-const terminals = attachTerminal(server, auth, {
-    initCommand: () => settings.get().terminalInitCommand,
-});
 // A crash and a clean stop must be distinguishable after the fact, and both
 // left nothing behind before this.
 process.on("uncaughtException", (err) => {
@@ -416,7 +417,6 @@ const shutdown = (stopTasks = true) => {
     // `systemctl restart` into a 90-second wait for SIGKILL.
     setTimeout(() => process.exit(0), 3000).unref();
     stopEviction();
-    terminals.close(); // no shell outlives the workbench
     // The drain path leaves task runs alone: aborting them here would record
     // them cancelled and race their callbacks against dying channels, when the
     // boot-time interrupted marking is the recovery that was promised.

package/dist/service.js

@@ -104,8 +104,14 @@ function legacyOptions(home) {
         ...(pierHome ? { pierHome } : {}),
     };
 }
-/** A separate cgroup stops Pier, takes a consistent backup, updates the exact
- * npm installation recorded at install time, and always starts Pier again. */
+/** A separate cgroup snapshots the database, updates the exact npm
+ * installation recorded at install time, and only then restarts Pier.
+ *
+ * Both slow steps run while the service is still up, so the downtime is one
+ * stop and one start rather than the ~10s an install takes. The snapshot is
+ * consistent on a live database — `VACUUM INTO` off a read-only connection
+ * (db.ts) — and it still runs from the tree npm is about to replace, so the
+ * copy carries the version whose schema it pairs with. */
 export function renderUpdateUnit(options) {
     const { execPath, npmPath, entry, pierHome, shellPath } = options;
     const cli = join(dirname(entry), "cli.js");
@@ -120,12 +126,16 @@ Type=oneshot
 # resolves node from PATH, and systemd's minimal PATH has no fnm/nvm node —
 # the install then dies with "node: not found" with the tree half written.
 ${environment("PATH", pathEnv(execPath, shellPath))}
-${pierHome ? `${environment("PIER_HOME", pierHome)}\n` : ""}ExecStart=systemctl --user stop ${UNIT_NAME}
-ExecStart=${quote(execPath, true)} ${quote(cli, true)} backup
+${pierHome ? `${environment("PIER_HOME", pierHome)}\n` : ""}ExecStart=${quote(execPath, true)} ${quote(cli, true)} backup
 # npm runs under the recorded node: its shebang needs a node on PATH too.
 ExecStart=${quote(execPath, true)} ${quote(npmPath, true)} install -g @timqi/pier@latest
-# ExecStopPost runs on success and failure, so a failed backup or npm install
-# does not leave the previously working service stopped.
+# Last, because everything above it is downtime the running Pier does not owe
+# anyone. A failed backup or install never gets here: the service stays up on
+# the code it already loaded.
+ExecStart=systemctl --user stop ${UNIT_NAME}
+# ExecStopPost runs on success and failure. After a failed step above, Pier was
+# never stopped and this is a no-op; it is here for the window that is still
+# fatal — the unit dying between that stop and the start of the new version.
 ExecStopPost=systemctl --user start ${UNIT_NAME}
 `;
 }
@@ -300,7 +310,7 @@ export function startUpdate(options) {
     if (!run(["systemctl", "--user", "start", "--no-block", UPDATE_UNIT_NAME]))
         return "failed";
     say(`updating in the background — follow it with: journalctl --user -u ${UPDATE_UNIT_NAME} -f`);
-    say(`Pier stops, snapshots the database into db/backups/, installs, then starts again.`);
+    say(`Pier snapshots the database into db/backups/ and installs while still up, then stops and starts on the new version.`);
     return "started";
 }
 export function uninstall(home = homedir(), say = console.log, exec) {

package/dist/settings.js

@@ -71,26 +71,6 @@ export function normalizeModelMenu(raw) {
     }
     return menu;
 }
-/**
- * One line, typed into a shell. Same reject-don't-repair contract: a command
- * silently truncated at a newline would run half of what the operator wrote,
- * in every project shell, with no sign of what was dropped.
- */
-export function normalizeTerminalInitCommand(raw) {
-    if (typeof raw !== "string")
-        return null;
-    const text = raw.trim();
-    if (!text)
-        return "";
-    if (text.length > 500)
-        return null;
-    // A tty reads these as keys, not text: an embedded newline is a second
-    // command nobody would see in the field it was typed in.
-    for (const ch of text)
-        if (ch < " " || ch === "\u007f")
-            return null;
-    return text;
-}
 /**
  * Shape only — an unknown name is not an error here. This file must not know
  * what Pier bundles (that catalog is code, and importing it would drag the Pi
@@ -131,7 +111,6 @@ export class SettingsStore {
             publicUrl: this.#value("publicUrl") ?? "",
             modelMenu: this.#json("modelMenu", normalizeModelMenu, "a valid menu") ?? [],
             autoUpdate: this.#value("autoUpdate") === "1",
-            terminalInitCommand: this.#value("terminalInitCommand") ?? "",
             extensions: this.#json("extensions", normalizeExtensions, "a list of names") ?? [],
             tools: this.#json("tools", normalizeTools, "a list of names") ?? [],
             customTools: this.#json("customTools", normalizeCustomTools, "a list of {name, spec}") ?? [],
@@ -170,11 +149,6 @@ export class SettingsStore {
         this.#set("modelMenu", JSON.stringify(menu));
         return this.get();
     }
-    /** Same contract again: hand this `normalizeTerminalInitCommand`'s output. */
-    setTerminalInitCommand(command) {
-        this.#set("terminalInitCommand", command);
-        return this.get();
-    }
     setAutoUpdate(on) {
         this.#set("autoUpdate", on ? "1" : "0");
         return this.get();

package/dist/tasks/callbacks.js

@@ -53,7 +53,7 @@ export class TaskCallbacks {
                     // one delivery, and the first one's name and model as the card's
                     // caption would attribute every other result to it. The text names
                     // each run; the card says nothing rather than something false.
-                    ...(runs.length === 1 ? { source: runSource(runs[0]) } : {}),
+                    ...(runs.length === 1 ? { source: runSource(runs[0]), state: runs[0].state } : {}),
                 },
             }),
             describe: (run) => `the result of "${run.context.definition.name}"`,

package/dist/tasks/definitions.js

@@ -247,6 +247,10 @@ export class TaskDefinitions {
         return this.router.stateOf(sessionId) !== undefined ||
             (await this.factory.find(sessionId)) !== undefined;
     }
+    /** A caller's own directory — what a relative or omitted cwd resolves against. */
+    async sessionCwd(sessionId) {
+        return (await this.factory.find(sessionId))?.cwd;
+    }
     /** The guard `ownerOf` exists for, on the three ways a definition changes. */
     assertOwner(task, by, what) {
         const owner = ownerOf(task);

package/dist/tasks/groups.js

@@ -27,7 +27,8 @@ export class TaskGroups {
             save: (group) => { this.store.saveGroup(group); },
             changed,
             // A group names itself in the origin where a run names its run id, so the
-            // engine's transcript proof works unchanged.
+            // engine's transcript proof works unchanged; the console's run route
+            // resolves that id to the group's members (web/ui/task-runs.ts).
             input: (groups) => ({
                 text: this.text(groups[0]),
                 origin: { kind: "task-callback", taskId: groups[0].id, runId: groups[0].id, sourceSessionId: null },

package/dist/tasks/service.js

@@ -18,6 +18,15 @@ import { TaskStore } from "./store.js";
 import { handleTaskTool } from "./tool.js";
 import { isTerminal } from "./types.js";
 const log = logger("tasks");
+/** The text a run was given, as the operator wrote it: a resume's follow-up,
+ *  else the action's own prompt or script. Not `renderedPrompt` — that is the
+ *  preamble and the input wrapper, which the delegating session did not send. */
+const runPrompt = (run) => {
+    if (run.context.resumePrompt)
+        return run.context.resumePrompt;
+    const action = run.context.definition.action;
+    return action.type === "agent" ? action.prompt : action.type === "bash" ? action.script : null;
+};
 export class TaskService {
     store;
     factory;
@@ -195,11 +204,11 @@ export class TaskService {
     recentMessages(since) {
         return this.messages.recent(since);
     }
+    /** Every run this session delegated: the card is the message that started
+     *  it, and a message does not leave the transcript because the run ended. */
     backgroundRuns(sessionId) {
-        const cutoff = Date.now() - 60 * 60 * 1000;
-        return this.store.listRunsForSession(sessionId, 50)
-            .filter((run) => run.background && (!isTerminal(run.state) || run.queuedAt >= cutoff))
-            .slice(0, 20)
+        return this.store.listRunsForSession(sessionId, 200)
+            .filter((run) => run.background)
             .reverse()
             .map((run) => this.backgroundRun(run));
     }
@@ -364,6 +373,7 @@ export class TaskService {
             targetSessionId: run.targetSessionId,
             sessionMode: run.sessionMode,
             depth: run.depth,
+            prompt: runPrompt(run),
             queuedAt: run.queuedAt,
             startedAt: run.startedAt,
             finishedAt: run.finishedAt,