@timqi/pier 0.1.14 → 0.3.0

package/dist/tasks/definitions.js

@@ -1,6 +1,6 @@
 // What a task *is* before it ever runs: the id it is minted with, the draft
 // validated into a definition, and when its trigger is next due. Every way a
-// definition can be created — HTTP, `pier task`, Pier's own owned task —
+// definition can be created — `pier task`, Pier's own owned task —
 // arrives here, so a field is checked in one place or nowhere.
 import { randomBytes } from "node:crypto";
 import { stat } from "node:fs/promises";
@@ -69,13 +69,27 @@ function parseTrigger(raw) {
 }
 /** Always computed from `from` (boot recomputes from *now*): cron runs missed
  *  while Pier was down are skipped, never caught up — no double fire. */
-export function nextRunAt(trigger, from) {
+function nextRunAt(trigger, from) {
     if (trigger.type === "manual")
         return null;
     if (trigger.type === "watch")
         return from + trigger.intervalSeconds * 1000;
     return new Cron(trigger.expression, { timezone: trigger.timezone }).nextRun(new Date(from))?.getTime() ?? null;
 }
+function parseModel(raw) {
+    const model = record(raw);
+    if (!model)
+        throw new Error("agent model must be an object");
+    return {
+        provider: requiredString(model.provider, "model provider"),
+        id: requiredString(model.id, "model id"),
+    };
+}
+function parseThinking(raw) {
+    if (!isThinkingLevel(raw))
+        throw new Error("invalid agent thinking level");
+    return raw;
+}
 function parseLaunch(raw) {
     if (raw === undefined)
         return undefined;
@@ -83,20 +97,19 @@ function parseLaunch(raw) {
     if (!value)
         throw new Error("agent launch policy must be an object");
     const launch = {};
-    if (value.model !== undefined) {
-        const model = record(value.model);
-        if (!model)
-            throw new Error("agent model must be an object");
-        launch.model = {
-            provider: requiredString(model.provider, "model provider"),
-            id: requiredString(model.id, "model id"),
-        };
+    if (value.model !== undefined)
+        launch.model = parseModel(value.model);
+    if (value.thinking !== undefined)
+        launch.thinking = parseThinking(value.thinking);
+    if (value.role !== undefined) {
+        if (value.role !== "lead")
+            throw new Error("agent role must be lead");
+        launch.role = "lead";
     }
-    if (value.thinking !== undefined) {
-        if (!isThinkingLevel(value.thinking)) {
-            throw new Error("invalid agent thinking level");
-        }
-        launch.thinking = value.thinking;
+    if (value.design !== undefined) {
+        if (value.design !== true || launch.role !== "lead")
+            throw new Error("agent design must be true, on a lead");
+        launch.design = true;
     }
     return Object.keys(launch).length ? launch : undefined;
 }
@@ -136,7 +149,7 @@ export class TaskDefinitions {
             revision: 1,
             trigger: draft.trigger,
             action: draft.action,
-            callback: draft.callback ?? { type: "none" },
+            callback: draft.callback ?? { type: "conversation" },
             timeoutSeconds: draft.timeoutSeconds ?? DEFAULT_TIMEOUT,
             nextRunAt: null,
             creator,
@@ -321,7 +334,7 @@ export class TaskDefinitions {
         if (raw === undefined)
             return undefined;
         const value = record(raw);
-        if (!value || (value.type !== "none" && value.type !== "origin" && value.type !== "session")) {
+        if (!value || (value.type !== "conversation" && value.type !== "none" && value.type !== "origin" && value.type !== "session")) {
             throw new Error("invalid callback");
         }
         if (value.type !== "session")

package/dist/tasks/execution.js

@@ -1,8 +1,11 @@
 // One queued run carried to a result: dispatched by action kind, abortable,
 // settled exactly once. The lifecycle command.ts and agent.ts share.
 import { logger } from "../log.js";
+import { settleCallback } from "./callbacks.js";
 import { runBash } from "./command.js";
+import { INTERRUPTED } from "./store.js";
 const log = logger("tasks");
+const SHUTDOWN = Symbol("shutdown");
 export class TaskExecution {
     store;
     definitions;
@@ -20,9 +23,11 @@ export class TaskExecution {
     start(run) {
         void this.execute(run);
     }
+    /** Shutdown: the abort still kills each detached bash group, which boot
+     *  recovery could not, but the run ends as that recovery would record it. */
     stop() {
         for (const controller of this.controllers.values())
-            controller.abort();
+            controller.abort(SHUTDOWN);
     }
     cancel(id) {
         log.info(`run ${id} cancel requested`);
@@ -74,9 +79,11 @@ export class TaskExecution {
         }
         catch (error) {
             // A killed child reports `exited null`; report why we aborted instead.
+            // The first abort's reason wins: a shutdown after a user cancel stays cancelled.
             const aborted = controller.signal.aborted;
-            run.state = aborted ? (timedOut ? "failed" : "cancelled") : "failed";
-            run.error = timedOut ? "task timed out" : aborted ? "cancelled" : String(error);
+            const interrupted = aborted && !timedOut && controller.signal.reason === SHUTDOWN;
+            run.state = aborted ? (timedOut ? "failed" : interrupted ? "interrupted" : "cancelled") : "failed";
+            run.error = timedOut ? "task timed out" : interrupted ? INTERRUPTED : aborted ? "cancelled" : String(error);
             cause = timedOut ? run.error : error;
         }
         finally {
@@ -92,8 +99,7 @@ export class TaskExecution {
                 log.debug(`${settled} (watch did not match)`);
             else
                 log.info(settled);
-            if (run.callbackSessionId)
-                run.callbackState = "pending";
+            settleCallback(run, this.store);
             this.controllers.delete(run.id);
             try {
                 this.store.saveRun(run);

package/dist/tasks/groups.js

@@ -13,12 +13,14 @@ export class TaskGroups {
     host;
     changed;
     unreachable;
+    headOf;
     outbox;
-    constructor(store, router, host, changed, unreachable) {
+    constructor(store, router, host, changed, unreachable, headOf = (id) => id, milestone) {
         this.store = store;
         this.host = host;
         this.changed = changed;
         this.unreachable = unreachable;
+        this.headOf = headOf;
         this.outbox = new Outbox(router, {
             id: (group) => group.id,
             reload: (id) => this.store.getGroup(id),
@@ -31,6 +33,7 @@ export class TaskGroups {
                 origin: { kind: "task-callback", taskId: groups[0].id, runId: groups[0].id, sourceSessionId: null },
             }),
             abandoned: (group, sessionId, why) => unreachable(sessionId, `the result of a ${String(group.memberRunIds.length)}-run group`, why),
+            milestone,
         });
     }
     /** Enqueues every member or none: a partially started group is worse than
@@ -141,7 +144,7 @@ export class TaskGroups {
         const group = this.store.getGroup(candidate.id);
         if (!group?.callbackSessionId || (group.callbackState !== "pending" && group.callbackState !== "failed"))
             return;
-        await this.outbox.deliver(group.callbackSessionId, [group]);
+        await this.outbox.deliver(this.headOf(group.callbackSessionId), [group]);
     }
     text(group) {
         const members = group.memberRunIds.map((id) => this.host.getRun(id));

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,88 @@
+// 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, openRunText } from "../core/reply.js";
+import { LEDGER_WINDOW_MS, NOT_IN_LEDGER, TASK_RUN_STATES } from "../core/types.js";
+import { logger } from "../log.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 awaiting = new Set(designs.flatMap((d) => (d.targetSessionId ? [d.targetSessionId] : [])));
+    const statusOf = (named) => named.some((r) => IN_FLIGHT.has(r.state) || (r.targetSessionId && router.stateOf(r.targetSessionId) === "streaming"))
+        ? "running"
+        : named.some((r) => r.targetSessionId && awaiting.has(r.targetSessionId))
+            ? "waiting on you"
+            : named.length && named.every((r) => r.state === "succeeded") ? "pending release" : "waiting on you";
+    // 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 ?? { 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);
+        return { problem: row.problem, stage: row.stage, runs: named, status: statusOf(named) };
+    });
+    const unlisted = runs.filter((r) => IN_FLIGHT.has(r.state) && !tracked.has(r.targetSessionId ?? r.runId));
+    for (const r of unlisted)
+        tracked.add(r.targetSessionId ?? r.runId);
+    const unheld = designs.filter((d) => !tracked.has(d.targetSessionId ?? d.runId)).map((d) => {
+        const named = [runs.find((r) => d.targetSessionId && r.targetSessionId === d.targetSessionId) ?? d];
+        return { problem: d.name, stage: "", runs: named, status: statusOf(named) };
+    });
+    const all = [...items, ...unheld];
+    // Every shown lead's workers in one read: a ledger call per lead grows with the list.
+    const leads = tasks.store.leads();
+    const leadOf = (r) => (r.state !== NOT_IN_LEDGER && r.targetSessionId && leads.has(r.targetSessionId) ? r.targetSessionId : null);
+    const shown = new Set([...all.flatMap((i) => i.runs), ...unlisted].flatMap((r) => leadOf(r) ?? []));
+    const counts = new Map([...shown].map((id) => [id, Object.fromEntries(TASK_RUN_STATES.map((s) => [s, 0]))]));
+    for (const w of shown.size ? tasks.store.ledgerRuns([...shown], since) : []) {
+        const c = w.invokedBySessionId ? counts.get(w.invokedBySessionId) : undefined;
+        if (c)
+            c[w.state] += 1;
+    }
+    const withWorkers = (r) => {
+        const workers = counts.get(leadOf(r) ?? "");
+        return workers ? { ...r, workers: { ...workers } } : r;
+    };
+    return {
+        items: all.map((i) => ({ ...i, runs: i.runs.map(withWorkers) })),
+        unlisted: unlisted.map(withWorkers),
+    };
+}
+/** 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;
+}
+/** An `unlisted` run's stage: main named it in no item. */
+const UNLISTED = "not on the list";
+/** `status` is an item's, or `queued` for an unlisted run not started, as the panel tags it. */
+const itemLine = (i, now) => `- ${i.problem}${i.stage ? ` — ${i.stage}` : ""} (${i.status})${i.runs.map((r) => ` · ${openRunText(r, now)}`).join("")}`;
+/** The one string every surface shows for the open items: `/status` and the seed.
+ *  Grouped as the status panel groups them (web/ui/drawer.ts): what waits on the user first. */
+function renderOpenItems({ items, unlisted }, now) {
+    if (!items.length && !unlisted.length)
+        return "Nothing open.";
+    const waiting = items.filter((i) => i.status !== "running").map((i) => itemLine(i, now));
+    const running = [
+        ...items.filter((i) => i.status === "running").map((i) => itemLine(i, now)),
+        ...unlisted.map((r) => itemLine({ problem: r.name, stage: UNLISTED, runs: [r], status: r.state === "queued" ? "queued" : "running" }, now)),
+    ];
+    return [
+        ...(waiting.length ? ["Waiting on you", ...waiting] : []),
+        ...(running.length ? ["In progress", ...running] : []),
+    ].join("\n");
+}
+/** `/status`'s card: the text, and run id → session id for every run it names that has one. */
+export function openItemsStatus(open, now) {
+    const sessions = Object.fromEntries([...open.items.flatMap((i) => i.runs), ...open.unlisted]
+        .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) {