@timqi/pier 0.0.17 → 0.0.20

package/dist/tasks/service.js

@@ -44,7 +44,7 @@ export class TaskService {
         this.instance = instance;
         const unreachable = (sessionId, what, why) => this.unreachable(sessionId, what, why);
         this.messages = new TaskMessenger(store, router, hub, (runId, prompt, fromSessionId) => this.resume(runId, prompt, { invokedBySessionId: fromSessionId, callbackSessionId: fromSessionId, background: true }), unreachable);
-        this.definitions = new TaskDefinitions(store, factory, router, hub);
+        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),
@@ -164,9 +164,6 @@ export class TaskService {
     archive(id, by) {
         return this.definitions.archive(id, by);
     }
-    sessionExists(sessionId) {
-        return this.definitions.sessionExists(sessionId);
-    }
     listRuns(taskId, limit = 50, offset = 0) {
         this.get(taskId);
         return this.store.listRuns(taskId, Math.min(Math.max(limit, 1), 200), Math.max(offset, 0));
@@ -177,6 +174,11 @@ export class TaskService {
             throw new Error(`unknown task run: ${id}`);
         return run;
     }
+    getRunView(id) {
+        const run = this.getRun(id);
+        return { ...run, pendingDecisionId: this.openDecisionId(id),
+            groupCallbackState: run.groupId ? this.store.getGroup(run.groupId)?.callbackState ?? null : null };
+    }
     listMessages(runId) {
         this.getRun(runId);
         return this.messages.list(runId);
@@ -184,6 +186,9 @@ export class TaskService {
     openDecisionId(runId) {
         return this.messages.openDecisionId(runId);
     }
+    queryRuns(query = {}) {
+        return this.store.queryRuns(query);
+    }
     recentRuns(limit = 100) {
         return this.store.listRecentRuns(limit);
     }
@@ -198,6 +203,11 @@ export class TaskService {
             .reverse()
             .map((run) => this.backgroundRun(run));
     }
+    /** The same runs `backgroundRuns` reports as in flight, counted per session
+     *  in one query — a list needs the number, not the runs. */
+    activeBackgroundRunCounts() {
+        return this.store.countActiveBackgroundRunsBySession();
+    }
     run(taskId, input = null, source = "manual", parentRunId = null, provenance = {}) {
         this.refusePaused(parentRunId);
         const task = this.get(taskId);

package/dist/tasks/store.js

@@ -2,22 +2,25 @@
 // runs, groups and messages are rows here, read and written through one
 // connection db.ts opened. A store owns its queries, never its own tables or
 // its own handle — the schema is db.ts's migration list.
-import { pierDb } from "../db.js";
+import { pierDb, statements } from "../db.js";
 const clamp = (limit, cap) => Math.min(Math.max(limit, 1), cap);
 export class TaskStore {
     db;
+    /** Every query below is a fixed string, so each is compiled once. */
+    sql;
     constructor(db = pierDb()) {
         this.db = db;
+        this.sql = statements(db);
     }
     // Every table is one JSON column plus query columns; these two are the only
     // readers, and the one seam where a future schema change normalizes old rows
     // (pre-v1 databases are refused outright in db.ts).
     #one(sql, ...params) {
-        const row = this.db.prepare(sql).get(...params);
+        const row = this.sql(sql).get(...params);
         return row ? JSON.parse(row.json) : undefined;
     }
     #many(sql, ...params) {
-        return this.db.prepare(sql).all(...params)
+        return this.sql(sql).all(...params)
             .map((row) => JSON.parse(row.json));
     }
     listTasks() {
@@ -27,11 +30,17 @@ export class TaskStore {
         return this.#one("SELECT json FROM tasks WHERE id = ?", id);
     }
     saveTask(task) {
-        this.db.prepare(`
+        this.sql(`
       INSERT INTO tasks(id, updated_at, json) VALUES (?, ?, ?)
       ON CONFLICT(id) DO UPDATE SET updated_at=excluded.updated_at, json=excluded.json
     `).run(task.id, task.updatedAt, JSON.stringify(task));
     }
+    /** The tick's whole question, asked of the index rather than of every
+     *  document: a task with no next run (disabled, archived, manual) is not in
+     *  it, so an idle second reads no row. */
+    listDueTasks(now) {
+        return this.#many("SELECT json FROM tasks WHERE next_run_at IS NOT NULL AND next_run_at <= ?", now);
+    }
     listRuns(taskId, limit = 50, offset = 0) {
         return this.#many(`
       SELECT json FROM task_runs WHERE task_id = ?
@@ -42,13 +51,56 @@ export class TaskStore {
         return this.#one("SELECT json FROM task_runs WHERE id = ?", id);
     }
     saveRun(run) {
-        this.db.prepare(`
+        this.sql(`
       INSERT INTO task_runs(id, task_id, queued_at, state, callback_state, json)
       VALUES (?, ?, ?, ?, ?, ?)
       ON CONFLICT(id) DO UPDATE SET
         state=excluded.state, callback_state=excluded.callback_state, json=excluded.json
     `).run(run.id, run.taskId, run.queuedAt, run.state, run.callbackState, JSON.stringify(run));
     }
+    /** The global list: filters precede the limit, and the id breaks timestamp
+     *  ties so a page boundary never repeats or skips a row. The statement is
+     *  built per call and not cached — the filter set makes it. */
+    queryRuns(query = {}) {
+        const where = [];
+        const params = [];
+        const add = (sql, value) => {
+            if (value !== undefined) {
+                where.push(sql);
+                params.push(value);
+            }
+        };
+        add("r.state = ?", query.state);
+        add("r.task_id = ?", query.taskId);
+        add("json_extract(r.json, '$.triggerSource') = ?", query.source);
+        add("r.queued_at >= ?", query.since);
+        add("r.queued_at <= ?", query.until);
+        // Keep this predicate identical to migration 17's partial index.
+        if (!query.showUnmatched)
+            where.push("NOT (r.state = 'succeeded' AND json_extract(r.json, '$.matched') IS 0)");
+        if (query.cursor) {
+            where.push("(r.queued_at, r.id) < (?, ?)");
+            params.push(query.cursor.queuedAt, query.cursor.id);
+        }
+        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
+      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,
+        }));
+        const last = runs.at(-1);
+        return {
+            runs,
+            nextCursor: rows.length > limit && last ? { queuedAt: last.queuedAt, id: last.id } : null,
+        };
+    }
     listRecentRuns(limit = 100) {
         return this.#many("SELECT json FROM task_runs ORDER BY queued_at DESC LIMIT ?", clamp(limit, 500));
     }
@@ -60,7 +112,7 @@ export class TaskStore {
     `, rootRunId, clamp(limit, 500));
     }
     countActiveRuns() {
-        const row = this.db.prepare("SELECT COUNT(*) AS n FROM task_runs WHERE state IN ('queued', 'running')").get();
+        const row = this.sql("SELECT COUNT(*) AS n FROM task_runs WHERE state IN ('queued', 'running')").get();
         return row.n;
     }
     findActiveRun(taskId) {
@@ -77,6 +129,20 @@ export class TaskStore {
       ORDER BY CASE state WHEN 'running' THEN 0 ELSE 1 END, queued_at DESC LIMIT 1
     `, sessionId);
     }
+    /** How many background runs each session has in flight, for a list that
+     *  draws one dot per row: the state column narrows the scan to the handful
+     *  of live runs, and no row's JSON is parsed. */
+    countActiveBackgroundRunsBySession() {
+        const rows = this.sql(`
+      SELECT json_extract(json, '$.invokedBySessionId') AS session_id, COUNT(*) AS n
+      FROM task_runs
+      WHERE state IN ('queued', 'running')
+        AND json_extract(json, '$.background') = 1
+        AND json_extract(json, '$.invokedBySessionId') IS NOT NULL
+      GROUP BY session_id
+    `).all();
+        return new Map(rows.map((row) => [row.session_id, row.n]));
+    }
     listRunsForSession(sessionId, limit = 50) {
         return this.#many(`
       SELECT json FROM task_runs
@@ -85,7 +151,7 @@ export class TaskStore {
     `, sessionId, clamp(limit, 200));
     }
     saveGroup(group) {
-        this.db.prepare(`
+        this.sql(`
       INSERT INTO task_groups(id, created_at, callback_state, finished_at, json)
       VALUES (?, ?, ?, ?, ?)
       ON CONFLICT(id) DO UPDATE SET
@@ -107,7 +173,7 @@ export class TaskStore {
     `, now);
     }
     saveMessage(message) {
-        this.db.prepare(`
+        this.sql(`
       INSERT INTO task_messages(id, run_id, state, created_at, json)
       VALUES (?, ?, ?, ?, ?)
       ON CONFLICT(id) DO UPDATE SET state=excluded.state, json=excluded.json
@@ -122,9 +188,20 @@ export class TaskStore {
     listRecentMessages(since) {
         return this.#many("SELECT json FROM task_messages WHERE created_at >= ? ORDER BY created_at DESC LIMIT 200", since);
     }
-    /** Messages whose injection never landed: the delivery sweep retries these. */
+    /** Messages whose injection never landed, each beside the run it belongs to:
+     *  the delivery sweep needs both, and fetching the run per message made one
+     *  sweep cost a query per undelivered message. A message whose run is gone
+     *  comes back with `run: undefined` — the sweep drops it. */
     listUndeliveredMessages() {
-        return this.#many("SELECT json FROM task_messages WHERE state IN ('pending', 'failed') ORDER BY created_at");
+        const rows = this.sql(`
+      SELECT m.json AS json, r.json AS run_json
+      FROM task_messages m LEFT JOIN task_runs r ON r.id = m.run_id
+      WHERE m.state IN ('pending', 'failed') ORDER BY m.created_at
+    `).all();
+        return rows.map((row) => ({
+            message: JSON.parse(row.json),
+            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. */

package/dist/tasks/tool.js

@@ -78,7 +78,6 @@ const DraftSchema = Type.Object({
             type: Type.Literal("agent"),
             session: Type.Union([
                 Type.Object({ mode: Type.Literal("fresh"), cwd: Type.String() }),
-                Type.Object({ mode: Type.Literal("fork"), cwd: Type.Optional(Type.String()) }),
                 Type.Object({ mode: Type.Literal("reuse"), sessionId: Type.String() }),
             ]),
             prompt: Type.String(),
@@ -102,7 +101,7 @@ export function taskToolSpec(execute) {
     return {
         name: "task",
         label: "Pier Task",
-        description: "Manage durable Pier tasks and subagents. Agent tasks support reused, fresh, or forked sessions. Run executes a stored task by task_id, a one-shot subagent from an inline task draft, or a core-joined fan-out via tasks[] with join all|first. Get accepts run_id, group_id, or task_id for that task's recent runs. Every operation returns immediately: results, group joins, and decision replies arrive as callback messages. Use steer/follow_up/resume for child control and contact/reply for supervisor decisions. models lists the deployment's model menu (operator pins with intent notes, else the live catalog).",
+        description: "Manage durable Pier tasks and subagents. Agent tasks run in a fresh session or a reused one. Run executes a stored task by task_id, a one-shot subagent from an inline task draft, or a core-joined fan-out via tasks[] with join all|first. Get accepts run_id, group_id, or task_id for that task's recent runs. Every operation returns immediately: results, group joins, and decision replies arrive as callback messages. Use steer/follow_up/resume for child control and contact/reply for supervisor decisions. models lists the deployment's model menu (operator pins with intent notes, else the live catalog).",
         parameters: Type.Object({
             operation: strEnum("list", "create", "update", "run", "get", "cancel", "steer", "follow_up", "resume", "contact", "reply", "models"),
             task_id: Type.Optional(Type.String()),
@@ -111,7 +110,7 @@ export function taskToolSpec(execute) {
             message_id: Type.Optional(Type.String()),
             message: Type.Optional(Type.String()),
             reason: Type.Optional(strEnum("progress", "decision")),
-            session_mode: Type.Optional(strEnum("fresh", "fork")),
+            session_mode: Type.Optional(strEnum("fresh")),
             task: Type.Optional(DraftSchema),
             // The same draft again, spelled out, cost more tokens in every session
             // than the whole rest of this contract. One copy is the guidance; this
@@ -173,7 +172,12 @@ export async function handleTaskTool(host, definitions, store, messages, raw, ca
         const task = draft
             ? await resolveDraft(definitions, draft, active, callerSessionId)
             : resolveStored(definitions, input.task_id, active);
-        const sessionMode = input.session_mode === "fresh" || input.session_mode === "fork" ? input.session_mode : undefined;
+        // Same as the HTTP route: a named mode the schema no longer offers is
+        // answered, not quietly swapped for the definition's own policy.
+        if (input.session_mode !== undefined && input.session_mode !== "fresh") {
+            throw new Error(`unsupported session_mode: ${String(input.session_mode)}`);
+        }
+        const sessionMode = input.session_mode;
         let callbackSessionId = input.callback === "none" ? null : callerSessionId;
         if (!active && callbackSessionId && typeof input.callback_session_id === "string") {
             callbackSessionId = requiredString(input.callback_session_id, "callback_session_id");

package/dist/tools.js

@@ -188,6 +188,10 @@ 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;
 }
+/** How long `ubix list --json` stays usable for `status()`: long enough that
+ *  one Console page open spawns it once, short enough that an install done
+ *  outside Pier shows up while the operator is still looking at the page. */
+const LIST_TTL_MS = 3_000;
 /** `stale` is heartbeat age, never how long the work has taken; `wait` is what
  *  a waiter gives a live holder before giving up with a reason. */
 const LOCK_TIMING = { heartbeatMs: 5_000, staleMs: 30_000, waitMs: 20 * 60_000, pollMs: 200 };
@@ -606,7 +610,15 @@ export class ManagedTools {
         this.#lock ??= new SyncLock(this.#db());
         return this.#lock.run(async (fence) => {
             const { tools, customTools } = read();
-            return this.#converge(tools, customTools, fence);
+            // This run is the only thing here that changes what `list` answers, so
+            // the memo `status()` reads is dropped on both sides of it.
+            this.#listed = undefined;
+            try {
+                return await this.#converge(tools, customTools, fence);
+            }
+            finally {
+                this.#listed = undefined;
+            }
         });
     }
     async #converge(enabled, custom, fence) {
@@ -698,7 +710,7 @@ export class ManagedTools {
             return base;
         let states;
         try {
-            states = await this.#states(this.ubixPath, this.#env(), ["list", "--json"]);
+            states = await this.#listedTools();
         }
         catch (err) {
             // The page says why it cannot answer rather than answering wrongly: a
@@ -733,6 +745,24 @@ export class ManagedTools {
             });
         });
     }
+    /** What `ubix list --json` last said, retained for LIST_TTL_MS. It is a
+     *  subprocess, and the Console asks for the catalog on every settings read —
+     *  one page open is several, each of which spawned its own ubix. A failed
+     *  read is not retained: it is not an answer to hand the next caller for
+     *  three seconds. */
+    #listed;
+    #listedTools() {
+        const now = Date.now();
+        if (this.#listed && now - this.#listed.at < LIST_TTL_MS)
+            return this.#listed.states;
+        const states = this.#states(this.ubixPath, this.#env(), ["list", "--json"]);
+        void states.catch(() => {
+            if (this.#listed?.states === states)
+                this.#listed = undefined;
+        });
+        this.#listed = { at: now, states };
+        return states;
+    }
     /** Pier's ubix config and state, never the operator's. `UBIX_CONFIG_DIR` /
      *  `UBIX_DATA_DIR` name the directories that hold config.toml / state.toml
      *  directly — not XDG parents, which every child ubix spawns (uv, fnm,

package/dist/web/auth.js

@@ -20,7 +20,7 @@
 import { createHash, randomBytes, randomInt, scryptSync, timingSafeEqual } from "node:crypto";
 import { getConnInfo } from "@hono/node-server/conninfo";
 import { deleteCookie, getCookie, setCookie } from "hono/cookie";
-import { pierDb, transact } from "../db.js";
+import { pierDb, statements, transact } from "../db.js";
 import { logger } from "../log.js";
 const log = logger("auth");
 const COOKIE = "pier_session";
@@ -67,9 +67,13 @@ function generatePassword() {
  */
 export class AuthStore {
     #db;
+    /** Compiled once each: `check()` runs two of these on every request that
+     *  carries a cookie, which is every request the workbench makes. */
+    #sql;
     #revokeListeners = new Set();
     constructor(db = pierDb(), print = (m) => log.info(m)) {
         this.#db = db;
+        this.#sql = statements(db);
         let row = this.#row();
         if (!row) {
             const password = generatePassword();
@@ -81,8 +85,7 @@ export class AuthStore {
             // in one transaction: half of this leaves a new password and live old
             // cookies, which is the state recovery exists to end.
             transact(this.#db, () => {
-                this.#db
-                    .prepare("INSERT INTO auth(id, salt, hash, created_at) VALUES (1, ?, ?, ?)")
+                this.#sql("INSERT INTO auth(id, salt, hash, created_at) VALUES (1, ?, ?, ?)")
                     .run(salt, hash(password, salt), Date.now());
                 this.#dropSessions();
             });
@@ -96,14 +99,13 @@ export class AuthStore {
         this.sweep();
     }
     #row() {
-        return this.#db
-            .prepare("SELECT salt, hash, created_at AS createdAt FROM auth WHERE id = 1")
+        return this.#sql("SELECT salt, hash, created_at AS createdAt FROM auth WHERE id = 1")
             .get();
     }
     /** Every signed-in browser at once. Private: the callers that mean it also
      *  have to tell the listeners, and `revoke(ALL)` is that pair in public. */
     #dropSessions() {
-        this.#db.prepare("DELETE FROM web_sessions").run();
+        this.#sql("DELETE FROM web_sessions").run();
     }
     /** Sessions nobody may use any more, deleted rather than merely refused: a
      *  row is what a push subscription hangs off, so "expired" has to become
@@ -111,8 +113,7 @@ export class AuthStore {
      *  boot and whenever somebody signs in — the two moments the process has a
      *  reason to look at this table at all. */
     sweep() {
-        const swept = this.#db
-            .prepare("DELETE FROM web_sessions WHERE seen_at <= ? RETURNING id")
+        const swept = this.#sql("DELETE FROM web_sessions WHERE seen_at <= ? RETURNING id")
             .all(Date.now() - TTL_MS);
         for (const row of swept)
             this.#revoked(row.id);
@@ -135,8 +136,7 @@ export class AuthStore {
         // Credential and sessions change together or not at all — a crash between
         // the two writes is exactly the state "everyone signs in again" denies.
         transact(this.#db, () => {
-            this.#db
-                .prepare("UPDATE auth SET salt = ?, hash = ?, created_at = ? WHERE id = 1")
+            this.#sql("UPDATE auth SET salt = ?, hash = ?, created_at = ? WHERE id = 1")
                 .run(salt, hash(password, salt), Date.now());
             this.#dropSessions();
         });
@@ -150,10 +150,8 @@ export class AuthStore {
         // name, and the 256-bit token is the only part that has to resist guessing.
         const id = randomBytes(9).toString("base64url");
         const token = randomBytes(32).toString("base64url");
-        this.#db
-            .prepare("INSERT INTO web_sessions(id, token_hash, created_at, seen_at, ip, agent)" +
-            " VALUES (?, ?, ?, ?, ?, ?)")
-            .run(id, digest(token), now, now, ip, agent.slice(0, 200));
+        this.#sql("INSERT INTO web_sessions(id, token_hash, created_at, seen_at, ip, agent)" +
+            " VALUES (?, ?, ?, ?, ?, ?)").run(id, digest(token), now, now, ip, agent.slice(0, 200));
         return `${id}.${token}`;
     }
     /**
@@ -166,9 +164,7 @@ export class AuthStore {
         const [id, token] = (cookie ?? "").split(".");
         if (!id || !token)
             return undefined;
-        const row = this.#db
-            .prepare("SELECT token_hash AS tokenHash, seen_at AS seenAt FROM web_sessions WHERE id = ?")
-            .get(id);
+        const row = this.#sql("SELECT token_hash AS tokenHash, seen_at AS seenAt FROM web_sessions WHERE id = ?").get(id);
         const now = Date.now();
         // One clock: last use is the deadline, so there is no second column that
         // can disagree with it about when this session ends. An expired row is
@@ -184,7 +180,7 @@ export class AuthStore {
             return undefined;
         if (now - row.seenAt < TOUCH_MS)
             return { id, renewed: false };
-        this.#db.prepare("UPDATE web_sessions SET seen_at = ? WHERE id = ?").run(now, id);
+        this.#sql("UPDATE web_sessions SET seen_at = ? WHERE id = ?").run(now, id);
         return { id, renewed: true };
     }
     /** Sign out one browser, or every one of them (`ALL`). Listeners hear the
@@ -193,16 +189,14 @@ export class AuthStore {
         if (id === ALL)
             this.#dropSessions();
         else
-            this.#db.prepare("DELETE FROM web_sessions WHERE id = ?").run(id);
+            this.#sql("DELETE FROM web_sessions WHERE id = ?").run(id);
         this.#revoked(id);
     }
     /** Signed-in browsers, most recently seen first. Never the token — the list
      *  is shown to whoever is signed in, and it is not a set of credentials. */
     list() {
-        return this.#db
-            .prepare("SELECT id, created_at AS createdAt, seen_at AS seenAt, ip, agent" +
-            " FROM web_sessions WHERE seen_at > ? ORDER BY seen_at DESC")
-            .all(Date.now() - TTL_MS);
+        return this.#sql("SELECT id, created_at AS createdAt, seen_at AS seenAt, ip, agent" +
+            " FROM web_sessions WHERE seen_at > ? ORDER BY seen_at DESC").all(Date.now() - TTL_MS);
     }
     /** A long-lived authenticated surface closes itself when a cookie is
      *  revoked. The store and listeners share the process lifetime. */

package/dist/web/config-sync.js

@@ -0,0 +1,91 @@
+// HTTP presentation of the injected configuration subscription. The sole
+// public route is registered before auth; every management action is after it.
+import { logger } from "../log.js";
+const log = logger("config-sync");
+export function registerConfigShareRoute(app, sync) {
+    app.get("/config-sync/:token", async (c) => {
+        c.header("cache-control", "no-store");
+        c.header("x-frame-options", "DENY");
+        c.header("referrer-policy", "no-referrer");
+        if (c.req.method !== "GET") {
+            c.header("allow", "GET");
+            return c.body(null, 405);
+        }
+        const token = c.req.param("token");
+        if (!/^[a-f0-9]{64}$/.test(token))
+            return c.json({ error: "not found" }, 404);
+        try {
+            const published = await sync.published(token);
+            if (!published)
+                return c.json({ error: "not found" }, 404);
+            c.header("etag", published.etag);
+            c.header("x-content-type-options", "nosniff");
+            const tags = c.req.header("if-none-match")?.split(",").map((value) => value.trim().replace(/^W\//, ""));
+            if (tags?.includes(published.etag) || tags?.includes("*"))
+                return c.body(null, 304);
+            c.header("content-type", "application/json; charset=utf-8");
+            return c.body(published.body);
+        }
+        catch {
+            // Never let the app's path logger print a capability URL.
+            log.error("Could not export shared configuration");
+            return c.json({ error: "Could not export configuration" }, 500);
+        }
+    });
+    // Reject other verbs here so neither auth redirects nor request-path logs
+    // can carry this capability to another surface.
+    app.all("/config-sync/:token", (c) => {
+        c.header("cache-control", "no-store");
+        c.header("allow", "GET");
+        return c.body(null, 405);
+    });
+}
+export function registerConfigSyncRoutes(app, deps) {
+    app.get("/api/config-sync", (c) => {
+        c.header("cache-control", "no-store");
+        return c.json(deps.status());
+    });
+    app.post("/api/config-sync", async (c) => {
+        c.header("cache-control", "no-store");
+        const body = await c.req.json().catch(() => null);
+        if (!body || typeof body.action !== "string")
+            return c.json({ error: "action required" }, 400);
+        try {
+            let result;
+            switch (body.action) {
+                case "publish":
+                    await deps.sync.publish();
+                    break;
+                case "revoke":
+                    await deps.sync.revoke();
+                    break;
+                case "subscribe": {
+                    if (typeof body.url !== "string")
+                        throw new Error("Source URL required");
+                    result = await deps.sync.subscribe(body.url);
+                    break;
+                }
+                case "pause":
+                    await deps.sync.pause();
+                    break;
+                case "sync":
+                    result = await deps.run();
+                    break;
+                default: return c.json({ error: "Unknown configuration sync action" }, 400);
+            }
+            await deps.reconcile();
+            return c.json({ ...deps.status(), ...(result ? { result } : {}) });
+        }
+        catch (err) {
+            // Application can succeed while reload fails; still reconcile the owned
+            // task to the persisted subscription switch in that case.
+            try {
+                await deps.reconcile();
+            }
+            catch {
+                log.error("Could not reconcile configuration sync task");
+            }
+            return c.json({ error: err instanceof Error ? err.message : "Configuration sync failed", status: deps.status() }, 409);
+        }
+    });
+}

package/dist/web/config.js

@@ -0,0 +1,61 @@
+// The agent files a scope is configured by — Pi's own config, skills and
+// extensions — read and written through the ConfigStore, never as paths. A
+// scope is "global" or a project cwd Pi already knows, which is why this is
+// the one filesystem-shaped surface that does not go through web/fs.ts: it
+// never takes a path from the browser at all.
+import { guarded } from "./route.js";
+export function registerConfigRoutes(app, { factory, config, onConfigWritten }) {
+    // Scope comes from the client as "global" or a project cwd; only cwds Pi
+    // already knows (the session list) are accepted — never an arbitrary path.
+    const parseScope = async (raw) => {
+        if (!raw || raw === "global")
+            return { kind: "global" };
+        const known = await factory.list();
+        return known.some((s) => s.cwd === raw) ? { kind: "project", cwd: raw } : null;
+    };
+    app.get("/api/config", async (c) => {
+        c.header("cache-control", "no-store");
+        const scope = await parseScope(c.req.query("scope"));
+        if (!scope)
+            return c.json({ error: "unknown scope" }, 400);
+        return c.json({
+            // Where this scope's files live on disk — the UI labels "Global" with it.
+            dir: scope.kind === "global" ? config.globalDir : scope.cwd,
+            files: await config.listFiles(scope),
+            resources: await config.listResources(scope),
+        });
+    });
+    guarded(app, "GET", "/api/config/files/:name", 400, async (c) => {
+        c.header("cache-control", "no-store");
+        const scope = await parseScope(c.req.query("scope"));
+        if (!scope)
+            return c.json({ error: "unknown scope" }, 400);
+        return c.json({ content: await config.readFile(scope, c.req.param("name")) });
+    });
+    guarded(app, "PUT", "/api/config/files/:name", 400, async (c) => {
+        const scope = await parseScope(c.req.query("scope"));
+        if (!scope)
+            return c.json({ error: "unknown scope" }, 400);
+        const body = await c.req.json().catch(() => null);
+        if (typeof body?.content !== "string" || typeof body?.expected !== "string") {
+            return c.json({ error: "content and expected content required" }, 400);
+        }
+        const name = c.req.param("name");
+        await config.writeFile(scope, name, body.content, body.expected);
+        onConfigWritten?.();
+        return c.json({ ok: true, content: await config.readFile(scope, name) });
+    });
+    // Resource names may contain slashes — query params, not path params.
+    guarded(app, "GET", "/api/config/resource", 400, async (c) => {
+        c.header("cache-control", "no-store");
+        const scope = await parseScope(c.req.query("scope"));
+        if (!scope)
+            return c.json({ error: "unknown scope" }, 400);
+        const kind = c.req.query("kind");
+        const name = c.req.query("name");
+        if ((kind !== "extensions" && kind !== "skills") || !name) {
+            return c.json({ error: "kind and name required" }, 400);
+        }
+        return c.json({ content: await config.readResource(scope, kind, name) });
+    });
+}