mixdog 1.3.4 → 1.4.0

package/src/session-runtime/agent-task-sessions.mjs

@@ -7,8 +7,13 @@
  * Only turns the origin agent starts (the brief, a later `send` from it)
  * report: when such a turn ends its result is queued durably for the agent's
  * home (agent-home-delivery.mjs), which posts it and wakes the agent once to
- * relay it. A turn blocked on the user's answer or approval posts one faint
- * line instead; the card stays in the task session for the user.
+ * relay it. The session's other answers in that chain (given while work it
+ * handed to its agents still runs) are queued as progress updates that wake
+ * nobody: the agent reads them before its next turn, whatever starts it
+ * (agent-home-delivery.mjs postBeforeTurn), and the final report never
+ * repeats one that already carried its answer. A turn blocked on the user's
+ * answer or approval posts one faint line instead; the card stays in the task
+ * session for the user.
  *
  * An agent's send to any other session reports the same way, by an origin for
  * that send only (reportOrigin). Every reporting turn is also watched durably
@@ -33,10 +38,12 @@ import { clean } from '../runtime/agent/orchestrator/runtime-core/session-text.m
 import { collectTurnArtifacts, handoffContent, sessionRoots, turnSlice } from './handoff-attachments.mjs';
 import { roomMemberOfSession } from '../runtime/agent/orchestrator/session/agent-room.mjs';
 import { wrapAgentMessage } from '../runtime/shared/agent-message-envelope.mjs';
-import { sessionsWithPendingWork } from '../runtime/shared/pending-agent-work.mjs';
+import { hasPendingAgentWork, sessionsWithPendingWork } from '../runtime/shared/pending-agent-work.mjs';
 import { agentTaskIdOfExecution } from './services/agent-tool/restart-notify.mjs';
+import { botChainOf } from '../runtime/shared/bot-hops.mjs';
 import { worktreeError, worktreeNameError } from '../runtime/shared/worktrees/contract.mjs';
 import { samePath } from '../runtime/shared/worktrees/paths.mjs';
+import { readModelCatalog, routeByDisplayName, withEffort } from './task-session-route.mjs';
 import { assertWorktreeMutationAllowed } from './services/worktree-access.mjs';
 
 const TITLE_LIMIT = 60;
@@ -77,12 +84,15 @@ const turnStatus = (detail) =>
 
 const INTERRUPTED = /^\[Request interrupted/;
 
-const messageText = (content) =>
-  typeof content === 'string'
-    ? content
-    : (Array.isArray(content) ? content : [])
-        .map((part) => (typeof part === 'string' ? part : part?.type === 'text' ? part.text || '' : ''))
-        .join('');
+const partText = (part) => {
+  if (typeof part === 'string') return part;
+  return part?.type === 'text' ? part.text || '' : '';
+};
+
+const messageText = (content) => {
+  if (typeof content === 'string') return content;
+  return (Array.isArray(content) ? content : []).map(partText).join('');
+};
 
 /** The submissions a stored user message delivered: a turn's prompt
  *  (`checkpointId`, `submissionIds` of a merged batch) or a steered message. */
@@ -104,13 +114,21 @@ export function submissionIdsOf(message) {
 export function submissionOutcome(messages, runId) {
   const list = Array.isArray(messages) ? messages : [];
   const start = list.findIndex((message) => submissionIdsOf(message).includes(runId));
-  if (start < 0) return null;
+  return start < 0 ? null : outcomeFrom(list, start);
+}
+
+/** submissionOutcome of the turn whose prompt is `list[start]`, read in
+ *  place: the scan stops at that turn's end (its completion, an
+ *  interruption, or the next turn's prompt). */
+function outcomeFrom(list, start) {
   for (let index = start; index < list.length; index += 1) {
     const message = list[index];
     const completion = message?.meta?.transcript?.completion;
     if (completion) {
       const status = turnStatus(completion);
-      const text = status === 'failed' ? completion.detail || '' : message.role === 'assistant' ? message.content : '';
+      let text = '';
+      if (status === 'failed') text = completion.detail || '';
+      else if (message.role === 'assistant') text = message.content;
       return { status, text: messageText(text) };
     }
     if (index === start || message?.role !== 'user') continue;
@@ -140,7 +158,9 @@ const callArguments = (call) => {
  *  no task. Empty when the turn recorded none. */
 function consumedTaskIds(message) {
   const recorded = message?.meta?.transcript?.consumedExecutionIds;
-  const ids = Array.isArray(recorded) ? recorded : message?.meta?.execution?.id ? [message.meta.execution.id] : [];
+  let ids = [];
+  if (Array.isArray(recorded)) ids = recorded;
+  else if (message?.meta?.execution?.id) ids = [message.meta.execution.id];
   return ids.map((id) => (id ? agentTaskIdOfExecution(id) : null));
 }
 
@@ -158,10 +178,27 @@ function consumedTaskIds(message) {
  *  submissionOutcome and when its end was recorded (0 when unknown); null
  *  when no turn took runId. */
 export function latestTurnOutcome(messages, runId) {
+  const chain = turnChain(messages, runId);
+  return chain && { id: chain.id, outcome: chain.outcome, at: chain.at, ambiguous: chain.ambiguous };
+}
+
+/** latestTurnOutcome with what a report's wait needs besides: `answers`,
+ *  every turn of the chain that recorded its end, oldest first (`{ id,
+ *  status, text }`: its submission id and submissionOutcome); `taskIds`, the
+ *  agent tasks the chain's turns started — the only tasks proven the chain's
+ *  — and `busyIsOthers`: the session's last stored turn is one outside the
+ *  chain that recorded no end yet, and a stored turn took the result of every
+ *  one of `taskIds` (only those make a turn the chain's) — a busy session
+ *  then runs that other turn, and no result of the chain can be on its way
+ *  into a turn (woken by it, or steered into the running one) whose prompt or
+ *  steer is not stored yet. */
+function turnChain(messages, runId) {
   const list = Array.isArray(messages) ? messages : [];
   const start = list.findIndex((message) => submissionIdsOf(message).includes(runId));
   if (start < 0) return null;
   const started = new Set();
+  // The agent tasks whose results a stored turn took (as its prompt or steered in).
+  const taken = new Set();
   const startingCalls = new Set();
   let at = start;
   let id = runId;
@@ -170,6 +207,8 @@ export function latestTurnOutcome(messages, runId) {
   // The turn the walk is in: where its prompt is stored and its submission id.
   let turnAt = start;
   let turnId = runId;
+  // Every turn of the chain, in order: where its prompt is stored, its id.
+  const turns = [{ at: start, id: runId }];
   for (let index = start; index < list.length; index += 1) {
     const message = list[index];
     const checkpointId = index > start && message?.role === 'user' ? message.meta?.transcript?.checkpointId : '';
@@ -186,11 +225,13 @@ export function latestTurnOutcome(messages, runId) {
       index > start && message?.role === 'user' && message.meta?.source === 'task-notification'
         ? consumedTaskIds(message)
         : null;
+    for (const taskId of delivered || []) if (taskId) taken.add(taskId);
     if (delivered && !inChain) {
       if (delivered.some((taskId) => taskId && started.has(taskId))) {
         inChain = true;
         at = turnAt;
         id = turnId;
+        if (turns.at(-1).id !== turnId) turns.push({ at: turnAt, id: turnId });
       } else if (!delivered.length || delivered.includes(null)) {
         ambiguous = true;
       }
@@ -209,9 +250,47 @@ export function latestTurnOutcome(messages, runId) {
     if (Array.isArray(message.agentTaskIds)) for (const taskId of message.agentTaskIds) started.add(String(taskId));
     else if (message.toolKind !== 'error') ambiguous = true;
   }
-  const turn = list.slice(at);
-  const ended = turn.find((message) => message?.meta?.transcript?.completion);
-  return { id, outcome: submissionOutcome(turn, id), at: Number(ended?.meta?.transcript?.at) || 0, ambiguous };
+  // Read in place, never on copied suffixes: each chain turn's outcome scan
+  // stops at that turn's end, so the turns' scans cover disjoint stretches
+  // and the whole walk stays linear in the transcript.
+  let ended = null;
+  for (let index = at; index < list.length && !ended; index += 1) {
+    if (list[index]?.meta?.transcript?.completion) ended = list[index];
+  }
+  const last = turnId === id ? null : outcomeFrom(list, turnAt);
+  const answers = [];
+  let outcome = null;
+  for (const chainTurn of turns) {
+    const turnOutcome = outcomeFrom(list, chainTurn.at);
+    if (chainTurn.at === at) outcome = turnOutcome;
+    if (turnOutcome !== 'open') answers.push({ id: chainTurn.id, ...turnOutcome });
+  }
+  return {
+    id,
+    outcome,
+    at: Number(ended?.meta?.transcript?.at) || 0,
+    ambiguous,
+    answers,
+    taskIds: started,
+    busyIsOthers: last === 'open' && [...started].every((taskId) => taken.has(taskId)),
+  };
+}
+
+/** The agent task an owed result reports; null when it names none. */
+function owedTaskId(result) {
+  const executionId = result?.meta?.execution_id;
+  return executionId ? agentTaskIdOfExecution(executionId) : null;
+}
+
+/** The `owed` results that may be the chain's of agent tasks `taskIds`: its
+ *  tasks' and those naming no task (their provenance is missing); every one
+ *  for a null `taskIds` (the whole session). */
+function owedOf(owed, taskIds) {
+  if (!taskIds) return owed;
+  return owed.filter((result) => {
+    const taskId = owedTaskId(result);
+    return !taskId || taskIds.has(taskId);
+  });
 }
 
 /** Whether task session `sessionId` still waits on agent work it handed off,
@@ -221,20 +300,76 @@ export function latestTurnOutcome(messages, runId) {
  *  `agentTaskOwners` (the sessions owning a queued, spawning or running agent
  *  task — one still waiting for admission has no turn in flight, and its pool
  *  row reads `unknown`). An agent task owned by an Agent session under it, at
- *  any depth, counts too: every descendant's pool row names the Lead as owner. */
+ *  any depth, counts too: every descendant's pool row names the Lead as owner.
+ *  `taskIds` narrows it to one chain's agent tasks (chainPendingWork). */
 export function pendingWorkOf(
   sessionId,
-  { agentWorking = new Set(), owed = [], pool = [], agentTaskOwners = new Set() }
+  {
+    agentWorking = new Set(),
+    owed = [],
+    pool = [],
+    agentTaskOwners = new Set(),
+    taskIds = null,
+    working = new Set(),
+    agentTasks = [],
+  }
 ) {
+  if (taskIds) return chainPendingWork(sessionId, taskIds, { owed, pool, agentTaskOwners, working, agentTasks });
   if (agentWorking.has(sessionId) || owed.length > 0 || agentTaskOwners.has(sessionId)) return true;
   if (sessionsWithPendingWork(pool).has(sessionId)) return true;
   return pool.some((row) => row?.ownerSessionId === sessionId && agentTaskOwners.has(String(row.sessionId || '')));
 }
 
+/** The agent work of the chain of Lead `sessionId` whose own agent tasks are
+ *  `taskIds`. `taskIds`: those tasks alone, the only ones proven the chain's
+ *  (no record says which task started a child agent). `sessions`: the Agent
+ *  sessions those tasks run in (`agentTasks` `sessionId`, a pool row's
+ *  `taskId`) and every Agent session under one (pool `parentSessionId`),
+ *  never the Lead — work there may be the chain's, so it only holds the
+ *  report (it may be another's: a session the chain's agent ran in can be
+ *  sent another task, which can spawn children of its own). */
+export function chainClosure(sessionId, taskIds, { pool = [], agentTasks = [] } = {}) {
+  const owned = new Set(taskIds);
+  const sessions = new Set();
+  const join = (id) => {
+    if (!id || id === sessionId || sessions.has(id)) return false;
+    sessions.add(id);
+    return true;
+  };
+  for (const task of agentTasks) if (owned.has(task.taskId)) join(task.sessionId);
+  for (const row of pool) if (owned.has(String(row?.taskId || ''))) join(String(row.sessionId || ''));
+  for (let grown = true; grown; ) {
+    grown = false;
+    for (const row of pool) {
+      if (sessions.has(String(row?.parentSessionId || '')) && join(String(row.sessionId || ''))) grown = true;
+    }
+  }
+  return { taskIds: owned, sessions };
+}
+
+/** pendingWorkOf of the chain of agent tasks `taskIds` alone, with all its
+ *  work (chainClosure): a task it owns or one of its Agent sessions runs
+ *  (`agentTasks`: `{ taskId, sessionId, running }` of this process's agent
+ *  tasks; a pool row's `taskId`) still queued or running, or its result owed
+ *  (or an owed result naming no task), or one of those sessions with a turn
+ *  in flight (`working`), owning a queued or running agent task, or pending
+ *  on its pool row. Other work of the session never counts. */
+function chainPendingWork(sessionId, taskIds, { owed, pool, agentTaskOwners, working, agentTasks }) {
+  const chain = chainClosure(sessionId, taskIds, { pool, agentTasks });
+  const sessionOf = new Map();
+  for (const row of pool) if (row?.taskId) sessionOf.set(String(row.taskId), String(row.sessionId || ''));
+  for (const task of agentTasks) if (task.sessionId) sessionOf.set(task.taskId, task.sessionId);
+  const ofChain = (taskId) => chain.taskIds.has(taskId) || chain.sessions.has(sessionOf.get(taskId));
+  if (owed.some((result) => !owedTaskId(result) || ofChain(owedTaskId(result)))) return true;
+  if (agentTasks.some((task) => task.running && ofChain(task.taskId))) return true;
+  for (const id of chain.sessions) if (working.has(id) || agentTaskOwners.has(id)) return true;
+  return pool.some((row) => chain.sessions.has(String(row?.sessionId || '')) && hasPendingAgentWork(row));
+}
+
 /** The agent results queued for `sessionId` that no turn has taken yet (its
  *  durable pending queue: an agent's completion, a restart failure): `{ text,
  *  meta }` as the notification bus delivers them. */
-export async function owedAgentResults(sessionId) {
+async function owedAgentResults(sessionId) {
   const [{ _getPendingMessagesForSession }, { completionIsDelivered, isCompletionNotificationEntry }] =
     await Promise.all([
       import('../runtime/agent/orchestrator/session/manager/pending-messages.mjs'),
@@ -255,22 +390,37 @@ export async function owedAgentResults(sessionId) {
 }
 
 /** pendingWorkOf over this process's state: the in-flight runtimes, the
- *  durable pending queue, the agent pool and the background agent tasks. */
-export async function taskSessionPendingWork(sessionId, { owedResults = owedAgentResults } = {}) {
-  const [{ inFlightSessionActivity }, { listStoredAgentWorkersAsync }, { activeBackgroundTaskSessionIds }] =
-    await Promise.all([
-      import('../runtime/agent/orchestrator/session/manager/runtime-state.mjs'),
-      import('../runtime/agent/orchestrator/session/store-summary-reader.mjs'),
-      import('../runtime/shared/background-tasks.mjs'),
-    ]);
+ *  durable pending queue, the agent pool and the background agent tasks;
+ *  `taskIds` narrows it to one chain's agent tasks. */
+export async function taskSessionPendingWork(sessionId, { owedResults = owedAgentResults, taskIds = null } = {}) {
+  const [
+    { inFlightSessionActivity },
+    { listStoredAgentWorkersAsync },
+    { activeBackgroundTaskSessionIds, listBackgroundTasks },
+  ] = await Promise.all([
+    import('../runtime/agent/orchestrator/session/manager/runtime-state.mjs'),
+    import('../runtime/agent/orchestrator/session/store-summary-reader.mjs'),
+    import('../runtime/shared/background-tasks.mjs'),
+  ]);
   const { working, agentWorking } = inFlightSessionActivity();
   const agentTaskOwners = activeBackgroundTaskSessionIds({ surface: 'agent' });
-  if (pendingWorkOf(sessionId, { agentWorking, agentTaskOwners })) return true;
-  if ((await owedResults(sessionId)).length) return true;
+  const agentTasks = taskIds ? agentTaskRows(listBackgroundTasks) : [];
+  const live = { agentWorking, agentTaskOwners, taskIds, working, agentTasks };
+  if (pendingWorkOf(sessionId, live)) return true;
+  const owed = await owedResults(sessionId);
+  if (pendingWorkOf(sessionId, { ...live, owed })) return true;
   const pool = await listStoredAgentWorkersAsync({ runningSessionIds: working });
-  return pendingWorkOf(sessionId, { pool, agentTaskOwners });
+  return pendingWorkOf(sessionId, { ...live, owed, pool });
 }
 
+/** This process's agent tasks as pendingWorkOf reads them. */
+const agentTaskRows = (listBackgroundTasks) =>
+  listBackgroundTasks({ surface: 'agent' }).map((task) => ({
+    taskId: task.task_id,
+    sessionId: task.sessionId || null,
+    running: task.status === 'running',
+  }));
+
 // A task session idle with nothing pending must stay so this long before its
 // latest answer is final: a finished agent's result can start the Lead's next
 // turn right after (the desktop notifier's quiet period).
@@ -285,9 +435,6 @@ const LOST_TEXT = 'The message never ran: the app restarted before its turn star
 const GONE_TEXT = 'The session no longer exists.';
 const RESUME_FAILED_TEXT =
   'The agent task session could not continue after the app restarted: its agents’ results never reached it. Check that session.';
-const PENDING_CAP_MS = 30 * 60_000;
-const STILL_WORKING_TEXT =
-  'Still in progress: its agents are still working 30+ minutes after this answer. This is the latest answer; the final one is reported when they finish.';
 // Deliveries of a restarted task session's queued agent results before its
 // report gives up as RESUME_FAILED_TEXT.
 const OWED_WAKE_TRIES = 3;
@@ -305,8 +452,9 @@ const LAST_USED_ROUTE_MAX_PAGES = 20;
 const roomFrom = (originSessionId) => (roomMemberOfSession(originSessionId) ? { from: originSessionId } : {});
 
 /** The route of `modelRef`: a provider/model[@effort…] ref (a superseded
- *  model runs on its successor) or a preset name. */
-async function configModelRoute(modelRef) {
+ *  model runs on its successor), a preset name, else whatever `byName` makes
+ *  of it (a catalog display name; it throws when it names none). */
+async function configModelRoute(modelRef, byName) {
   const [{ modelRouteFields, parseScheduleModelRef }, { migrateCodexRoute }, { loadConfig }] = await Promise.all([
     import('../runtime/shared/schedule-model-ref.mjs'),
     import('../runtime/agent/orchestrator/providers/openai-oauth-catalog-store.mjs'),
@@ -315,13 +463,12 @@ async function configModelRoute(modelRef) {
   const ref = parseScheduleModelRef(modelRef);
   if (ref && typeof ref === 'object') return modelRouteFields(migrateCodexRoute(ref));
   const preset = loadConfig({ secrets: false }).presets?.find((p) => p.id === ref || p.name === ref);
-  if (!preset) throw new Error(`model "${ref}" is neither a provider/model route nor a known preset name`);
-  return modelRouteFields(preset);
+  return preset ? modelRouteFields(preset) : byName(ref);
 }
 
 /** The Lead (Main) route of the config — what a desktop New task starts on.
  *  Null while none is chosen. */
-async function configLeadRoute() {
+export async function configLeadRoute() {
   const [{ modelRouteFields }, { resolveRoute }, { loadConfig }] = await Promise.all([
     import('../runtime/shared/schedule-model-ref.mjs'),
     import('./boot/shared.mjs'),
@@ -352,29 +499,60 @@ async function lastUsedSessionRoute(sessionService) {
 /** Wait for the final answer of the task turn `runId` of `sessionId` ended
  *  completed: the end of the latest turn since it (a Lead that handed work
  *  to agents ends its turn and answers in the turn their results wake),
- *  once the session is idle with no pending agent work (pendingWork) for
- *  `settleMs`. `immediate` is runId's own end, when this process saw it.
- *  `finish(status, text)` runs once; `check` re-evaluates (call it on every
- *  state change of `runtime`), `stop` ends the wait. */
+ *  once that chain has no turn running and no pending agent work
+ *  (pendingWork of its agent tasks) for `settleMs`. Work of the session
+ *  outside the chain (a turn the user typed, its agents) never holds it;
+ *  without the provenance to tell (no stored turn, `ambiguous`) the whole
+ *  session must be idle with none pending. `immediate` is runId's own end,
+ *  when this process saw it.
+ *  Every other answer of the chain — each ended turn a later turn of the
+ *  chain followed, and the latest while its work still runs or its
+ *  provenance is missing — goes to `interim({ id, status, text })` once, in
+ *  chain order (`id`: the submission of the turn that gave it): a progress
+ *  update, which wakes nobody. Every check lists all the chain's ended turns,
+ *  so answers that end close together are each reported. `progressedThrough`:
+ *  the last turn an earlier process reported (the watch's durable mark):
+ *  it and the turns before it are not reported again.
+ *  `finish(status, text, answerId)` runs once (`answerId`: the turn whose
+ *  answer it is, none for a report of no turn); `check` re-evaluates (call it
+ *  on every state change of `runtime`), `stop` ends the wait. */
 function followTaskToFinal(
-  { loadSession, owedResults, deliverCompletion, pendingWork, settleMs, pollMs, pendingCapMs, log },
-  { sessionId, runId, runtime, immediate = null, wakeOwed = false, finish, progress = null }
+  { loadSession, owedResults, deliverCompletion, pendingWork, settleMs, pollMs, log },
+  { sessionId, runId, runtime, immediate = null, wakeOwed = false, finish, interim = null, progressedThrough = '' }
 ) {
-  let progressed = false;
-  let pendingSince = 0;
-  // Agent work still pending `pendingCapMs` after the chain's latest turn
-  // ended: `progress(text)` reports that answer once, marked still in
-  // progress, and the wait for the final one goes on.
-  async function reportProgress() {
-    if (progressed || typeof progress !== 'function') return;
-    const latest = latestTurnOutcome((await loadSession(sessionId))?.messages, runId);
-    let end = latest?.outcome && latest.outcome !== 'open' ? latest.outcome : null;
-    if (immediate && (!latest || latest.id === runId)) end = immediate;
-    if (!end) return;
-    pendingSince ||= Date.now();
-    if (Date.now() - (latest?.at || pendingSince) < pendingCapMs) return;
-    progressed = true;
-    await progress(`${STILL_WORKING_TEXT}\n\n${end.text}`);
+  // The chain's ended answers, oldest first, `{ id, status, text }`; runId's
+  // own is `immediate` when this process saw it. `latest`: turnChain's.
+  const answersOf = (latest) => {
+    const stored = latest?.answers || [];
+    if (!immediate) return stored;
+    return [{ id: runId, ...immediate }, ...stored.filter((answer) => answer.id !== runId)];
+  };
+  // The answers already handed to `interim`, by turn.
+  const interimIds = new Set();
+  /** Hand `answer` to `interim` once; false when that failed (logged): it is
+   *  tried again at the next check, and no later answer goes out before it. */
+  async function reportInterim(answer) {
+    if (!answer?.id || !String(answer.text || '').trim() || typeof interim !== 'function') return true;
+    if (interimIds.has(answer.id)) return true;
+    try {
+      await interim(answer);
+    } catch (error) {
+      log(`progress update of ${sessionId} failed, retried at the next check: ${error?.message || error}`);
+      return false;
+    }
+    interimIds.add(answer.id);
+    return true;
+  }
+  /** Report, in order, every one of `answers` past the durable mark but
+   *  `held` (the final candidate, reported only when it proves not final);
+   *  false, stopping there, at the first that could not be queued. */
+  async function reportEarlier(answers, held) {
+    const through = progressedThrough ? answers.findIndex((answer) => answer.id === progressedThrough) : -1;
+    for (const [index, answer] of answers.entries()) {
+      if (index <= through) interimIds.add(answer.id);
+      else if (answer !== held && !(await reportInterim(answer))) return false;
+    }
+    return true;
   }
   let done = false;
   let checking = false;
@@ -383,6 +561,7 @@ function followTaskToFinal(
   let candidateAt = 0;
   let timer = null;
   let wakes = 0;
+  let otherWakes = 0;
   let wokeAt = 0;
   const unwoken = (why) => {
     log(`${sessionId} could not take its agents' results after the restart: ${why}`);
@@ -391,23 +570,32 @@ function followTaskToFinal(
   // `wakeOwed` (a restarted watch): deliver the agent results queued for
   // the idle session through the notification bus so a turn takes them, at
   // most OWED_WAKE_TRIES times, a poll apart; null while that turn is owed.
-  async function wakeForOwed() {
+  // Every owed result is delivered, but only those of the chain's agent tasks
+  // (owedOf `taskIds`) hold the report or fail it; deliveries of the others
+  // alone have a bound of their own (`otherWakes`).
+  async function wakeForOwed(taskIds) {
     const owed = await owedResults(sessionId);
     if (!owed.length) return undefined;
-    if (Date.now() - wokeAt < pollMs) return null;
-    if (wakes >= OWED_WAKE_TRIES) return unwoken(`still not taken after ${wakes} deliveries`);
-    wakes += 1;
-    wokeAt = Date.now();
-    let delivered = false;
-    try {
-      if (typeof deliverCompletion === 'function') {
-        const results = await Promise.all(owed.map(({ text, meta }) => deliverCompletion(sessionId, text, meta)));
-        delivered = results.some((result) => result === true);
-      }
-    } catch (error) {
-      return unwoken(error?.message || error);
+    const chain = new Set(owedOf(owed, taskIds));
+    const hold = chain.size ? null : undefined;
+    if (Date.now() - wokeAt < pollMs) return hold;
+    if (chain.size ? wakes >= OWED_WAKE_TRIES : otherWakes >= OWED_WAKE_TRIES) {
+      return chain.size ? unwoken(`still not taken after ${wakes} deliveries`) : undefined;
     }
-    return delivered ? null : unwoken('no session runtime took the delivery');
+    if (chain.size) wakes += 1;
+    else otherWakes += 1;
+    wokeAt = Date.now();
+    const outcomes = await Promise.allSettled(
+      owed.map(
+        async ({ text, meta }) =>
+          typeof deliverCompletion === 'function' && (await deliverCompletion(sessionId, text, meta)) === true
+      )
+    );
+    if (!chain.size) return undefined;
+    const ofChain = outcomes.filter((_, index) => chain.has(owed[index]));
+    const failure = ofChain.find((outcome) => outcome.status === 'rejected');
+    if (failure) return unwoken(failure.reason?.message || failure.reason);
+    return ofChain.some((outcome) => outcome.value === true) ? null : unwoken('no session runtime took the delivery');
   }
   const arm = (ms) => {
     clearTimeout(timer);
@@ -421,26 +609,36 @@ function followTaskToFinal(
   const failed = (error) => log(`following ${sessionId} to its final answer failed: ${error?.message || error}`);
   // The end to report now, or null while the task still works.
   async function ready() {
-    if (runtime?.getState?.()?.busy) return null;
-    if (wakeOwed) {
-      const woke = await wakeForOwed();
+    const stored = await loadSession(sessionId);
+    const latest = turnChain(stored?.messages, runId);
+    // The chain's agent tasks; null (the whole session) without its provenance.
+    const taskIds = latest && !latest.ambiguous ? latest.taskIds : null;
+    // Every answer of the chain but its latest turn's is no final one: each
+    // goes out as progress, whatever the session does now.
+    const answers = answersOf(latest);
+    const latestId = latest ? latest.id : runId;
+    const answer = answers.at(-1)?.id === latestId ? answers.at(-1) : null;
+    // An answer that could not be queued holds the chain (later answers, the
+    // final report) until a later check queues it: the poll retries it.
+    if (!(await reportEarlier(answers, answer))) return null;
+    // A busy session may run the chain's turn unless that turn is provably another's.
+    const busy = Boolean(runtime?.getState?.()?.busy);
+    if (busy && !(taskIds && latest.busyIsOthers)) return null;
+    if (wakeOwed && !busy) {
+      const woke = await wakeForOwed(taskIds);
       if (woke !== undefined) return woke;
     }
-    if (await pendingWork(sessionId)) {
-      await reportProgress();
+    if (await pendingWork(sessionId, { taskIds })) {
+      await reportInterim(answer);
       return null;
     }
-    const stored = await loadSession(sessionId);
     if (!stored && !immediate) return { key: 'gone', status: 'cancelled', text: GONE_TEXT };
-    const latest = latestTurnOutcome(stored?.messages, runId);
     // Provenance the chain needs is missing: its answer may not be final.
     if (latest?.ambiguous) {
-      await reportProgress();
+      await reportInterim(answer);
       return null;
     }
-    if (immediate && (!latest || latest.id === runId)) return { key: runId, ...immediate };
-    if (!latest?.outcome || latest.outcome === 'open') return null;
-    return { key: `${latest.id}:${latest.outcome.status}`, ...latest.outcome };
+    return answer && { key: `${answer.id}:${answer.status}`, ...answer };
   }
   async function check() {
     if (done) return;
@@ -466,7 +664,7 @@ function followTaskToFinal(
           arm(candidateAt + settleMs - Date.now());
         } else {
           stop();
-          await finish(end.status, end.text);
+          await finish(end.status, end.text, end.id);
         }
       } while (again && !done);
     } finally {
@@ -624,7 +822,7 @@ async function rearmTaskWatch(
   // The turn that answers: the watched submission's own, or the one it
   // follows (a room member's turn under another submission id).
   const turnId = watch.follows || watch.runId;
-  const finish = async (status, text = '') =>
+  const finish = async (status, text = '', answerId = '') =>
     deliver(watch.agentId, {
       runId: `${watch.runId}_end`,
       taskSessionId: sessionId,
@@ -635,9 +833,8 @@ async function rearmTaskWatch(
       ...(watch.hop > 0 ? { hop: watch.hop } : {}),
       ...roomFrom(watch.homeSessionId),
       watchId: watch.runId,
-      ...(watch.textOnly || text === GONE_TEXT || text === LOST_TEXT
-        ? {}
-        : await artifactFields(sessionId, turnId)),
+      ...progressOf(watch.runId, answerId),
+      ...(watch.textOnly || text === GONE_TEXT || text === LOST_TEXT ? {} : await artifactFields(sessionId, turnId)),
     });
   if (!(await loadSession(sessionId))) return finish('cancelled', GONE_TEXT);
   let runtime;
@@ -682,21 +879,25 @@ async function rearmTaskWatch(
             runId: turnId,
             runtime,
             wakeOwed: true,
-            progress: (text) =>
+            // The turns an earlier process already reported as progress.
+            progressedThrough: watch.progressed || '',
+            interim: (answer) =>
               deliver(watch.agentId, {
-                runId: `${watch.runId}_progress`,
+                runId: progressRunId(watch.runId, answer.id),
                 taskSessionId: sessionId,
                 title: watch.title,
                 status: 'working',
-                text,
+                text: answer.text,
+                progressWatchId: watch.runId,
+                answerId: answer.id,
                 ...(watch.target === 'session' ? { target: 'session' } : {}),
                 ...(watch.hop > 0 ? { hop: watch.hop } : {}),
                 ...roomFrom(watch.homeSessionId),
               }),
-            finish: async (status, text) => {
+            finish: async (status, text, answerId) => {
               done = true;
               unsubscribe();
-              await finish(status, text);
+              await finish(status, text, answerId);
             },
           });
         } else if (end) {
@@ -715,6 +916,161 @@ async function rearmTaskWatch(
   await check();
 }
 
+/** The settlement of sends one turn answers: they settle together with the
+ *  same `detail` object (a send steered into the turn while it ran, or queued
+ *  and taken as one batch), and that turn reports once, closing every one of
+ *  them. `nextSeq()` numbers the sends in submission order: the earliest of
+ *  the sends one turn answers reports for them. */
+function createSendSettlement(log) {
+  const settledTurns = new WeakMap();
+  let sendCount = 0;
+
+  /** Add send `member` (`{ seq, id, unwatch, settle }`) to the settlement
+   *  `detail` of its turn, per reporting conversation. The sends of one turn
+   *  settle in the same tick; after it the earliest (the turn's own, whose
+   *  record holds the whole turn) settles with all their ids and the others
+   *  stand down. */
+  function join(detail, origin, member) {
+    const key = `${origin.agentId}\0${origin.sessionId}`;
+    let groups = settledTurns.get(detail);
+    if (!groups) {
+      groups = new Map();
+      settledTurns.set(detail, groups);
+    }
+    let members = groups.get(key);
+    if (!members) {
+      members = [];
+      groups.set(key, members);
+      const settling = members;
+      void Promise.resolve()
+        .then(() => {
+          const [first, ...others] = settling.sort((a, b) => a.seq - b.seq);
+          for (const other of others) other.unwatch();
+          first.settle(settling.map((entry) => entry.id));
+        })
+        .catch((error) => log(`settling the sends of one turn failed: ${error?.message || error}`));
+    }
+    members.push(member);
+  }
+
+  const nextSeq = () => {
+    sendCount += 1;
+    return sendCount;
+  };
+
+  return { join, nextSeq };
+}
+
+/** The queue row of send `id`'s progress update carrying the answer of turn
+ *  `answerId` (followToFinal `interim`): one per answer, across restarts. */
+const progressRunId = (id, answerId) => `${id}_progress_${answerId}`;
+
+/** The queue row of send `id`'s report of `status`. 'working': a progress
+ *  update (progressRunId), not the end. A wait for approval belongs to the
+ *  target session, not to this send: every watcher of it names the same row,
+ *  so it posts once. */
+const turnReportRunId = (sessionId, id, status, { approvalId = '', answerId = '' } = {}) => {
+  if (status === 'blocked') return `${sessionId}_${approvalId}_blocked`;
+  return status === 'working' ? progressRunId(id, answerId) : `${id}_end`;
+};
+
+/** The report fields naming the progress update that may have carried the
+ *  final answer of turn `answerId` already (the queue then does not repeat
+ *  it); none for a report of no turn. */
+const progressOf = (id, answerId) => (answerId ? { progressRunId: progressRunId(id, answerId) } : {});
+
+/** The handler of send `id`'s task-session state: a wait for the user's
+ *  approval reports blocked once; a later, different one reports again. */
+function approvalWaitReporter(id, report) {
+  // The approval wait last reported.
+  let reportedApproval = null;
+  return (state) => {
+    if (!state.toolApproval) {
+      reportedApproval = null;
+      return;
+    }
+    const approvalId = String(state.toolApproval.id ?? 'approval');
+    if (approvalId === reportedApproval) return;
+    // A send still queued behind the running turn is not the turn
+    // waiting: that turn's own watcher reports it.
+    if ((state.queued || []).some((entry) => entry?.id === id)) return;
+    reportedApproval = approvalId;
+    void report('blocked', '', { approvalId });
+  };
+}
+
+/** The transcript meta of a send from `origin`. `fromAgent`: the sending bot,
+ *  recorded when it writes into another bot's home chat (otherwise the row
+ *  would read as the user's); `hop`: its place in a bot-to-bot chain
+ *  (bot-hops.mjs). */
+const sendTranscriptMeta = (origin) => ({
+  sender: 'lead',
+  ...(origin.envelopeName ? { fromAgent: origin.agentId } : {}),
+  ...(origin.hop > 0 ? { hop: origin.hop } : {}),
+  // The bots that handed this work on, the sender last (bot-hops.mjs).
+  ...(origin.botChain?.length ? { botChain: origin.botChain } : {}),
+});
+
+/** What a send tells its caller once submitted. */
+const sendResult = (accepted, notify, id, noReport) => ({
+  accepted,
+  // Names this send; its terminal report carries it back (routine.sendId).
+  ...(accepted && notify ? { sendId: id } : {}),
+  reportsBack: accepted && notify,
+  ...(accepted && !notify ? { reportsBackReason: noReport } : {}),
+});
+
+/** create's brief and `worktree` location, checked before anything runs. */
+function createRequest(args, callerAgentId, callerScope) {
+  if (!callerAgentId) throw new Error('session: create is only for an agent conversation');
+  const brief = typeof args.brief === 'string' ? args.brief.trim() : '';
+  if (!brief) throw new Error('session: brief is required for action=create');
+  const location = taskLocation(args.worktree);
+  if (location.mode === 'worktree') assertWorktreeMutationAllowed(callerScope, 'session: create with a worktree');
+  return { brief, location };
+}
+
+/** Where create starts (resolveTaskProject). An explicit worktree is never
+ *  silently dropped: it needs a registered Project. */
+function createWhere(args, projects, callerCwd, location) {
+  const where = resolveTaskProject(args.project, { projects, cwd: callerCwd || process.cwd() });
+  const registered = where.project && projects.some((entry) => samePath(entry.path, where.project.path));
+  if (location.mode === 'worktree' && !registered) {
+    throw taskWorktreeFailure(
+      worktreeError('WORKTREE_PROJECT_UNKNOWN', 'A worktree needs a registered Project; run list-projects.', {
+        projectPath: where.project?.path ?? null,
+      })
+    );
+  }
+  return where;
+}
+
+/** The worktree failure `error` of task session `sessionId` whose empty
+ *  session could not be dropped (`dropFailure`): the model must know the
+ *  empty session is still there to delete. */
+const orphanSessionError = (error, sessionId, dropFailure) =>
+  Object.assign(
+    new Error(
+      `${error?.message || error} The empty task session ${sessionId} could not be deleted either (${dropFailure?.message || dropFailure}); delete it with session action=delete session_id=${sessionId}.`
+    ),
+    {
+      ...(typeof error?.code === 'string' ? { code: error.code } : {}),
+      ...(error?.details ? { details: error.details } : {}),
+      orphanSessionId: sessionId,
+      cause: error,
+    }
+  );
+
+/** `ready` resolves once `started()` runs: "Started" lands in the home before
+ *  any report of the brief's turn. */
+function startedGate() {
+  let started = () => {};
+  const ready = new Promise((resolveReady) => {
+    started = resolveReady;
+  });
+  return { ready, started };
+}
+
 export function createAgentTaskSessions({
   getSessionService,
   deliver = async (agentId, report) => (await import('./agent-home-delivery.mjs')).deliverAgentTask(agentId, report),
@@ -737,6 +1093,8 @@ export function createAgentTaskSessions({
   newTaskDefault = async () =>
     (await import('../runtime/agent/orchestrator/config.mjs')).loadConfig({ secrets: false }).worktree?.newTaskDefault,
   modelRoute = configModelRoute,
+  // The model menu's catalog rows, read through the calling session's runtime.
+  modelCatalog = (sessionId) => readModelCatalog(getSessionService(), sessionId),
   // The Lead (Main) route of the config — what a desktop New task starts on.
   leadRoute = configLeadRoute,
   // The model the user last used in a coding session.
@@ -767,9 +1125,6 @@ export function createAgentTaskSessions({
   owedResults = owedAgentResults,
   deliverCompletion = null,
   settleAgentResults = async () => {},
-  // Pending agent work this long after the latest answer reports that answer
-  // as still in progress (once); the final report still follows.
-  pendingCapMs = PENDING_CAP_MS,
   log = (line) => process.stderr.write(`mixdog task sessions: ${line}\n`),
 }) {
   /** The report fields of turn `runId`'s files; none when it produced none. */
@@ -791,61 +1146,106 @@ export function createAgentTaskSessions({
   };
 
   const followToFinal = (follow) =>
-    followTaskToFinal(
-      { loadSession, owedResults, deliverCompletion, pendingWork, settleMs, pollMs, pendingCapMs, log },
-      follow
-    );
+    followTaskToFinal({ loadSession, owedResults, deliverCompletion, pendingWork, settleMs, pollMs, log }, follow);
+
+  const settlement = createSendSettlement(log);
 
   /** Submit `prompt` as the origin agent's turn; its end (and a wait for the
    *  user in it) reports to the agent's home. Resolves on intake. `submit`
    *  takes the turn in another way than a prompt to `sessionId` (a message
    *  into a group room, whose member answers in `sessionId`): given `{ id,
    *  onSettled }`, it resolves `{ accepted }`. */
-  async function agentTurn(sessionId, prompt, origin, id = `atask_${randomUUID()}`, beforeReport = null, submit = null) {
+  async function agentTurn(
+    sessionId,
+    prompt,
+    origin,
+    id = `atask_${randomUUID()}`,
+    beforeReport = null,
+    submit = null
+  ) {
     const sessions = service();
     const target = origin.target === 'session' ? { target: 'session' } : {};
     const { notify, noReport } = await watchTurn({ watches, owner: processToken, log }, sessionId, origin, id);
     const dropWatch = () =>
       watches.remove(id).catch((error) => log(`dropping the watch of ${sessionId} failed: ${error?.message || error}`));
     let runtime = null;
+    // The sends this turn's end closes: this one, plus any that its turn
+    // answered too (createSendSettlement).
+    let sendIds = [id];
     // A report that cannot be queued is retried in this process; when every try
     // fails the durable watch stays and restart recovery delivers it (the queue
     // dedupes by runId, so a retry never posts twice).
-    const report = (status, text = '') =>
-      Promise.resolve(beforeReport)
-        .then(async () =>
-          deliverWithRetries({ deliver, retryDelaysMs, log }, origin.agentId, sessionId, {
-            // 'working': a still-in-progress answer (followToFinal), not the end.
-            runId: `${id}_${{ blocked: 'blocked', working: 'progress' }[status] || 'end'}`,
-            taskSessionId: sessionId,
-            title: origin.title,
-            status,
-            text,
-            ...target,
-            ...(origin.hop > 0 ? { hop: origin.hop } : {}),
-            ...roomFrom(origin.sessionId),
-            // A turn's end brings back the files it produced, when the agent
-            // may receive them (reportOrigin `textOnly`).
-            ...(status === 'blocked' || status === 'working'
-              ? {}
-              : { watchId: id, ...(origin.textOnly ? {} : await artifactFields(sessionId, id, runtime)) }),
-          })
-        )
-        .catch((error) => log(`report of ${sessionId} failed: ${error?.message || error}`));
+    // `answerId`: the turn whose answer a progress update or the end carries.
+    // `deliverReport` rejects once every try failed (a progress update is
+    // tried again at the follow's next check); `report` logs it instead.
+    const deliverReport = (status, text = '', { approvalId = '', answerId = '' } = {}) =>
+      Promise.resolve(beforeReport).then(async () =>
+        deliverWithRetries({ deliver, retryDelaysMs, log }, origin.agentId, sessionId, {
+          runId: turnReportRunId(sessionId, id, status, { approvalId, answerId }),
+          taskSessionId: sessionId,
+          title: origin.title,
+          status,
+          text,
+          ...target,
+          ...(origin.hop > 0 ? { hop: origin.hop } : {}),
+          ...roomFrom(origin.sessionId),
+          // A progress update moves this send's durable mark to its turn
+          // (agent-home-delivery.mjs enqueueTask), in the same write.
+          ...(status === 'working' ? { progressWatchId: id, answerId } : {}),
+          // A turn's end brings back the files it produced, when the agent
+          // may receive them (reportOrigin `textOnly`).
+          ...(status === 'blocked' || status === 'working'
+            ? {}
+            : {
+                watchId: id,
+                ...(sendIds.length > 1 ? { watchIds: sendIds } : {}),
+                ...progressOf(id, answerId),
+                ...(origin.textOnly ? {} : await artifactFields(sessionId, id, runtime)),
+              }),
+        })
+      );
+    const report = (status, text = '', options = {}) =>
+      deliverReport(status, text, options).catch((error) =>
+        log(`report of ${sessionId} failed: ${error?.message || error}`)
+      );
     let unwatch = () => {};
     // Set once the turn ended completed: the report waits for the final answer.
     let follow = null;
     let result;
+    /** This send ends the turn `detail` for the sends `answered` (createSendSettlement). */
+    const settleTurn = (detail, answered) => {
+      sendIds = answered;
+      const status = turnStatus(detail);
+      const text = detail?.result?.content || detail?.error || '';
+      // A failed or cancelled turn reports at once; a completed one
+      // reports the task's final answer (followToFinal).
+      if (status !== 'completed') {
+        unwatch();
+        void report(status, text);
+        return;
+      }
+      follow = followToFinal({
+        sessionId,
+        runId: id,
+        runtime,
+        immediate: { status, text },
+        finish: async (endStatus, endText, answerId) => {
+          unwatch();
+          await report(endStatus, endText, { answerId });
+        },
+        // Each other answer of its chain: a progress update that wakes nobody.
+        interim: (answer) => deliverReport('working', answer.text, { answerId: answer.id }),
+      });
+      follow.check();
+    };
     try {
       if (notify) {
         runtime = await sessions.materializeSession(sessionId);
-        let blocked = false;
+        const onState = approvalWaitReporter(id, report);
         unwatch =
           runtime?.subscribe?.(() => {
             follow?.check();
-            if (blocked || !runtime.getState?.()?.toolApproval) return;
-            blocked = true;
-            void report('blocked');
+            onState(runtime.getState?.() || {});
           }) || unwatch;
       }
       // A bot's send to a session that is not its own task session reaches the
@@ -854,46 +1254,24 @@ export function createAgentTaskSessions({
         ? wrapAgentMessage(prompt, { name: origin.envelopeName, agentId: origin.agentId })
         : prompt;
       const take = submit ?? ((options) => sessions.submitSession({ sessionId, prompt: sent, options }));
+      const seq = settlement.nextSeq();
       result = await take({
         id,
         mode: 'prompt',
-        // `fromAgent`: the sending bot, recorded when it writes into another
-        // bot's home chat (otherwise the row would read as the user's);
-        // `hop`: its place in a bot-to-bot chain (bot-hops.mjs).
-        transcriptMeta: {
-          sender: 'lead',
-          ...(origin.envelopeName ? { fromAgent: origin.agentId } : {}),
-          ...(origin.hop > 0 ? { hop: origin.hop } : {}),
-        },
+        transcriptMeta: sendTranscriptMeta(origin),
         ...(notify
           ? {
               // A room answers this send in a turn under another submission
               // id (one turn for several sends, or a fresh turn for one cut
               // short): the watch follows that turn, recorded before it runs.
               follow: (submissionId) => watches.follow?.(id, submissionId),
-              onSettled: (detail) => {
-                const status = turnStatus(detail);
-                const text = detail?.result?.content || detail?.error || '';
-                // A failed or cancelled turn reports at once; a completed one
-                // reports the task's final answer (followToFinal).
-                if (status !== 'completed') {
-                  unwatch();
-                  void report(status, text);
-                  return;
-                }
-                follow = followToFinal({
-                  sessionId,
-                  runId: id,
-                  runtime,
-                  immediate: { status, text },
-                  finish: async (endStatus, endText) => {
-                    unwatch();
-                    await report(endStatus, endText);
-                  },
-                  progress: (progressText) => report('working', progressText),
-                });
-                follow.check();
-              },
+              onSettled: (detail) =>
+                settlement.join(detail, origin, {
+                  seq,
+                  id,
+                  unwatch: () => unwatch(),
+                  settle: (answered) => settleTurn(detail, answered),
+                }),
             }
           : {}),
       });
@@ -907,11 +1285,7 @@ export function createAgentTaskSessions({
       unwatch();
       if (notify) await dropWatch();
     }
-    return {
-      accepted,
-      reportsBack: accepted && notify,
-      ...(accepted && !notify ? { reportsBackReason: noReport } : {}),
-    };
+    return sendResult(accepted, notify, id, noReport);
   }
 
   const rearm = (watch) =>
@@ -954,24 +1328,18 @@ export function createAgentTaskSessions({
    *  caller is refused and the New task default keeps it in the Project folder. */
   async function create(
     args = {},
-    { callerSessionId, callerAgentId, callerCwd, callerHop = 0, callerScope, attachmentParts = [] } = {}
+    {
+      callerSessionId,
+      callerAgentId,
+      callerCwd,
+      callerHop = 0,
+      callerBotChain = [],
+      callerScope,
+      attachmentParts = [],
+    } = {}
   ) {
-    if (!callerAgentId) throw new Error('session: create is only for an agent conversation');
-    const brief = typeof args.brief === 'string' ? args.brief.trim() : '';
-    if (!brief) throw new Error('session: brief is required for action=create');
-    const location = taskLocation(args.worktree);
-    if (location.mode === 'worktree') assertWorktreeMutationAllowed(callerScope, 'session: create with a worktree');
-    const projects = await listProjects();
-    const where = resolveTaskProject(args.project, { projects, cwd: callerCwd || process.cwd() });
-    // An explicit worktree is never silently dropped: it needs a registered Project.
-    const registered = where.project && projects.some((entry) => samePath(entry.path, where.project.path));
-    if (location.mode === 'worktree' && !registered) {
-      throw taskWorktreeFailure(
-        worktreeError('WORKTREE_PROJECT_UNKNOWN', 'A worktree needs a registered Project; run list-projects.', {
-          projectPath: where.project?.path ?? null,
-        })
-      );
-    }
+    const { brief, location } = createRequest(args, callerAgentId, callerScope);
+    const where = createWhere(args, await listProjects(), callerCwd, location);
     const requestId = `atask_${randomUUID()}`;
     const title = (clean(args.title) || clean(brief.split('\n')[0])).slice(0, TITLE_LIMIT);
     const taskOrigin = {
@@ -984,10 +1352,18 @@ export function createAgentTaskSessions({
     // A task session runs in coding mode under Lead: an explicit model wins,
     // else the Lead route, else the last-used model. Never a model-less
     // session — the composer would show no model and its first turn would fail.
-    const route = clean(args.model)
-      ? await modelRoute(clean(args.model))
+    // The catalog is read only when a display name or an effort needs it.
+    let catalog = null;
+    const catalogRows = async () => (catalog ??= await modelCatalog(callerSessionId));
+    let route = clean(args.model)
+      ? await modelRoute(clean(args.model), async (text) =>
+          routeByDisplayName(text, await catalogRows(), args.effort !== undefined)
+        )
       : (await leadRoute()) || (await lastUsedRoute(service()));
     if (!route) throw new Error('session: no model to start the task session on. Choose a Lead model first.');
+    // An explicit effort is the setting the menu's effort pick makes (session.effort,
+    // Auto effort off); it wins over one a model ref or name carried.
+    if (args.effort !== undefined) route = withEffort(route, args.effort, await catalogRows());
     const sessions = service();
     // Where it starts: the `worktree` option, else the user's New task default
     // for a caller that may provision one. Decided before the session exists,
@@ -1031,31 +1407,17 @@ export function createAgentTaskSessions({
         }
         if (dropFailure) log(`dropping ${sessionId} failed: ${dropFailure?.message || dropFailure}`);
         if (!dropFailure) throw error;
-        // The model must know the empty session is still there to delete.
-        throw Object.assign(
-          new Error(
-            `${error?.message || error} The empty task session ${sessionId} could not be deleted either (${dropFailure?.message || dropFailure}); delete it with session action=delete session_id=${sessionId}.`
-          ),
-          {
-            ...(typeof error?.code === 'string' ? { code: error.code } : {}),
-            ...(error?.details ? { details: error.details } : {}),
-            orphanSessionId: sessionId,
-            cause: error,
-          }
-        );
+        throw orphanSessionError(error, sessionId, dropFailure);
       }
     }
-    // "Started" lands in the home before any report of the brief's turn.
-    let started = () => {};
-    const ready = new Promise((resolveReady) => {
-      started = resolveReady;
-    });
+    const { ready, started } = startedGate();
     // The brief carries the files the agent forwarded (workspace-tools.mjs).
     const prompt = handoffContent(brief, attachmentParts);
+    const botChain = botChainOf(callerBotChain);
     const { accepted, reportsBack, reportsBackReason } = await agentTurn(
       sessionId,
       prompt,
-      callerHop > 0 ? { ...taskOrigin, hop: callerHop } : taskOrigin,
+      { ...taskOrigin, ...(callerHop > 0 ? { hop: callerHop } : {}), ...(botChain.length ? { botChain } : {}) },
       requestId,
       ready
     );