@timqi/pier 0.1.14 → 0.2.0

package/dist/tasks/messages.js

@@ -23,13 +23,17 @@ export class TaskMessenger {
     store;
     hub;
     unreachable;
+    runChanged;
     outbox;
     constructor(store, router, hub, 
     /** Reports a delivery nobody can complete (service.ts owns the surfaces). */
-    unreachable) {
+    unreachable, 
+    /** A follow-up's run card counts it while it is pending (service.ts). */
+    runChanged) {
         this.store = store;
         this.hub = hub;
         this.unreachable = unreachable;
+        this.runChanged = runChanged;
         this.outbox = new Outbox(router, {
             id: ({ message }) => message.id,
             reload: (id) => {
@@ -68,12 +72,6 @@ export class TaskMessenger {
         for (const message of this.store.expirePendingMessages())
             this.changed(message);
     }
-    list(runId) {
-        return this.store.listMessages(runId);
-    }
-    recent(since) {
-        return this.store.listRecentMessages(since);
-    }
     async control(run, fromSessionId, kind, content) {
         const message = this.create(run, kind, fromSessionId, run.targetSessionId ?? "", content);
         this.changed(message);
@@ -178,5 +176,7 @@ export class TaskMessenger {
     /** Publish only after any transaction changing this message has committed. */
     changed(message) {
         this.hub.emitWorkspace({ type: "task-message-changed", runId: message.runId, messageId: message.id });
+        if (message.kind === "follow_up")
+            this.runChanged(message.runId);
     }
 }

package/dist/tasks/open-items.js

@@ -0,0 +1,70 @@
+// The continuous conversation's open items in task-run words: main's markers
+// joined to the run ledger by session, a lead's workers counted by state, and
+// the one text every surface shows (docs/design/10-continuous-session.md#open-items).
+import { openItemMarkers, runStatus, workerCounts } from "../core/reply.js";
+import { LEDGER_WINDOW_MS, TASK_RUN_STATES } from "../core/types.js";
+import { logger } from "../log.js";
+import { NOT_IN_LEDGER } from "./types.js";
+const log = logger("tasks");
+const IN_FLIGHT = new Set(["queued", "running"]);
+/** `members`: the chain, newest first; `designs`: the open designs of sessions not closed. */
+export function openItems(tasks, router, members, designs, now) {
+    const since = now - LEDGER_WINDOW_MS;
+    const runs = members.length ? tasks.ledger(members, since) : [];
+    const withWorkers = (r) => {
+        if (!r.targetSessionId || tasks.store.roleOf(r.targetSessionId) !== "lead")
+            return r;
+        const workers = Object.fromEntries(TASK_RUN_STATES.map((s) => [s, 0]));
+        for (const w of tasks.ledger([r.targetSessionId], since)) {
+            if (w.state in workers)
+                workers[w.state] += 1;
+        }
+        return { ...r, workers };
+    };
+    // An item names a session through any of its runs: the session's newest run stands for it.
+    const tracked = new Set();
+    const items = tasks.store.openItems().map((row) => {
+        const named = row.runIds.map((id) => {
+            const session = runs.find((r) => r.runId === id)?.targetSessionId ?? tasks.store.getRun(id)?.targetSessionId ?? null;
+            tracked.add(session ?? id);
+            const run = runs.find((r) => (session ? r.targetSessionId === session : r.runId === id));
+            return run
+                ? withWorkers(run)
+                : { runId: id, name: id, state: NOT_IN_LEDGER, targetSessionId: session, cwd: null, queuedAt: 0, finishedAt: null };
+        }).filter((r, i, all) => all.findIndex((o) => o.runId === r.runId) === i);
+        const busy = named.some((r) => IN_FLIGHT.has(r.state) || (r.targetSessionId && router.stateOf(r.targetSessionId) === "streaming"));
+        return { problem: row.problem, stage: row.stage, runs: named, ...(named.length ? { live: busy ? "running" : "idle" } : {}) };
+    });
+    const unlisted = runs.filter((r) => IN_FLIGHT.has(r.state) && !tracked.has(r.targetSessionId ?? r.runId)).map(withWorkers);
+    return { items, unlisted, designs };
+}
+/** The head's reply's markers, written; answers whether a row changed. */
+export function recordOpenItems(store, text, now) {
+    const { markers, dropped } = openItemMarkers(text);
+    for (const marker of dropped)
+        log.warn(`open items: dropped a marker with no problem text: ${marker}`);
+    return markers.length > 0 && store.markOpenItems(markers, now) > 0;
+}
+const workersText = (workers) => workers ? ` · workers: ${workerCounts(workers)}` : "";
+const runText = (r, now) => r.state === NOT_IN_LEDGER
+    ? `run ${r.runId} — ${NOT_IN_LEDGER}`
+    : `run ${r.runId.length > 8 ? `${r.runId.slice(0, 8)}…` : r.runId} ${runStatus(r, now)}${workersText(r.workers)}`;
+/** The one string every surface shows for the open items: `/status` and the seed. */
+export function renderOpenItems({ items, unlisted, designs }, now) {
+    if (!items.length && !unlisted.length && !designs.length)
+        return "Nothing open.";
+    const open = items.map((i) => `- ${i.problem}${i.stage ? ` — ${i.stage}` : ""}${i.live ? ` (${i.live})` : ""}${i.runs.map((r) => ` · ${runText(r, now)}`).join("")}`);
+    const rest = unlisted.map((r) => `- ${r.name} — ${runStatus(r, now)}${workersText(r.workers)}`);
+    const decide = designs.map((r) => `- ${r.name} · ${runText(r, now)}`);
+    return [
+        ...(open.length ? ["Open", ...open] : []),
+        ...(rest.length ? ["Not on the list", ...rest] : []),
+        ...(decide.length ? ["Designs for you to finalize", ...decide] : []),
+    ].join("\n");
+}
+/** `/status`'s card: the text, and run id → session id for every named run and listed design that has one. */
+export function openItemsStatus(open, now) {
+    const sessions = Object.fromEntries([...open.items.flatMap((i) => i.runs), ...open.designs]
+        .flatMap((r) => (r.targetSessionId ? [[r.runId, r.targetSessionId]] : [])));
+    return { text: renderOpenItems(open, now), sessions };
+}

package/dist/tasks/operations.js

@@ -1,8 +1,9 @@
 // The `/task` socket route: every `pier task` operation — run, message, save,
-// list, cancel, recover — validated here once, answered with the summaries a
-// model reads. Scheduling and delivery stay in the service; this file decides
-// who may ask for what.
+// list, pause, resume, archive, cancel, recover — validated here once, answered
+// with the summaries a model reads. Scheduling and delivery stay in the
+// service; this file decides who may ask for what.
 import { isAbsolute, resolve } from "node:path";
+import { isModelTier, LEDGER_WINDOW_MS } from "../core/types.js";
 import { logger } from "../log.js";
 import { record, requiredString } from "./definitions.js";
 import { isTerminal } from "./types.js";
@@ -104,35 +105,67 @@ function cancelledOrCurrent(host, id, ms) {
         new Promise((resolve) => setTimeout(() => resolve(host.getRun(id)), ms).unref()),
     ]);
 }
-export async function handleTask(host, definitions, store, raw, callerSessionId) {
+export async function handleTask(host, definitions, store, raw, callerSessionId, chain) {
+    // The launching session controls a run, and so does the run's own; every
+    // member of the continuous conversation counts as the one that launched it.
+    const launchers = () => chain.chainOf(callerSessionId) ?? [callerSessionId];
+    const assertOwns = (target) => {
+        if (!launchers().includes(target.invokedBySessionId ?? "") && target.targetSessionId !== callerSessionId) {
+            throw new Error("session does not own this run");
+        }
+    };
     const input = record(raw);
     if (!input)
         throw new Error("task parameters required");
-    // Delegation is one level (docs/design/09-tasks-cli.md §Two levels, no tree):
-    // what a supervised run launched would report to a session no run owns. A
-    // queued run has not taken the session's turn, so it gates nothing yet.
+    // Depth stays 2 (docs/design/09-tasks-cli.md §Two levels, no tree); a queued
+    // run has not taken the session's turn, so it gates nothing yet.
+    const role = store.roleOf(callerSessionId);
+    const lead = role === "lead";
     const active = store.findActiveRunForTarget(callerSessionId);
-    if (active?.state === "running" && store.supervised(active))
+    if (active?.state === "running" && store.supervised(active) && !lead)
         throw new Error("a delegated run cannot delegate; ask in your result and let your supervisor run it");
+    if (role === "worker")
+        throw new Error("a worker's session never delegates, in a run or after it; say what needs another agent and let the session that launched it run it");
+    // Read off a draft before it is filed; a saved definition has the same shape under `action`.
+    const notLead = (draft) => {
+        const role = record(record(draft)?.launch)?.role ?? record(record(record(draft)?.action)?.launch)?.role;
+        if (lead && role === "lead")
+            throw new Error("a feature lead cannot launch a lead; a build lead is your supervisor's to launch, from your milestone");
+        return draft;
+    };
     const menu = () => host.models().then((listed) => listed.models);
-    if (input.operation === "list")
-        return definitions.list().filter((task) => task.kind !== "subagent");
+    if (input.operation === "list") {
+        // What the schedule answer needs: the next occurrence and the last run's state, not the run.
+        return definitions.list().filter((task) => task.kind !== "subagent").map(({ nextRunAt, ...task }) => {
+            const last = host.listRuns(task.id, 1)[0];
+            return { ...task, nextRun: nextRunAt, lastRun: last ? defined({ runId: last.id, state: last.state, startedAt: last.startedAt, finishedAt: last.finishedAt }) : null };
+        });
+    }
+    if (input.operation === "runs")
+        return host.ledger(launchers(), Date.now() - LEDGER_WINDOW_MS);
+    // A one-shot's hidden definition is a run's record, not a task anyone filed.
+    const filed = () => {
+        const id = requiredString(input.task_id, "task_id");
+        if (definitions.get(id).kind === "subagent")
+            throw new Error(`${id} is a one-shot run's own definition; save without --task-id to file a task`);
+        return id;
+    };
     if (input.operation === "save") {
         const draft = await expandDraft(definitions, menu, input.task, callerSessionId);
         if (input.task_id === undefined)
             return definitions.create(draft, `session:${callerSessionId}`);
-        const id = requiredString(input.task_id, "task_id");
-        // A one-shot's hidden definition is a run's record, not a task anyone filed.
-        if (definitions.get(id).kind === "subagent")
-            throw new Error(`${id} is a one-shot run's own definition; save without --task-id to file a task`);
-        return definitions.update(id, draft);
+        return definitions.update(filed(), draft);
     }
+    if (input.operation === "pause" || input.operation === "resume")
+        return host.setEnabled(filed(), input.operation === "resume");
+    if (input.operation === "archive")
+        return host.archive(filed());
     if (input.operation === "run") {
         // `--model ?`: the menu instead of a run, the one lookup the common case never pays.
         if (record(input.launch)?.model === "?") {
             const { source, models } = await host.models();
             const head = source === "menu" ? "the operator's menu" : "the live catalog (no model pinned)";
-            return `${head} — --model takes a provider/id or a unique substring of one:\n${menuLines(models)}`;
+            return `${head} — --model takes a tier, a provider/id or a unique substring of one:\n${menuLines(models)}`;
         }
         const callbackMode = callbackModeOf(input);
         if (Array.isArray(input.tasks)) {
@@ -149,8 +182,8 @@ export async function handleTask(host, definitions, store, raw, callerSessionId)
                 if (!entry)
                     throw new Error("invalid tasks[] entry");
                 resolved.push(entry.task_id === undefined
-                    ? await resolveDraft(definitions, menu, entry, callerSessionId)
-                    : definitions.get(requiredString(entry.task_id, "task_id")));
+                    ? await resolveDraft(definitions, menu, notLead(entry), callerSessionId)
+                    : notLead(definitions.get(requiredString(entry.task_id, "task_id"))));
             }
             const groupCallbackSessionId = input.callback === "none" ? null : callerSessionId;
             const { group, runs } = host.runGroup(resolved, oneOf(input, "join", ["all", "first"]) ?? "all", callerSessionId, groupCallbackSessionId, callbackMode);
@@ -158,8 +191,8 @@ export async function handleTask(host, definitions, store, raw, callerSessionId)
         }
         const draft = input.task_id === undefined ? inlineDraft(input) : undefined;
         const task = draft
-            ? await resolveDraft(definitions, menu, draft, callerSessionId)
-            : definitions.get(requiredString(input.task_id, "task_id"));
+            ? await resolveDraft(definitions, menu, notLead(draft), callerSessionId)
+            : notLead(definitions.get(requiredString(input.task_id, "task_id")));
         const callbackSessionId = await callbackTarget(input, definitions, callerSessionId);
         const run = host.run(task.id, null, "agent", null, {
             invokedBySessionId: callerSessionId,
@@ -205,12 +238,12 @@ export async function handleTask(host, definitions, store, raw, callerSessionId)
         if (typeof input.group_id === "string") {
             const { group, members } = host.getGroup(input.group_id);
             for (const member of members)
-                assertOwns(callerSessionId, member);
+                assertOwns(member);
             const cancelled = host.cancelGroup(group.id);
             return summarizeGroup(cancelled, cancelled.memberRunIds.map((id) => host.getRun(id)));
         }
         const run = host.getRun(requiredString(input.run_id, "run_id"));
-        assertOwns(callerSessionId, run);
+        assertOwns(run);
         // cancel() only aborts; the row flips ~100 ms later. A receipt still saying
         // `running` reads as "cancel failed", so wait for the flip, briefly.
         host.cancel(run.id);
@@ -221,7 +254,7 @@ export async function handleTask(host, definitions, store, raw, callerSessionId)
         // caller, decides whether the text steers, queues or resumes, so a status
         // query never has to exist.
         const run = host.getRun(requiredString(input.run_id, "run_id"));
-        assertOwns(callerSessionId, run);
+        assertOwns(run);
         const message = requiredString(input.message, "message");
         if (isTerminal(run.state)) {
             // A resumed run is a new run with its own callback.
@@ -254,23 +287,33 @@ function nameFrom(text) {
         .find(Boolean) ?? "subagent";
     return line.length > 60 ? `${line.slice(0, 59).trimEnd()}…` : line;
 }
-/** `launch.model` by name (docs/design/09-tasks-cli.md §Models). Anything but
- *  one pin or an unpinned `provider/id` is refused with the lines to pick
- *  from, so the agent never guesses an id. */
+/** `launch.model` by name (docs/design/09-tasks-cli.md §Models): the one pin
+ *  it names, a tier its first. Anything but a tier, one pin or an unpinned
+ *  `provider/id` is refused with the lines to pick from, so the agent never
+ *  guesses an id. A tier is never a substring: "cheap" matching an id would
+ *  pick a pin the operator did not assign. */
 function resolveModel(name, menu) {
     const needle = name.trim().toLowerCase();
     const full = (pin) => `${pin.provider}/${pin.id}`;
-    const exact = menu.find((pin) => full(pin).toLowerCase() === needle);
-    const hits = exact ? [exact] : menu.filter((pin) => `${full(pin)} ${pin.note ?? ""}`.toLowerCase().includes(needle));
-    if (hits.length === 1)
-        return { model: { provider: hits[0].provider, id: hits[0].id }, thinking: hits[0].thinking };
+    const pick = (pin) => ({ model: { provider: pin.provider, id: pin.id }, thinking: pin.thinking });
+    if (isModelTier(needle)) {
+        const pin = menu.find((p) => p.tier === needle);
+        if (pin)
+            return pick(pin);
+        throw new Error(`model "${name}": tier ${needle} is unassigned — the operator's menu:\n${menuLines(menu)}`);
+    }
+    const exact = menu.filter((pin) => full(pin).toLowerCase() === needle);
+    const hits = exact.length ? exact : menu.filter((pin) => full(pin).toLowerCase().includes(needle));
+    // One model pinned at several levels is still one model: its first row, as with a tier.
+    if (hits.length && hits.every((pin) => full(pin) === full(hits[0])))
+        return pick(hits[0]);
     const slash = name.indexOf("/");
     if (!hits.length && slash > 0 && slash < name.length - 1)
         return { model: { provider: name.slice(0, slash), id: name.slice(slash + 1) } };
     throw new Error(`model "${name}" matches ${String(hits.length)} of the menu:\n${menuLines(hits.length ? hits : menu)}`);
 }
 /** One pin per line, the only shape a menu is ever printed in. */
-const menuLines = (menu) => menu.map((pin) => `${pin.provider}/${pin.id}${pin.thinking ? ` · ${pin.thinking}` : ""}${pin.note ? ` — ${pin.note}` : ""}`).join("\n")
+const menuLines = (menu) => menu.map((pin) => `${pin.tier ? `${pin.tier} · ` : ""}${pin.provider}/${pin.id}${pin.thinking ? ` · ${pin.thinking}` : ""}`).join("\n")
     || "(no model is pinned or available)";
 /** A `prompt` shorthand becomes a fresh Agent action in the caller's own
  *  directory; everything the caller did spell out passes through to parseDraft. */
@@ -305,6 +348,7 @@ async function expandDraft(definitions, menu, raw, callerSessionId) {
     const launch = record(action?.launch);
     if (typeof launch?.model === "string") {
         const { model, thinking } = resolveModel(launch.model, await menu());
+        // A pin's level only where the caller named none.
         const resolved = { ...launch, model, ...(launch.thinking === undefined && thinking ? { thinking } : {}) };
         draft = { ...draft, action: { ...record(draft.action), launch: resolved } };
     }
@@ -324,12 +368,5 @@ async function resolveDraft(definitions, menu, raw, callerSessionId) {
     if (draft.callback !== undefined || draft.callback_session_id !== undefined) {
         throw new Error("an inline task draft cannot set callback; use the top-level callback / callback_session_id");
     }
-    return definitions.create({ ...draft, trigger: { type: "manual" } }, `session:${callerSessionId}`, "subagent");
-}
-/** The session that launched a run controls it, and so does the run's own
- *  session; a `task` action's child inherits its parent's launcher. */
-function assertOwns(callerSessionId, target) {
-    if (target.invokedBySessionId !== callerSessionId && target.targetSessionId !== callerSessionId) {
-        throw new Error("session does not own this run");
-    }
+    return definitions.create({ ...draft, trigger: { type: "manual" }, callback: { type: "none" } }, `session:${callerSessionId}`, "subagent");
 }

package/dist/tasks/outbox.js

@@ -3,6 +3,11 @@
 import { logger } from "../log.js";
 import { MAX_DELIVERY_ATTEMPTS, retryDelay, undeliverable } from "./types.js";
 const log = logger("tasks");
+/** A result waiting on a lead's own running turn is asked again this often, not
+ *  every tick: a wait spends no attempt, so the attempt backoff does not apply. */
+const MILESTONE_WAIT_MS = 10_000;
+/** The marks a delivered record carries: nothing left to retry. */
+const DELIVERED = { callbackState: "delivered", callbackError: null, callbackNextAttemptAt: null };
 /** The records a delivery names, from either side of the seam: a batch names
  *  every one of them, a group names itself, a message names its id. */
 const recordIds = (origin) => {
@@ -24,6 +29,17 @@ export class Outbox {
      *  written only against the input visible in the recipient's transcript: Pi's
      *  queues are memory, so a resolved `systemInput` proves nothing. */
     async deliver(sessionId, batch) {
+        const marked = batch.map((record) => ({ ...record, ...DELIVERED }));
+        const taken = this.kind.milestone?.(sessionId, () => this.kind.input(batch).text, () => { for (const record of marked)
+            this.kind.save(record); });
+        if (taken === "resumed")
+            for (const record of marked)
+                this.kind.changed(record);
+        if (taken === "wait")
+            for (const record of batch)
+                this.defer(record, MILESTONE_WAIT_MS);
+        if (taken === "resumed" || taken === "wait")
+            return;
         const mine = batch.filter((record) => !this.delivering.has(this.kind.id(record)));
         if (mine.length === 0)
             return;
@@ -128,8 +144,8 @@ export class Outbox {
         return true;
     }
     /** Busy target: try again shortly, and do not count it. */
-    defer(record) {
-        record.callbackNextAttemptAt = Date.now() + 1000;
+    defer(record, ms = 1000) {
+        record.callbackNextAttemptAt = Date.now() + ms;
         this.kind.save(record);
     }
     /** Backs off like a failure, so an input never recorded is re-sent on a
@@ -142,10 +158,7 @@ export class Outbox {
         this.kind.save(record);
     }
     delivered(record) {
-        record.callbackState = "delivered";
-        record.callbackError = null;
-        record.callbackNextAttemptAt = null;
-        this.write(record);
+        this.write(Object.assign(record, DELIVERED));
     }
     /** A failed pass costs one attempt, whether it died before or after send. */
     failed(record, error, counted) {

package/dist/tasks/routes.js

@@ -1,258 +1,28 @@
-// The area's HTTP surface. A route names the caller and hands the decision to
-// TaskService: policy here would be policy `pier task` does not get.
-import { record, requiredString } from "./definitions.js";
-/** Reject malformed filters instead of silently widening a global query. */
-function runQuery(params) {
-    const query = {};
-    const states = ["queued", "running", "succeeded", "failed", "cancelled", "interrupted", "skipped"];
-    const sources = ["manual", "cron", "watch", "agent", "task"];
-    if (params.state) {
-        if (!states.includes(params.state))
-            throw new Error("invalid state");
-        query.state = params.state;
-    }
-    if (params.source) {
-        if (!sources.includes(params.source))
-            throw new Error("invalid source");
-        query.source = params.source;
-    }
-    if (params.taskId)
-        query.taskId = params.taskId;
-    for (const key of ["since", "until", "limit"]) {
-        if (params[key] === undefined)
-            continue;
-        const value = Number(params[key]);
-        if (!params[key] || !Number.isSafeInteger(value) || value < 0 || (key === "limit" && (value < 1 || value > 200)))
-            throw new Error(`invalid ${key}`);
-        query[key] = value;
-    }
-    if (query.since !== undefined && query.until !== undefined && query.since > query.until)
-        throw new Error("since exceeds until");
-    if (params.showUnmatched !== undefined) {
-        if (!["true", "false"].includes(params.showUnmatched))
-            throw new Error("invalid showUnmatched");
-        query.showUnmatched = params.showUnmatched === "true";
-    }
-    if (params.cursor) {
-        const cursor = JSON.parse(params.cursor);
-        const value = record(cursor);
-        if (!value || !Number.isSafeInteger(value.queuedAt) || Number(value.queuedAt) < 0 || typeof value.id !== "string" || !value.id)
-            throw new Error("invalid cursor");
-        query.cursor = { queuedAt: Number(value.queuedAt), id: value.id };
-    }
-    return query;
-}
-const jsonBody = async (req) => req.json().catch(() => null);
-export function registerTaskRoutes(app, tasks, activity) {
-    if (activity)
-        app.get("/api/activity", async (c) => {
-            const now = Date.now();
-            const recent = c.req.query("scope") === "recent";
-            const windowStart = now - 24 * 60 * 60 * 1000;
-            const runs = tasks.activityRuns(recent ? windowStart : undefined);
-            const listed = await activity.factory.list();
-            const byId = new Map(listed.map((session) => [session.id, session]));
-            const linkedIds = new Set();
-            for (const run of runs) {
-                for (const id of [run.invokedBySessionId, run.targetSessionId, run.callbackSessionId]) {
-                    if (id)
-                        linkedIds.add(id);
-                }
-            }
-            for (const session of listed) {
-                if (activity.router.stateOf(session.id) === "streaming")
-                    linkedIds.add(session.id);
-            }
-            const messages = tasks.recentMessages(windowStart)
-                .filter((message) => runs.some((run) => run.id === message.runId));
-            for (const message of messages) {
-                if (message.fromSessionId !== "console")
-                    linkedIds.add(message.fromSessionId);
-                if (message.toSessionId !== "console")
-                    linkedIds.add(message.toSessionId);
-            }
-            return c.json({
-                sessions: [...linkedIds].map((id) => {
-                    const session = byId.get(id);
-                    return {
-                        id,
-                        cwd: session?.cwd ?? "",
-                        createdAt: session?.createdAt ?? null,
-                        title: session?.title,
-                        state: activity.router.stateOf(id) ?? "idle",
-                        stateSince: activity.router.stateSinceOf(id) ?? null,
-                    };
-                }),
-                runs,
-                messages,
-            });
-        });
-    app.get("/api/task-runs", (c) => {
-        try {
-            return c.json(tasks.queryRuns(runQuery(c.req.query())));
-        }
-        catch (err) {
-            return c.json({ error: String(err) }, 400);
-        }
-    });
-    app.get("/api/tasks", (c) => {
-        const trigger = c.req.query("trigger");
-        const state = c.req.query("state");
-        const kind = c.req.query("kind");
-        let rows = tasks.list();
-        // Subagent one-shots are hidden unless explicitly requested via ?kind=subagent.
-        rows = rows.filter((task) => task.kind === (kind ?? "task"));
-        if (trigger)
-            rows = rows.filter((task) => task.trigger.type === trigger);
-        if (state === "archived")
-            rows = rows.filter((task) => task.archived);
-        else if (state === "active")
-            rows = rows.filter((task) => !task.archived);
-        return c.json(rows.map((task) => ({
-            ...task,
-            lastRun: tasks.listRuns(task.id, 1)[0] ?? null,
-        })));
-    });
-    app.post("/api/tasks", async (c) => {
-        const body = await jsonBody(c.req);
-        const runNow = typeof body === "object" && body !== null && "runNow" in body && body.runNow === true;
-        const definition = typeof body === "object" && body !== null && "task" in body ? body.task : body;
-        try {
-            const task = await tasks.create(definition);
-            const run = runNow ? tasks.run(task.id) : null;
-            return c.json({ task, runId: run?.id ?? null }, 201);
-        }
-        catch (err) {
-            return c.json({ error: String(err) }, 400);
-        }
-    });
+// Settings → Tasks' HTTP surface: the list, pause/resume, a task's runs. A
+// route names the caller and hands the decision to TaskService: policy here
+// would be policy `pier task` does not get.
+const RUNS_LIMIT = 20;
+export function registerTaskRoutes(app, tasks) {
+    // Subagent one-shots and archived tasks are history, not something to manage.
+    app.get("/api/tasks", (c) => c.json(tasks.list()
+        .filter((task) => task.kind === "task" && !task.archived)
+        .map((task) => ({ ...task, lastRun: tasks.listRuns(task.id, 1)[0] ?? null }))));
     app.get("/api/tasks/:id/runs", (c) => {
         try {
-            const limit = Number(c.req.query("limit") ?? 50);
-            const offset = Number(c.req.query("offset") ?? 0);
-            return c.json(tasks.listRuns(c.req.param("id"), limit, offset));
+            return c.json(tasks.listRuns(tasks.get(c.req.param("id")).id, RUNS_LIMIT));
         }
         catch (err) {
             return c.json({ error: String(err) }, 404);
         }
     });
-    app.get("/api/task-runs/:id", (c) => {
-        try {
-            return c.json(tasks.getRunView(c.req.param("id")));
-        }
-        catch (err) {
-            return c.json({ error: String(err) }, 404);
-        }
-    });
-    app.get("/api/task-groups/:id", (c) => {
-        try {
-            return c.json(tasks.getGroup(c.req.param("id")));
-        }
-        catch (err) {
-            return c.json({ error: String(err) }, 404);
-        }
-    });
-    app.get("/api/task-runs/:id/messages", (c) => {
-        try {
-            return c.json(tasks.listMessages(c.req.param("id")));
-        }
-        catch (err) {
-            return c.json({ error: String(err) }, 404);
-        }
-    });
-    app.post("/api/task-runs/:id/steer", async (c) => {
-        const body = record(await jsonBody(c.req));
-        try {
-            return c.json(await tasks.control(c.req.param("id"), typeof body?.sourceSessionId === "string" ? body.sourceSessionId : "console", body?.mode === "followUp" ? "follow_up" : "steer", requiredString(body?.message, "message")), 202);
-        }
-        catch (err) {
-            return c.json({ error: String(err) }, 400);
-        }
-    });
-    app.post("/api/task-runs/:id/resume", async (c) => {
-        const body = record(await jsonBody(c.req));
-        try {
-            const wait = body?.wait === true;
-            const source = typeof body?.sourceSessionId === "string" ? body.sourceSessionId : null;
-            const run = tasks.resume(c.req.param("id"), requiredString(body?.message, "message"), {
-                invokedBySessionId: source,
-                callbackSessionId: wait ? null : source,
-                background: !wait,
-            });
-            return c.json(wait ? await tasks.waitForRun(run.id) : run, wait ? 200 : 202);
-        }
-        catch (err) {
-            return c.json({ error: String(err) }, 400);
-        }
-    });
-    app.post("/api/task-runs/:id/cancel", (c) => {
-        try {
-            return c.json(tasks.cancel(c.req.param("id")), 202);
-        }
-        catch (err) {
-            return c.json({ error: String(err) }, 404);
-        }
-    });
-    app.get("/api/tasks/:id", (c) => {
-        try {
-            return c.json(tasks.get(c.req.param("id")));
-        }
-        catch (err) {
-            return c.json({ error: String(err) }, 404);
-        }
-    });
-    app.patch("/api/tasks/:id", async (c) => {
-        try {
-            return c.json(await tasks.update(c.req.param("id"), await jsonBody(c.req)));
-        }
-        catch (err) {
-            return c.json({ error: String(err) }, 400);
-        }
-    });
-    app.post("/api/tasks/:id/run", async (c) => {
-        const body = record(await jsonBody(c.req));
-        const input = body && "input" in body ? body.input : null;
-        try {
-            // Dropping an unsupported override would run the definition's own policy
-            // instead — on a reuse definition, work injected into a live session.
-            if (body?.sessionMode !== undefined && body.sessionMode !== "fresh") {
-                throw new Error(`unsupported sessionMode: ${String(body.sessionMode)}`);
+    for (const [verb, enabled] of [["pause", false], ["resume", true]]) {
+        app.post(`/api/tasks/:id/${verb}`, (c) => {
+            try {
+                return c.json(tasks.setEnabled(c.req.param("id"), enabled));
             }
-            const sessionMode = body?.sessionMode;
-            const sourceSessionId = typeof body?.sourceSessionId === "string" && body.sourceSessionId ? body.sourceSessionId : null;
-            const task = tasks.get(c.req.param("id"));
-            return c.json({ runId: tasks.run(task.id, input, "manual", null, {
-                    invokedBySessionId: sourceSessionId,
-                    sourceSessionId,
-                    sessionMode,
-                }).id }, 202);
-        }
-        catch (err) {
-            return c.json({ error: String(err) }, 400);
-        }
-    });
-    app.post("/api/tasks/:id/pause", (c) => {
-        try {
-            return c.json(tasks.setEnabled(c.req.param("id"), false));
-        }
-        catch (err) {
-            return c.json({ error: String(err) }, 400);
-        }
-    });
-    app.post("/api/tasks/:id/resume", (c) => {
-        try {
-            return c.json(tasks.setEnabled(c.req.param("id"), true));
-        }
-        catch (err) {
-            return c.json({ error: String(err) }, 400);
-        }
-    });
-    app.post("/api/tasks/:id/archive", (c) => {
-        try {
-            return c.json(tasks.archive(c.req.param("id")));
-        }
-        catch (err) {
-            return c.json({ error: String(err) }, 400);
-        }
-    });
+            catch (err) {
+                return c.json({ error: String(err) }, 400);
+            }
+        });
+    }
 }