pi-durable-subagents 1.0.7 → 1.0.9

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## 1.0.9
+
+- `status` shows the model a call actually uses: the model of its last
+  provider request. A requested switch not used yet shows as `switching`
+  (also in the brief status), a switch the subagent refused as
+  `switchFailed`. Before, `status` kept the model the execution started with,
+  so a switch that had worked looked as if it had not.
+- `send follow-up` with `model` runs the new generation on that model; it was
+  ignored, and the generation continued on the session's model. A send that
+  names a model replies with `model` and `effect`: `next-request` (a running
+  call switches at its next request), `next-execution` or `next-generation`.
+- `send model` to a call that is asking (hibernated) or still waiting for a
+  slot is recorded and applied when it runs again, instead of being refused
+  with `call-not-running`.
+  A requested model applies once: afterwards the session and the pool choose
+  as before. Withdrawing a follow-up that names a model withdraws the switch
+  too.
+- A provider's refusal of the content (terms of service, usage policy) fails
+  the call at once with that error. It was retried as a lost execution five
+  times and reported as `lost ×5`.
+
+## 1.0.8
+
+- pi stays responsive with a long history: the extension's polling in pi's
+  main thread no longer re-reads it all. Workflow status folds only what a
+  journal appended, the orchestrator ledger is indexed once per change, the
+  attention check reads only this session's workflows, and an open question's
+  card reads only what the child session appended. On a home with 60
+  workflows and 356 calls, the dock refresh went from 4.5 ms to under 1 ms
+  every half second, and an idle pi's busy time from about 4% to 1.5%.
+- Calls finished more than 10 s ago keep their summary only; their transcript
+  is read when shown. pi holds about 100 MB less and garbage collection no
+  longer pauses typing.
+- A change of `config.json` written twice quickly to the same size is no
+  longer missed: the orchestrator compares the file's content.
+
 ## 1.0.7
 
 - Changes to `config.json` (`defaultModel`, `pools`, `providers`, `memory`,

package/README.md

@@ -77,6 +77,12 @@ answer) or failed, and one line per finished workflow. `status` with a wid
 shows one workflow with outputs clipped; add `key` for one call's full result,
 or `full: true` for everything. When a run replies `{submitted: {rid}}`
 (its workflow was not created within 10 s), the rid works wherever a wid does.
+A call's `model` in `status` is the model its last provider request used; a
+requested switch not used yet shows as `switching`, a refused one as
+`switchFailed`. A send naming a model replies with `model` and `effect`
+(`next-request`, `next-execution` or `next-generation`).
+A provider's refusal of the content (terms of service, usage policy) fails the
+call at once with that error instead of retrying it.
 With `tasks` or `chain`, top-level `model`, `timeoutMs`, `budget`, `isolation`,
 `context`, `tools`, `skills` and `once` apply to every step that does not set
 its own; other call fields there, and any of them beside a workflow script,
@@ -90,9 +96,9 @@ it something. Each verb means one thing, and a refusal says what would work:
 |---|---|---|
 | `run` | — | Start one subagent, `tasks` in parallel, a `chain`, or a workflow script. An unknown agent name is refused before anything starts, with the list of agents. |
 | `send steer` | a running subagent | Reaches it at its next safe point. To a finished one: refused, use `follow-up`; To one waiting on its question: it interrupts the question, and the subagent usually asks again; `answer` answers it. |
-| `send follow-up` | a finished subagent | Continues the same session as a new generation (`key@2`). |
+| `send follow-up` | a finished subagent | Continues the same session as a new generation (`key@2`). With `model`, that generation runs on it. |
 | `send answer` | an open question | Answers it once. |
-| `send model` | any subagent | Switches its model at the next request. |
+| `send model` | any subagent | A running one switches at its next request; one asking, hibernated or waiting for a slot launches on it when it runs again. |
 | `stop` | a subagent or a workflow | Final: `stopped`, usage kept, edits left as they are. |
 | `drain` / `resume` | existing workflows | A reversible hold; runs started later are not held. |
 

package/dist/agent/main/snapshots.js

@@ -1,13 +1,14 @@
-import { readdirSync, readFileSync } from "node:fs";
+import { closeSync, openSync, readdirSync, readSync, statSync } from "node:fs";
+import { StringDecoder } from "node:string_decoder";
 import { join } from "node:path";
 import { readJournalSnapshot } from "../../kernel/journal.js";
 import { journalPath, orchLedger } from "../../paths.js";
 import { CT, JT } from "../../types.js";
-import { holdOf } from "../../orchestrator/snapshot.js";
+import { holdOf, ledgerIndex } from "../../orchestrator/snapshot.js";
 /** P15, P25: Read workflow snapshots without modifying another domain's history; a wid with an orchestrator.jsonl
  *  `pruned{wid}` entry is gone (housekeeping), even while its directory is still being removed. */
-export function workflows(home) {
-    const ledger = readJournalSnapshot(orchLedger(home));
+export function workflows(home, origin) {
+    const ledger = readJournalSnapshot(orchLedger(home)), { created: createdBy, pruned } = ledgerIndex(ledger);
     let names;
     try {
         names = readdirSync(join(home, "w"));
@@ -17,21 +18,38 @@ export function workflows(home) {
             throw error;
         names = [];
     }
-    const pruned = new Set(ledger.filter(e => e.type === "pruned").map(e => String(e.wid)));
-    const ids = new Set([...ledger.filter(e => e.type === JT.created).map(e => String(e.wid)), ...names].filter(wid => !pruned.has(wid)));
-    const createdBy = new Map();
-    for (const e of ledger)
-        if (e.type === JT.created && !createdBy.has(e.wid))
-            createdBy.set(e.wid, e);
-    return [...ids].sort().map(wid => {
+    const ids = new Set([...[...createdBy.keys()].map(String), ...names].filter(wid => !pruned.has(wid)));
+    const result = [];
+    for (const wid of [...ids].sort()) {
+        // With an origin wanted, a workflow the ledger attributes to another session is skipped without reading its journal.
+        const known = createdBy.get(wid);
+        if (origin !== undefined && known && known.origin !== origin)
+            continue;
         const entries = readJournalSnapshot(journalPath(home, wid));
-        const created = createdBy.get(wid) ?? entries.find(e => e.type === JT.created);
-        return { wid, origin: created?.origin, entries };
-    });
+        const created = known ?? entries.find(e => e.type === JT.created);
+        if (origin !== undefined && created?.origin !== origin)
+            continue;
+        result.push({ wid, origin: created?.origin, entries });
+    }
+    return result;
 }
 /** P37: a generation opened by a send (possibly after the workflow finished) that has no seal yet is pending work. */
+const opened = new WeakMap();
 export function openGeneration(entries) {
-    return entries.some(g => g.type === "generation" && !entries.some(s => s.type === JT.sealed && String(s.call).endsWith(`/${String(g.key)}@${String(g.gen)}`)));
+    const hit = opened.get(entries);
+    if (hit?.length === entries.length)
+        return hit.open;
+    // Sealed call ids end in `/<key>@<gen>`; collect every such suffix once instead of rescanning per generation.
+    const sealed = new Set();
+    for (const s of entries)
+        if (s.type === JT.sealed) {
+            const call = String(s.call);
+            for (let i = call.indexOf("/"); i >= 0; i = call.indexOf("/", i + 1))
+                sealed.add(call.slice(i));
+        }
+    const open = entries.some(g => g.type === "generation" && !sealed.has(`/${String(g.key)}@${String(g.gen)}`));
+    opened.set(entries, { length: entries.length, open });
+    return open;
 }
 /** P1: Workflow-side pending work shared by every starter: a workflow without JT.done or with an unsealed generation,
  *  unless a drain (stop-all) holds it: held work waits for an explicit resume, which starts the orchestrator itself. */
@@ -65,9 +83,7 @@ function unresolved(entries) {
 /** P15, V7: Select only unresolved, unpresented items owned by this session. */
 export function attention(home, sender, seen) {
     const items = [], shown = new Set(seen.map(s => `${s.id}\0${s.rev}`));
-    for (const workflow of workflows(home)) {
-        if (workflow.origin !== sender)
-            continue;
+    for (const workflow of workflows(home, sender)) {
         for (const item of unresolved(workflow.entries)) {
             const key = `${item.id}\0${item.rev}`;
             if (shown.has(key))
@@ -86,37 +102,96 @@ export function presentText(item) {
         return `Question from ${call}${item.qid ? ` (qid ${item.qid})` : ""}; reply with send kind:"answer" to:"${call}": ${item.text}`;
     return item.text.includes(item.wid) ? item.text : `${where}: ${item.text}`;
 }
-/** P15: Refresh a question against durable workflow and child receipts at request time. */
-export function resolved(home, item) {
-    if (readJournalSnapshot(journalPath(home, item.wid)).some(e => e.type === JT.attentionResolved && e.id === item.id && e.rev === item.rev))
-        return true;
-    if (item.kind !== "question" || !item.session || !item.qid)
-        return false;
-    let text;
+/** Resolutions recorded in one immutable journal snapshot, keyed by id and rev. */
+const resolutions = new WeakMap();
+function resolvedIn(entries) {
+    let done = resolutions.get(entries);
+    if (!done) {
+        done = new Set(entries.filter(e => e.type === JT.attentionResolved).map(e => JSON.stringify([e.id, e.rev])));
+        resolutions.set(entries, done);
+    }
+    return done;
+}
+const asks = new Map(), ASK_SCANS = 64, MARK = 64;
+function ask(scan, line) {
+    if (!line.includes('"ask"'))
+        return;
+    let entry;
+    try {
+        entry = JSON.parse(line);
+    }
+    catch {
+        return;
+    } // a malformed line is skipped, as pi and the session tail do (E4)
+    const msg = entry?.type === "message" ? entry.message : undefined;
+    if (msg?.role === "toolResult" && msg.toolName === "ask" && !msg.isError)
+        scan.answered.add(JSON.stringify([msg.details?.qid, msg.details?.rev]));
+}
+function answeredAsks(path) {
+    let stat;
     try {
-        text = readFileSync(item.session, "utf8");
+        stat = statSync(path);
     }
     catch (error) {
-        if (error.code === "ENOENT")
-            return false;
+        if (error.code === "ENOENT") {
+            asks.delete(path);
+            return undefined;
+        }
         throw error;
     }
-    const lines = text.split("\n");
-    for (let index = 0; index < lines.length; index++) {
-        if (!lines[index])
-            continue;
-        let entry;
-        try {
-            entry = JSON.parse(lines[index]);
+    const identity = `${stat.dev}:${stat.ino}`;
+    let scan = asks.get(path);
+    if (scan) {
+        asks.delete(path);
+        asks.set(path, scan);
+    } // least recently used first
+    const fd = openSync(path, "r");
+    try {
+        // Appending keeps what was read: the bytes just before the old end are still there. Anything else (a replaced or
+        // shorter file, other bytes before the old end) is a rewrite, read again from the start. File times are too coarse
+        // to tell a quick rewrite of the same size, so the bytes are compared.
+        let kept = !!scan && scan.identity === identity && stat.size >= scan.offset;
+        if (kept && scan.mark.length) {
+            const now = Buffer.alloc(scan.mark.length);
+            kept = readSync(fd, now, 0, now.length, scan.offset - now.length) === now.length && now.equals(scan.mark);
+        }
+        if (kept && stat.size === scan.offset)
+            return scan.answered;
+        if (!kept) {
+            scan = { identity, offset: 0, mark: Buffer.alloc(0), pending: "", decoder: new StringDecoder("utf8"), answered: new Set() };
+            asks.set(path, scan);
+            if (asks.size > ASK_SCANS)
+                asks.delete(asks.keys().next().value);
         }
-        catch (error) {
-            if (index >= lines.length - 2)
+        const s = scan;
+        const buffer = Buffer.alloc(Math.min(256 * 1024, Math.max(1, stat.size - s.offset)));
+        while (s.offset < stat.size) {
+            const n = readSync(fd, buffer, 0, Math.min(buffer.length, stat.size - s.offset), s.offset);
+            if (!n)
                 break;
-            throw error;
+            s.offset += n;
+            s.pending += s.decoder.write(buffer.subarray(0, n));
+            s.mark = Buffer.concat([s.mark, buffer.subarray(0, n)]).subarray(-MARK);
+            let end;
+            while ((end = s.pending.indexOf("\n")) >= 0) {
+                ask(s, s.pending.slice(0, end));
+                s.pending = s.pending.slice(end + 1);
+            }
         }
-        const msg = entry.type === "message" ? entry.message : undefined;
-        if (msg?.role === "toolResult" && msg.toolName === "ask" && !msg.isError && msg.details?.qid === item.qid && msg.details?.rev === item.rev)
-            return true;
+        // A last line without its newline counts once it is complete JSON; it stays pending until the newline arrives.
+        if (s.pending)
+            ask(s, s.pending);
+        return s.answered;
     }
-    return false;
+    finally {
+        closeSync(fd);
+    }
+}
+/** P15: Refresh a question against durable workflow and child receipts at request time. */
+export function resolved(home, item) {
+    if (resolvedIn(readJournalSnapshot(journalPath(home, item.wid))).has(JSON.stringify([item.id, item.rev])))
+        return true;
+    if (item.kind !== "question" || !item.session || !item.qid)
+        return false;
+    return answeredAsks(item.session)?.has(JSON.stringify([item.qid, item.rev])) ?? false;
 }

package/dist/agent/main/tool.js

@@ -39,6 +39,13 @@ function call(value, cwd, where) {
     return spec;
 }
 /** v12 §2: Infer unambiguous runs and normalize controls into unchanged wire bodies. */
+/** P12: a send naming a model is answered with that model and when it applies — `next-request` (a running call switches
+ *  at its next provider request), `next-execution` (a call with no live execution launches on it) or `next-generation`
+ *  (a follow-up's new generation runs on it). From the orchestrator ledger's `send-note`. */
+export function sendReceipt(ledger, rid) {
+    const note = ledger.find(e => e.type === "send-note" && e.rid === rid);
+    return note ? { model: String(note.model), effect: String(note.effect) } : {};
+}
 export function request(args, cwd) {
     // v12 §2: Infer run only when one launch form is present; never guess a control verb.
     const launchForms = [args.agent !== undefined || args.task !== undefined, args.tasks !== undefined,
@@ -110,7 +117,9 @@ export function request(args, cwd) {
         const kind = string(args, "kind");
         if (!["steer", "follow-up", "answer", "model"].includes(kind))
             throw new Error("Unsupported send kind");
-        const body = { to: string(args, "to"), kind, ...(kind === "model" ? { model: string(args, "model") } : { message: string(args, "message") }), ...(args.by === "user" ? { by: "user" } : {}) };
+        // follow-up may name the model its continuation runs on (P37); other kinds ignore one.
+        const model = kind === "model" || kind === "follow-up" && args.model !== undefined ? { model: string(args, "model") } : {};
+        const body = { to: string(args, "to"), kind, ...model, ...(kind === "model" ? {} : { message: string(args, "message") }), ...(args.by === "user" ? { by: "user" } : {}) };
         const cond = {};
         if (kind === "answer") {
             cond.qid = string(args, "qid");

package/dist/agent/main.js

@@ -13,7 +13,7 @@ import { dsaHome, orchInbox, orchLedger, orchLock, outboxRoot } from "../paths.j
 import { CT, JT } from "../types.js";
 import { attention, presentText, presented, resolved, unfinishedWorkflow } from "./main/snapshots.js";
 import { isLive, pausedElsewhere, statusBrief, statusCallDetail, statusCompactDetail, statusDetail, statusView, widOfRid } from "../orchestrator/snapshot.js";
-import { parameters, request } from "./main/tool.js";
+import { parameters, request, sendReceipt } from "./main/tool.js";
 import { discoverAgents } from "../compat/agents.js";
 let noteSink;
 /** P16: Queue a UI note for the next boundary without waking the model. */
@@ -303,8 +303,9 @@ export function registerMain(pi, ui) {
                 // The rid is returned so a later send can supersede this one (replaces: [rid]).
                 if (decision.type === "rejected")
                     return { applied: false, reason: sent.kind === "resume" && args.wid === undefined ? resumeElsewhere(String(decision.reason)) : decision.reason, rid: sent.rid };
-                if (sent.kind !== "run")
-                    return { applied: true, rid: sent.rid };
+                if (sent.kind !== "run") {
+                    return { applied: true, rid: sent.rid, ...sendReceipt(ledger(), sent.rid) };
+                }
             }
             if (performance.now() >= deadline || signal?.aborted)
                 break;
@@ -324,7 +325,7 @@ export function registerMain(pi, ui) {
             "Durable asynchronous subagents; run returns {wid} when created (or {submitted:{rid}} while pending). A finished workflow (its notice carries every agent's result) or a question wakes you, so after starting work end your turn: never poll with sleep or repeated status. Crash recovery resumes sessions, not external side effects. Background helper processes (orchestrator, evaluator) exit by themselves about 10 s after all work ends: never kill processes or delete files to 'clean up'. When the user quits pi, this session's running workflows pause (nothing is spent); resume continues them.",
             "run (action optional for exactly one launch form): agent+task; tasks:[call specs] parallel; chain:[call specs] sequential ({previous}); workflow:'./script.js' or source (runs.run(key,spec), runs.all([...]), emit(value), args, runs.input(name)). Optional name, cwd, usageBudget, maxCalls, inputs. With tasks/chain, top-level model, timeoutMs, budget, isolation, context, tools, skills, once are defaults for every step (a step's own value wins); a workflow/source script sets them per runs.run call. timeoutMs is milliseconds of active time (a number); omit it unless a hard limit is needed. Explicit unknown agents are rejected BEFORE creation, with available names; unknown script agents fail only their call.",
             "agents: list names, descriptions, default models and source for this cwd; use these names for run.",
-            "send to:'<wid>/<key>' (bare '<wid>' only for a single-call workflow): steer on a running call delivers at the next safe point (receipt in status/UI); a steer to a call waiting on its question interrupts the question and the subagent usually asks again — use answer to answer it; sealed → finished:<status> — use kind 'follow-up'. follow-up continues a sealed call as generation g+1 or queues after a running turn. answer: give the qid (or just the call, or nothing when one question is open); to and rev are filled in. A question that needs the user's decision goes to the user; if you answer one yourself, tell the user what you chose. model switches at next provider request. Unknown targets list valid addresses. replaces:[rid] supersedes an earlier send.",
+            "send to:'<wid>/<key>' (bare '<wid>' only for a single-call workflow): steer on a running call delivers at the next safe point (receipt in status/UI); a steer to a call waiting on its question interrupts the question and the subagent usually asks again — use answer to answer it; sealed → finished:<status> — use kind 'follow-up'. follow-up continues a sealed call as generation g+1 or queues after a running turn; follow-up model:'provider/id' runs that generation on it. answer: give the qid (or just the call, or nothing when one question is open); to and rev are filled in. A question that needs the user's decision goes to the user; if you answer one yourself, tell the user what you chose. model: a running call switches at its next provider request; an asking, hibernated or queued call launches on it when it runs again; the reply's model/effect (next-request|next-execution|next-generation) says which. status model = model actually used by the last request; switching = requested, not used yet; switchFailed = refused. A provider content refusal (ToS/usage policy) fails the call at once, not retried. Unknown targets list valid addresses. replaces:[rid] supersedes an earlier send.",
             "stop target:<wid|<wid>/<key>> is terminal stopped (usage and partial edits kept); a sealed call → already-sealed:<status>, a finished workflow → terminal:<status>. drain holds existing workflows reversibly (new runs unaffected); resume [wid] releases held workflows. status: without wid, what runs, asks (with its answer address; hibernated:true holds no slot) or failed, finished workflows one line each, provider slots held/limit and the config in effect; wid: one workflow, outputs clipped; wid+key: one call's full result; full:true: everything. A run's rid from {submitted:{rid}} works wherever a wid is expected. revise wid + workflow/source/args starts a revision.",
             "Control replies are {applied:true,rid} or {applied:false,reason,rid} when decided; otherwise {submitted:{rid}} after 10s.",
             ...(agents ? [`Available agents: ${agents}.`] : []),

package/dist/cli/main.js

@@ -65,7 +65,7 @@ export function renderStatus(wf) {
 /** P25, T10: Render the compact status projection shared with the `subagents` tool. */
 export function renderView(view) {
     const lines = view.workflows.map(w => [`${w.wid}@${w.rev}${w.name ? ` ${w.name}` : ""}: ${w.status}${w.followUps ? " (follow-up running)" : ""}${w.error ? ` (${clip(w.error, 200)})` : ""} · ${w.done}/${w.planned ?? w.calls.length}${w.planned === undefined && w.status === "running" ? "+" : ""} done${w.usage.input || w.usage.output || w.usage.costUsd ? ` · ${formatUsage(w.usage)}` : ""}`,
-        ...w.calls.map(c => `  ${c.key}@${c.gen} ${c.status ?? c.phase}${c.hibernated ? " (hibernated, no slot)" : ""}${c.model ? ` ${c.model}` : ""}${c.tools ? ` tools:${c.tools}` : ""}${c.usage ? ` ${formatUsage(c.usage)}` : ""}${c.lastLine ? ` ${JSON.stringify(c.lastLine)}` : c.error ? ` (${c.error})` : ""}`),
+        ...w.calls.map(c => `  ${c.key}@${c.gen} ${c.status ?? c.phase}${c.hibernated ? " (hibernated, no slot)" : ""}${c.model ? ` ${c.model}` : ""}${c.switching ? ` → ${c.switching} (requested)` : ""}${c.switchFailed ? ` (switch refused: ${c.switchFailed})` : ""}${c.tools ? ` tools:${c.tools}` : ""}${c.usage ? ` ${formatUsage(c.usage)}` : ""}${c.lastLine ? ` ${JSON.stringify(c.lastLine)}` : c.error ? ` (${c.error})` : ""}`),
         ...w.attention.map(a => `  ${a.kind}: ${JSON.stringify(a.text.split("\n")[0])}`)].join("\n"));
     if (view.paused)
         lines.unshift(`${view.paused} (pi-durable-subagents resume)`);

package/dist/orchestrator/config.js

@@ -4,7 +4,7 @@
 // config-rejected{hash,error} — a changed file that was not applied; the settings before it stay in effect.
 // A reload changes the shared config object in place: every later read sees it (the next slot acquisition, model
 // resolution or check). Slots already held are kept when a limit drops; timers of running executions keep their period.
-import { readFile, stat } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { contentHash } from "../kernel/ids.js";
 /** The keys the orchestrator reads; config.json also holds pi-side settings (ui, onQuit) that it ignores. */
@@ -85,10 +85,11 @@ function applyInPlace(target, next) {
     Object.assign(t, orchestratorSettings(next));
 }
 /** Identity of the file's current version (taken before a read, so a change during the read is seen next time). */
+/** The version of config.json: its content. File times are too coarse to tell two quick writes of the same size apart
+ *  (a change could be missed for good), and the file is small enough to read once a second. */
 export async function configStamp(path) {
     try {
-        const s = await stat(path);
-        return `${s.ino}:${s.size}:${s.mtimeMs}`;
+        return `=${await readFile(path, "utf8")}`;
     }
     catch (error) {
         if (error.code === "ENOENT")
@@ -96,6 +97,8 @@ export async function configStamp(path) {
         throw error;
     }
 }
+/** The settings of a version read by `configStamp`; invalid JSON throws, as `readConfig` does. */
+export function stampedConfig(stamp) { return stamp === "missing" ? {} : JSON.parse(stamp.slice(1)); }
 /** Watch config.json from the version `stamp` (read at start) and apply each valid change in place. */
 /** `apply` runs the change where readers cannot observe half of it (the executor's admission section). */
 export function watchConfig(options) {
@@ -106,8 +109,9 @@ export function watchConfig(options) {
         if (now === stamp || stopped)
             return;
         let raw;
+        // The content compared is the content applied: a second read could see another version than the stamp.
         try {
-            raw = await readConfig(path);
+            raw = stampedConfig(now);
         }
         catch (error) {
             // A half-written file reads as invalid JSON: retry on the next change of the file, report it once per version.

package/dist/orchestrator/engine.js

@@ -22,6 +22,7 @@ import { EvaluatorClient } from "./evaluator-client.js";
 import { Store, revisionEntries, terminalEntry } from "./store.js";
 import { formatUsage, holdOf, refusedResult, snapshotFromEntries } from "./snapshot.js";
 import { validateCallSpec } from "../compat/spec.js";
+import { parseModel } from "../compat/model.js";
 const tail = (text, n) => text.length > n ? `…${text.slice(-(n - 1))}` : text;
 const charged = (u) => u && (u.input || u.output || u.costUsd) ? formatUsage(u) : undefined;
 const wakeStatus = (status) => {
@@ -330,12 +331,26 @@ export class Engine {
             const seal = wf.journal.entries().find(e => e.type === JT.sealed && e.call === from);
             if (seal && send.kind === 'steer')
                 return { action: 'reject', reason: `finished:${seal.result.status} — use kind "follow-up" to continue it` };
+            if (send.kind === 'follow-up' && send.model !== undefined) {
+                try {
+                    if (!parseModel(send.model).provider)
+                        throw new Error('missing provider');
+                }
+                catch {
+                    return { action: 'reject', reason: 'unknown-model' };
+                }
+            }
             if (seal && send.kind === 'follow-up') {
                 const gen = Math.max(0, ...wf.journal.entries().filter(e => ['call', 'generation'].includes(e.type) && e.key === entry.key).map(e => Number(e.gen))) + 1;
-                const opened = await wf.journal.append('generation', { rid: req.rid, key: entry.key, gen, from, spec: entry.spec, revision: wf.revision, opening: { rid: req.rid, kind: send.kind, message: send.message ?? '' } });
+                // A follow-up's model replaces the continued session's for this generation and those continuing it.
+                const spec = send.model !== undefined ? { ...entry.spec, model: send.model } : entry.spec;
+                if (send.model !== undefined)
+                    await this.note(req.rid, send.model, 'next-generation');
+                const opened = await wf.journal.append('generation', { rid: req.rid, key: entry.key, gen, from, spec, revision: wf.revision, opening: { rid: req.rid, kind: send.kind, message: send.message ?? '' }, ...(send.model !== undefined ? { model: send.model } : {}) });
                 this.dispatchGeneration(wf, opened);
                 return { action: 'apply' };
             }
+            // A follow-up naming a model, queued on unfinished work: the executor records its model request with the message.
             return this.executor.forward(req, this.context(wf, entry));
         }
         else if (req.kind === 'stop') {
@@ -504,6 +519,11 @@ export class Engine {
             this.background(async () => { throw error; });
         });
     }
+    /** The reply to a send that names a model says which model and when it applies (orchestrator ledger `send-note`). */
+    async note(rid, model, effect) {
+        if (!this.ledgers.orch.entries().some(e => e.type === 'send-note' && e.rid === rid))
+            await this.ledgers.orch.append('send-note', { rid, model, effect });
+    }
     ticket(st, entry) {
         const spec = entry.spec, agent = st.wf.pins.agents.find(a => a.name === spec.agent);
         if (!agent)
@@ -511,7 +531,8 @@ export class Engine {
         return { wid: st.wf.wid, widRev: `${st.wf.wid}@${st.wf.revision}`, key: entry.key, gen: entry.gen,
             callId: `${st.wf.wid}@${st.wf.revision}/${entry.key}@${entry.gen}`, spec, agent, workflowBudget: st.wf.pins.usageBudget, cwd: resolve(st.wf.cwd, spec.cwd ?? '.'), journal: st.wf.journal,
             ...(st.wf.pins.origin !== undefined ? { originSession: join(pinnedDir(this.ledgers.home, st.wf.wid), ...(st.wf.revision === 1 ? [] : [`r${st.wf.revision}`]), 'origin.jsonl') } : {}),
-            ...(entry.type === 'generation' ? { continueFrom: entry.from, opening: entry.opening } : {}) };
+            ...(entry.type === 'generation' ? { continueFrom: entry.from, opening: entry.opening } : {}),
+            ...(entry.type === 'generation' && typeof entry.model === 'string' ? { model: entry.model } : {}) };
     }
     sealed(st, entry) {
         if (entry.type === 'refused')