@timqi/pier 0.1.2 → 0.1.4

package/dist/tasks/runs.js

@@ -1,34 +1,22 @@
-// A definition plus an input becomes a queued run. The depth and per-root
-// limits are decided here because every caller enqueues through this one door.
+// A definition plus an input becomes a queued run; every caller enqueues
+// through this one door.
 import { logger } from "../log.js";
 import { newId } from "./definitions.js";
 const log = logger("tasks");
-const MAX_DEPTH = 2;
-const MAX_CHILDREN_PER_ROOT = 16;
 export class TaskRunQueue {
     store;
     callbacks;
-    getRun;
     execute;
     changed;
-    constructor(store, callbacks, getRun, execute, changed) {
+    constructor(store, callbacks, execute, changed) {
         this.store = store;
         this.callbacks = callbacks;
-        this.getRun = getRun;
         this.execute = execute;
         this.changed = changed;
     }
     /** Validate and persist only; callers may stage several runs in a transaction. */
     prepare(definition, input, source, parentRunId, provenance) {
         const id = newId();
-        const parent = parentRunId ? this.getRun(parentRunId) : null;
-        const depth = provenance.depth ?? (parent ? parent.depth + 1 : 0);
-        const rootRunId = provenance.rootRunId ?? parent?.rootRunId ?? id;
-        if (depth > MAX_DEPTH)
-            throw new Error(`subagent depth limit is ${MAX_DEPTH}`);
-        if (depth > 0 && this.store.listRunsByRoot(rootRunId, MAX_CHILDREN_PER_ROOT + 1).filter((run) => run.depth > 0).length >= MAX_CHILDREN_PER_ROOT) {
-            throw new Error(`subagent child limit is ${MAX_CHILDREN_PER_ROOT} per root run`);
-        }
         const invokedBySessionId = provenance.invokedBySessionId ?? null;
         const sourceSessionId = provenance.sourceSessionId ?? invokedBySessionId;
         const sessionMode = definition.action.type === "agent"
@@ -50,8 +38,6 @@ export class TaskRunQueue {
             taskRevision: definition.revision,
             parentRunId,
             groupId: provenance.groupId ?? null,
-            rootRunId,
-            depth,
             resumedFromRunId: provenance.resumedFromRunId ?? null,
             triggerSource: source,
             invokedBySessionId,
@@ -86,13 +72,12 @@ export class TaskRunQueue {
     /** Publish and execute only after all records this run relies on committed. */
     start(run) {
         this.changed(run);
-        const { id, depth, triggerSource: source } = run;
+        const { id, triggerSource: source } = run;
         const overlapped = run.skipReason === "overlap";
         const definition = run.context.definition;
         // Why a run exists is answerable only here: the row keeps the ids, not the
         // reason. A watch probe queues every interval, so it logs at debug.
-        const queued = `run ${id} ${run.state}: ${definition.name} via ${source}` +
-            `${overlapped ? " (overlapped)" : ""}${depth > 0 ? ` depth ${String(depth)}` : ""}`;
+        const queued = `run ${id} ${run.state}: ${definition.name} via ${source}${overlapped ? " (overlapped)" : ""}`;
         if (source === "watch" && !overlapped)
             log.debug(queued);
         else

package/dist/tasks/service.js

@@ -9,7 +9,7 @@ import { TaskExecution } from "./execution.js";
 import { TaskGroups } from "./groups.js";
 import { TaskMessenger } from "./messages.js";
 import { TaskRunQueue } from "./runs.js";
-import { handleTaskTool } from "./tool.js";
+import { handleTask } from "./operations.js";
 import { isTerminal } from "./types.js";
 const log = logger("tasks");
 /** Not `renderedPrompt`: that carries the preamble and input wrapper, which the
@@ -44,14 +44,13 @@ export class TaskService {
         this.hub = hub;
         this.instance = instance;
         const unreachable = (sessionId, what, why) => this.unreachable(sessionId, what, why);
-        this.messages = new TaskMessenger(store, router, hub, (runId, prompt, fromSessionId) => this.prepareResume(runId, prompt, { invokedBySessionId: fromSessionId, callbackSessionId: fromSessionId, background: true }), unreachable, (run) => this.runs.start(run));
+        this.messages = new TaskMessenger(store, router, hub, unreachable);
         this.definitions = new TaskDefinitions(store, factory, router, hub, instance?.systemActions);
         this.callbacks = new TaskCallbacks(store, router, (run) => this.changed(run), unreachable);
         this.groups = new TaskGroups(store, router, {
             getRun: (id) => this.getRun(id),
             cancel: (id) => { this.cancel(id); },
-            openDecisionId: (runId) => this.messages.openDecisionId(runId),
-            prepareMember: (taskId, groupId, callerSessionId, parentRunId) => this.prepareRun(taskId, null, "agent", parentRunId, {
+            prepareMember: (taskId, groupId, callerSessionId) => this.prepareRun(taskId, null, "agent", null, {
                 invokedBySessionId: callerSessionId,
                 sourceSessionId: callerSessionId,
                 callbackSessionId: null,
@@ -72,9 +71,8 @@ export class TaskService {
             cancel: (id) => { this.cancel(id); },
             settled: (run) => this.settled(run),
             changed: (run) => this.changed(run),
-            openDecisionId: (runId) => this.messages.openDecisionId(runId),
         });
-        this.runs = new TaskRunQueue(store, this.callbacks, (id) => this.getRun(id), (run) => this.execution.start(run), (run) => this.changed(run));
+        this.runs = new TaskRunQueue(store, this.callbacks, (run) => this.execution.start(run), (run) => this.changed(run));
     }
     start(tickMs = 1000) {
         if (this.timer)
@@ -147,7 +145,7 @@ export class TaskService {
     create(raw, creator = "http") {
         return this.definitions.create(raw, creator);
     }
-    /** `by` is how owning code says so; the routes and the tool have none (definitions.ts). */
+    /** `by` is how owning code says so; the routes and `pier task` have none (definitions.ts). */
     update(id, raw, by) {
         return this.definitions.update(id, raw, by);
     }
@@ -169,16 +167,13 @@ export class TaskService {
     }
     getRunView(id) {
         const run = this.getRun(id);
-        return { ...run, pendingDecisionId: this.openDecisionId(id),
+        return { ...run,
             groupCallbackState: run.groupId ? this.store.getGroup(run.groupId)?.callbackState ?? null : null };
     }
     listMessages(runId) {
         this.getRun(runId);
         return this.messages.list(runId);
     }
-    openDecisionId(runId) {
-        return this.messages.openDecisionId(runId);
-    }
     queryRuns(query = {}) {
         return this.store.queryRuns(query);
     }
@@ -227,7 +222,8 @@ export class TaskService {
             set.add(resolve);
         });
     }
-    /** Cascades: orphans must not outlive the delegation that wanted them. */
+    /** Cascades down a `task` action's chain: a child must not outlive the run
+     *  that waits on it. */
     cancel(id) {
         const run = this.getRun(id);
         for (const target of [run, ...this.descendants(run)]) {
@@ -242,23 +238,15 @@ export class TaskService {
     getGroup(id) {
         return this.groups.members(id);
     }
-    runGroup(definitions, join, callerSessionId, parentRunId, callbackSessionId, callbackMode) {
-        this.refusePaused(parentRunId);
-        return this.groups.runAll(definitions, join, callerSessionId, parentRunId, callbackSessionId, callbackMode);
+    runGroup(definitions, join, callerSessionId, callbackSessionId, callbackMode) {
+        this.refusePaused();
+        return this.groups.runAll(definitions, join, callerSessionId, callbackSessionId, callbackMode);
     }
     descendants(run) {
-        const byParent = new Map();
-        for (const member of this.store.listRunsByRoot(run.rootRunId, 500)) {
-            if (!member.parentRunId)
-                continue;
-            const siblings = byParent.get(member.parentRunId) ?? [];
-            siblings.push(member);
-            byParent.set(member.parentRunId, siblings);
-        }
         const collected = [];
         const queue = [run.id];
         while (queue.length > 0) {
-            for (const child of byParent.get(queue.shift()) ?? []) {
+            for (const child of this.store.listChildRuns(queue.shift())) {
                 collected.push(child);
                 queue.push(child.id);
             }
@@ -273,20 +261,7 @@ export class TaskService {
             throw new Error("terminal run cannot be steered; resume it instead");
         return this.messages.control(run, fromSessionId, mode, message);
     }
-    reply(messageId, fromSessionId, message) {
-        return this.messages.reply(messageId, fromSessionId, message);
-    }
     resume(id, message, provenance = {}) {
-        const { run, expired } = this.store.transact(() => ({
-            run: this.prepareResume(id, message, provenance),
-            expired: this.messages.expireDecisions(id, "superseded by a manual resume"),
-        }));
-        for (const message of expired)
-            this.messages.changed(message);
-        this.runs.start(run);
-        return run;
-    }
-    prepareResume(id, message, provenance) {
         this.refusePaused();
         const prior = this.getRun(id);
         if (!isTerminal(prior.state))
@@ -295,19 +270,20 @@ export class TaskService {
             throw new Error("only persisted Agent runs can be resumed");
         }
         const prompt = requiredString(message, "message");
-        return this.runs.prepare(prior.context.definition, null, "agent", null, {
+        const run = this.runs.prepare(prior.context.definition, null, "agent", null, {
             ...provenance,
             sourceSessionId: provenance.invokedBySessionId ?? prior.invokedBySessionId,
             targetSessionId: prior.targetSessionId,
             sessionMode: "reuse",
             resumedFromRunId: prior.id,
-            rootRunId: prior.rootRunId,
-            depth: prior.depth,
             resumePrompt: prompt,
         });
+        this.runs.start(run);
+        return run;
     }
-    tool(raw, callerSessionId) {
-        return handleTaskTool(this, this.definitions, this.store, this.messages, raw, callerSessionId);
+    /** What `pier task` asks, under the calling session's identity. */
+    handle(raw, callerSessionId) {
+        return handleTask(this, this.definitions, this.store, raw, callerSessionId);
     }
     /** An agent picks from names that exist right now, never from memory. */
     async models() {
@@ -375,7 +351,6 @@ export class TaskService {
             state: run.state,
             targetSessionId: run.targetSessionId,
             sessionMode: run.sessionMode,
-            depth: run.depth,
             prompt: runPrompt(run),
             queuedAt: run.queuedAt,
             startedAt: run.startedAt,

package/dist/tasks/store.js

@@ -104,16 +104,13 @@ export class TaskStore {
         }
         const limit = clamp(query.limit ?? 50, 200);
         const rows = this.db.prepare(`
-      SELECT r.json, g.callback_state AS group_callback_state,
-        (SELECT m.id FROM task_messages m WHERE m.run_id = r.id
-          AND m.state IN ('pending', 'delivered') AND json_extract(m.json, '$.kind') = 'decision'
-          ORDER BY m.created_at, m.id LIMIT 1) AS decision_id
+      SELECT r.json, g.callback_state AS group_callback_state
       FROM task_runs r LEFT JOIN task_groups g ON g.id = json_extract(r.json, '$.groupId')
       ${where.length ? `WHERE ${where.join(" AND ")}` : ""}
       ORDER BY r.queued_at DESC, r.id DESC LIMIT ?
     `).all(...params, limit + 1);
         const runs = rows.slice(0, limit).map((row) => ({
-            ...JSON.parse(row.json), pendingDecisionId: row.decision_id, groupCallbackState: row.group_callback_state,
+            ...JSON.parse(row.json), groupCallbackState: row.group_callback_state,
         }));
         const last = runs.at(-1);
         return {
@@ -134,12 +131,20 @@ export class TaskStore {
     `, since);
         return [...active, ...recent].sort((a, b) => b.queuedAt - a.queuedAt || b.id.localeCompare(a.id));
     }
-    listRunsByRoot(rootRunId, limit = 100) {
+    /** A `task` action's child runs; a cancel walks them. */
+    listChildRuns(parentRunId) {
         return this.#many(`
       SELECT json FROM task_runs
-      WHERE json_extract(json, '$.rootRunId') = ?
-      ORDER BY queued_at LIMIT ?
-    `, rootRunId, clamp(limit, 500));
+      WHERE json_extract(json, '$.parentRunId') = ?
+      ORDER BY queued_at LIMIT 500
+    `, parentRunId);
+    }
+    /** Someone waits on this run's result — its own callback or its group's — so
+     *  the run is one turn of its session and may not delegate (design 09). */
+    supervised(run) {
+        if (run.callbackSessionId !== null)
+            return true;
+        return run.groupId !== null && (this.getGroup(run.groupId)?.callbackSessionId ?? null) !== null;
     }
     countActiveRuns() {
         const row = this.sql("SELECT COUNT(*) AS n FROM task_runs WHERE state IN ('queued', 'running')").get();
@@ -239,13 +244,8 @@ export class TaskStore {
             run: row.run_json === null ? undefined : JSON.parse(row.run_json),
         }));
     }
-    /** Decisions are excluded: they have no timeout and stay answerable across
-     * restarts — a reply to a terminal run resumes it. */
     expirePendingMessages() {
-        return this.#many(`
-      SELECT json FROM task_messages
-      WHERE state = 'pending' AND json_extract(json, '$.kind') != 'decision'
-    `).map((message) => {
+        return this.#many("SELECT json FROM task_messages WHERE state = 'pending'").map((message) => {
             message.state = "expired";
             // "Confirmed", not "completed": the proof lives in a transcript this
             // layer cannot see.

package/dist/tools.js

@@ -5,6 +5,7 @@ import { execFile } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import { chmodSync, existsSync, mkdirSync, mkdtempSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { delimiter, join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { pierDb, transact } from "./db.js";
 import { logger } from "./log.js";
 import { pierPath, resolveAgentDir } from "./paths.js";
@@ -13,37 +14,34 @@ const log = logger("tools");
 const UBIX_LATEST = "https://api.github.com/repos/timqi/ubix/releases/latest";
 export const MANAGED = [
     {
-        kind: "extension",
         name: "rtk",
-        toml: `spec = "github:rtk-ai/rtk"`,
-        summary: "Compresses long bash output before it reaches the model. Ships as a " +
-            "command, and installs its own Pi extension into Pier's agent dir — " +
-            "refreshed on every update.",
-        // Write-if-changed inside rtk: re-running after an upgrade is the extension-update path.
-        provision: ["init", "-g", "--agent", "pi"],
-        deprovision: ["init", "--uninstall", "--agent", "pi", "--global"],
+        // The hooks register and unregister its Pi extension; `--auto-patch` keeps
+        // `rtk init` non-interactive and overwrites a stale copy, which is right
+        // because nothing else writes Pier's agent dir.
+        toml: `spec = "github:rtk-ai/rtk"\n` +
+            `post_install = ["rtk", "init", "-g", "--agent", "pi", "--auto-patch"]\n` +
+            `pre_remove = ["rtk", "init", "--uninstall", "--agent", "pi", "--global", "--auto-patch"]`,
+        summary: "Compresses long bash output before it reaches the model. Its install hook " +
+            "writes its own Pi extension (extensions/rtk.ts, listed under the local " +
+            "package) — refreshed on every update.",
     },
     {
-        kind: "tool",
         name: "rg",
         // `exe`: ubi looks for files named after the project, and ripgrep ships `rg`.
         toml: `spec = "github:BurntSushi/ripgrep"\nexe = "rg"`,
         summary: "ripgrep: searches a tree by content, fast enough to be the default.",
     },
     {
-        kind: "tool",
         name: "fd",
         toml: `spec = "github:sharkdp/fd"`,
         summary: "Finds files by name, respecting .gitignore — what `find` should feel like.",
     },
     {
-        kind: "tool",
         name: "wt",
         toml: `spec = "github:max-sixty/worktrunk"\nexe = "wt"`,
         summary: "worktrunk: git worktrees as one command — branch, switch, merge, clean up.",
     },
     {
-        kind: "tool",
         name: "jq",
         // No `exe`: jq publishes bare per-platform binaries, which ubi installs
         // under the tool's own name.
@@ -138,6 +136,22 @@ export function prependPath(env = process.env, bin = toolsBin()) {
     mkdirSync(bin, { recursive: true }); // a PATH entry that does not exist is a shell's problem
     env.PATH = current ? `${bin}${delimiter}${current}` : bin;
 }
+/** `pier` on an agent's PATH is this process's own cli — the same source, the
+ *  same loader (`tsx` in dev) — not whichever install `npm i -g` left behind.
+ *  Placed from this module, not argv[1]: `pier serve` enters through cli.*.
+ *  The one line naming the harness variable: the cli reads `PIER_SESSION_ID`
+ *  only, and an explicit one wins. */
+export function writePierShim(bin = toolsBin(), proc = process, cli = fileURLToPath(import.meta.url).replace(/tools(\.[cm]?[jt]s)$/, "cli$1")) {
+    const quote = (s) => `'${s.replaceAll("'", String.raw `'\''`)}'`;
+    const script = `#!/bin/sh\nexport PIER_SESSION_ID="\${PIER_SESSION_ID:-$PI_SESSION_ID}"\nexec ${[proc.execPath, ...proc.execArgv, cli].map(quote).join(" ")} "$@"\n`;
+    mkdirSync(bin, { recursive: true });
+    const path = join(bin, "pier");
+    const tmp = `${path}.${randomUUID()}`;
+    writeFileSync(tmp, script);
+    chmodSync(tmp, 0o755);
+    renameSync(tmp, path); // a shell mid-exec never sees a half-written file
+    return path;
+}
 /** Long enough that one Console page open spawns `ubix list` once, short
  *  enough that an install done outside Pier shows up while they look. */
 const LIST_TTL_MS = 3_000;
@@ -339,17 +353,14 @@ export function ubixConfigToml(tools, installDir) {
         lines.push("", `[tools.${tool.name}]`, tool.toml.trim());
     return `${lines.join("\n")}\n`;
 }
-/** clap's unknown-argument message, and ubix's own refusal on a command that
- *  takes no JSON. Nothing else counts as too old. */
-const refusesJson = (stderr) => /unexpected argument\s+'?--json|unrecognized (?:option|argument)\s+'?--json|`--json` is not supported/i
-    .test(stderr);
-/** Pier put that binary in `bin/`, so `sync` re-bootstraps rather than reports. */
-class UbixTooOld extends Error {
-}
+/** The first ubix that runs `post_install` / `pre_remove`. An older one parses
+ *  the keys as unknown and ignores them, so rtk would install without its
+ *  extension and nothing would say so. Release tags are `vYYYYMMDD-<sha>`. */
+const UBIX_MIN = "v20260910-61f07ae";
 /** A name in neither list is not an error: a row a future release drops must
  *  not stop the sync of everything else. */
 function rows(custom) {
-    return [...MANAGED, ...custom.map((tool) => ({ kind: "tool", summary: "", custom: true, ...tool }))];
+    return [...MANAGED, ...custom.map((tool) => ({ summary: "", custom: true, ...tool }))];
 }
 export function ubixAsset(tag, platform, arch) {
     const os = platform === "linux" || platform === "darwin" ? platform : null;
@@ -465,26 +476,11 @@ export class ManagedTools {
             return { entries: [], failed: false, summary: "no tools switched on" };
         }
         fence();
-        const ubix = await this.bootstrapUbix();
         const env = this.#env();
+        const ubix = await this.#current(await this.bootstrapUbix(), env);
         const entries = [];
-        // ubix cannot know that rtk must uninstall its own Pi extension *before*
-        // its binary goes; tools leaving the set undo their footprint first.
-        const kept = [];
-        for (const state of await this.#listing(ubix, env)) {
-            const leaving = all.find((tool) => tool.name === state.name);
-            if (!leaving?.deprovision || wanted.some((tool) => tool.name === state.name))
-                continue;
-            fence(); // a tool's own uninstall is a change to the machine
-            const error = await this.#provision(env, leaving, leaving.deprovision);
-            if (error) {
-                // Removing it now would orphan what deprovision failed to remove.
-                kept.push(leaving);
-                entries.push({ name: leaving.name, action: "kept", version: null, error });
-            }
-        }
         fence();
-        this.#writeConfig([...wanted, ...kept]);
+        this.#writeConfig(wanted);
         // `--prune` removes what the config no longer declares; `--wait` lets a
         // hand-typed `pier tools sync` converge behind the managed run.
         fence();
@@ -492,25 +488,19 @@ export class ManagedTools {
         for (const state of states) {
             if (wanted.some((tool) => tool.name === state.name))
                 continue;
-            if (entries.some((entry) => entry.name === state.name))
-                continue;
-            // A failure to remove is as much a failure as one to install.
+            // A failure to remove (a `pre_remove` hook included) is as much a failure as one to install.
             entries.push({ name: state.name, action: state.action ?? "removed", version: null, error: state.error });
         }
         for (const tool of wanted) {
             const state = states.find((s) => s.name === tool.name);
-            const entry = {
+            entries.push({
                 name: tool.name,
                 action: state?.action ?? "missing",
                 version: state?.to ?? state?.version ?? null,
-                // A tool ubix never mentioned is not a tool that is fine.
+                // A tool ubix never mentioned is not a tool that is fine; a failed
+                // `post_install` arrives here as `error` beside an `installed` action.
                 error: state?.error ?? (state ? null : "ubix reported nothing about it"),
-            };
-            if (!entry.error && tool.provision) {
-                fence();
-                entry.error = await this.#provision(env, tool, tool.provision);
-            }
-            entries.push(entry);
+            });
         }
         const failed = entries.some((entry) => entry.error !== null);
         return { entries, failed, summary: summarize(entries) };
@@ -519,8 +509,6 @@ export class ManagedTools {
      *  version is unknown (§5). */
     async status(enabled, custom = []) {
         const base = rows(custom).map((tool) => ({
-            source: "binary",
-            kind: tool.kind,
             name: tool.name,
             summary: tool.summary,
             enabled: enabled.includes(tool.name),
@@ -577,12 +565,20 @@ export class ManagedTools {
         return states;
     }
     /** `UBIX_CONFIG_DIR` / `UBIX_DATA_DIR` name the directories directly — not
-     *  XDG parents, which every child ubix spawns (uv, fnm, cargo) would read too. */
+     *  XDG parents, which every child ubix spawns (uv, fnm, cargo) would read too.
+     *  Hooks inherit this env: `pier tools sync` typed in a shell has no main.ts
+     *  parent exporting PI_CODING_AGENT_DIR, and rtk would then write its
+     *  extension into ~/.pi. */
     #env() {
+        const agentDir = resolveAgentDir(process.env);
+        if (process.env.PI_CODING_AGENT_DIR !== agentDir) {
+            log.info(`PI_CODING_AGENT_DIR was ${process.env.PI_CODING_AGENT_DIR ?? "unset"} — ubix gets ${agentDir}`);
+        }
         const env = {
             ...process.env,
             UBIX_CONFIG_DIR: this.#configDir,
             UBIX_DATA_DIR: join(this.#root, "state"),
+            PI_CODING_AGENT_DIR: agentDir,
         };
         prependPath(env, this.bin);
         return env;
@@ -599,8 +595,9 @@ export class ManagedTools {
         renameSync(`${path}.writing`, path);
     }
     /** A non-zero exit still parses: under `--json` a failed tool is in the
-     *  document as `action: "failed"`, and the run exits non-zero. The two must
-     *  agree — an exit code with no failed entry is a failure this file cannot
+     *  document as `action: "failed"` — or as `installed`/`upgraded` with an
+     *  `error`, when its `post_install` hook failed — and the run exits non-zero.
+     *  The two must agree — an exit code with no failed entry is a failure this file cannot
      *  attribute, and passing it on as clean is the one thing it may never do. */
     async #states(ubix, env, args) {
         const result = await this.#exec(ubix, args, env);
@@ -610,43 +607,24 @@ export class ManagedTools {
         }
         catch (err) {
             const failure = failedRun(`ubix ${args.join(" ")}`, result);
-            // Only the flag being unknown means "too old"; re-bootstrapping over a
-            // config error would fix nothing and say something false.
-            if (result.code !== 0 && refusesJson(result.stderr))
-                throw new UbixTooOld(failure);
             throw new Error(result.code === 0 ? String(err) : `${failure} (${String(err)})`);
         }
-        if (result.code !== 0 && !states.some((state) => state.action === "failed")) {
+        if (result.code !== 0 && !states.some((state) => state.error !== null)) {
             throw new Error(`${failedRun(`ubix ${args.join(" ")}`, result)} — and its report names no failure`);
         }
         return states;
     }
-    /** The one place a too-old ubix is repaired rather than reported. */
-    async #listing(ubix, env) {
-        try {
-            return await this.#states(ubix, env, ["list", "--json"]);
-        }
-        catch (err) {
-            if (!(err instanceof UbixTooOld))
-                throw err;
-            log.warn(`the ubix in ${this.bin} is too old for --json — replacing it`);
-            return this.#states(await this.bootstrapUbix(true), env, ["list", "--json"]);
-        }
-    }
-    /** Returns the failure text, or null. */
-    async #provision(env, tool, args) {
-        const exe = join(this.bin, tool.name);
-        if (!existsSync(exe))
-            return `${tool.name} is not in ${this.bin} — ${args.join(" ")} was not run`;
-        // `pier tools sync` typed in a shell has no main.ts parent exporting
-        // PI_CODING_AGENT_DIR; rtk would then write its extension into ~/.pi.
-        const agentDir = resolveAgentDir(env);
-        if (env.PI_CODING_AGENT_DIR !== agentDir) {
-            log.info(`PI_CODING_AGENT_DIR was ${env.PI_CODING_AGENT_DIR ?? "unset"} — ${tool.name} gets ${agentDir}`);
-        }
-        mkdirSync(join(agentDir, "extensions"), { recursive: true });
-        const result = await this.#exec(exe, args, { ...env, PI_CODING_AGENT_DIR: agentDir });
-        return result.code === 0 ? null : failedRun(`${tool.name} ${args.join(" ")}`, result);
+    /** The one place a too-old ubix is repaired rather than reported: Pier put
+     *  that binary in `bin/`, and one below UBIX_MIN would run the config and
+     *  skip its hooks without a word. */
+    async #current(ubix, env) {
+        const result = await this.#exec(ubix, ["--version"], env);
+        const date = /\bv(\d{8})-/.exec(result.stdout)?.[1];
+        if (result.code === 0 && date && date >= UBIX_MIN.slice(1, 9))
+            return ubix;
+        const found = result.code === 0 ? result.stdout.trim() || "(no version)" : failedRun("ubix --version", result);
+        log.warn(`the ubix in ${this.bin} is ${found} and Pier needs ${UBIX_MIN} or newer — replacing it`);
+        return this.bootstrapUbix(true);
     }
     async #getText(url) {
         return new TextDecoder().decode(await this.#getBytes(url));
@@ -662,7 +640,7 @@ export class ManagedTools {
         return new Uint8Array(await res.arrayBuffer());
     }
 }
-const withBinary = (entry, patch) => entry.source === "binary" ? { ...entry, binary: { ...entry.binary, ...patch } } : entry;
+const withBinary = (entry, patch) => ({ ...entry, binary: { ...entry.binary, ...patch } });
 /** Never empty: an exit code with no words is not a report. */
 const failedRun = (what, result) => `${what} exited ${String(result.code)}: ${result.stderr.trim().slice(0, 300) || "(no output)"}`;
 /** `<sha256>  <bare filename>` lines, as `sha256sum` writes them. */

package/dist/vault.js

@@ -0,0 +1,107 @@
+// Named secrets for `pier vault run`: the vault table and its resolution. The
+// value's shape is the level — a sealed envelope is `auto`, a `vt://` record is
+// `approve` — so no column can disagree with the value beside it. Plaintext is
+// a parameter and a return value here, never a log line or a field.
+import { pierDb } from "./db.js";
+import { logger } from "./log.js";
+import { isSealed, vtCli } from "./secrets.js";
+const log = logger("vault");
+/** An env-var name, so the common case needs no mapping. */
+export const isVaultName = (name) => /^[A-Z][A-Z0-9_]{0,63}$/.test(name);
+/** Named, never partial: the caller learns which name to file, and gets no
+ *  values for the others. */
+export class UnknownSecret extends Error {
+    secret;
+    constructor(secret) {
+        super(`no secret named ${secret}`);
+        this.secret = secret;
+    }
+}
+/** Only sealed rows need the key; the reason is the operator's repair instruction. */
+export class VaultLocked extends Error {
+    constructor(reason) {
+        super(`locked — ${reason}`);
+    }
+}
+const levelOf = (value) => (isSealed(value) ? "auto" : "approve");
+function check(name, plaintext) {
+    if (!isVaultName(name))
+        throw new Error(`${name} is not a vault name (A-Z, 0-9, _; starts with a letter)`);
+    if (!plaintext)
+        throw new Error("empty value");
+}
+export class Vault {
+    secrets;
+    db;
+    vt;
+    constructor(secrets, db = pierDb(), vt = vtCli) {
+        this.secrets = secrets;
+        this.db = db;
+        this.vt = vt;
+    }
+    list() {
+        const rows = this.db.prepare("SELECT name, value, updated_at FROM vault ORDER BY name").all();
+        return rows.map((row) => ({ name: row.name, level: levelOf(row.value), updatedAt: row.updated_at }));
+    }
+    /** Overwrite by name is rotation: a command already running keeps the env it
+     *  was given, the next `run` gets the new value. */
+    async put(name, level, plaintext) {
+        if (level === "auto")
+            return this.seal(name, plaintext);
+        check(name, plaintext);
+        const record = await this.vt.create(plaintext);
+        if (!record.startsWith("vt://"))
+            throw new Error("vt create did not return a vt:// record");
+        this.#store(name, level, record);
+    }
+    /** The `auto` half of put, synchronous: a channel save runs on the message
+     *  path and cannot await. */
+    seal(name, plaintext) {
+        check(name, plaintext);
+        this.#store(name, "auto", this.secrets.encrypt(plaintext));
+    }
+    #store(name, level, value) {
+        this.db.prepare(`
+      INSERT INTO vault(name, value, updated_at) VALUES (?, ?, ?)
+      ON CONFLICT(name) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
+    `).run(name, value, Date.now());
+        log.info(`vault put ${name} (${level})`);
+    }
+    /** False when there was nothing to remove. */
+    remove(name) {
+        const removed = this.db.prepare("DELETE FROM vault WHERE name = ?").run(name).changes > 0;
+        if (removed)
+            log.info(`vault remove ${name}`);
+        return removed;
+    }
+    /** One of Pier's own credentials, `undefined` when unfiled — a state there,
+     *  not an error. A sealed row still needs the key. */
+    get(name) {
+        const row = this.db.prepare("SELECT value FROM vault WHERE name = ?").get(name);
+        if (!row)
+            return undefined;
+        return isSealed(row.value) ? this.secrets.decrypt(row.value) : row.value;
+    }
+    /** `by` names the caller in the one log line a resolve leaves; values never
+     *  appear at any level. `approve` rows resolve while locked — they need no key. */
+    resolve(names, by = "unknown") {
+        const select = this.db.prepare("SELECT value FROM vault WHERE name = ?");
+        const rows = names.map((name) => {
+            const row = select.get(name);
+            if (!row)
+                throw new UnknownSecret(name);
+            return [name, row.value];
+        });
+        if (rows.some(([, value]) => isSealed(value)) && this.secrets.state === "locked") {
+            throw new VaultLocked(this.secrets.lockedReason);
+        }
+        const resolved = {};
+        for (const [name, value] of rows) {
+            resolved[name] = isSealed(value)
+                ? { kind: "plain", value: this.secrets.decrypt(value) }
+                : { kind: "record", value };
+        }
+        log.info(`vault resolve ${names.join(",")} by ${by}`);
+        return resolved;
+    }
+}