mixdog 1.3.3 → 1.3.5

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

@@ -33,10 +33,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;
@@ -158,10 +160,25 @@ 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: `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;
@@ -186,6 +203,7 @@ 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;
@@ -211,7 +229,32 @@ export function latestTurnOutcome(messages, runId) {
   }
   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 };
+  const last = turnId === id ? null : submissionOutcome(list.slice(turnAt), turnId);
+  return {
+    id,
+    outcome: submissionOutcome(turn, id),
+    at: Number(ended?.meta?.transcript?.at) || 0,
+    ambiguous,
+    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,16 +264,72 @@ 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. */
@@ -255,22 +354,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).
@@ -305,8 +419,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 +430,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,8 +466,12 @@ 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.
+ *  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.
  *  `finish(status, text)` runs once; `check` re-evaluates (call it on every
  *  state change of `runtime`), `stop` ends the wait. */
 function followTaskToFinal(
@@ -364,10 +482,10 @@ function followTaskToFinal(
   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() {
+  // progress, and the wait for the final one goes on. `latest`: the chain's
+  // latest turn (turnChain).
+  async function reportProgress(latest) {
     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;
@@ -383,6 +501,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 +510,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,21 +549,25 @@ 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;
+    // 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 reportProgress(latest);
       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 reportProgress(latest);
       return null;
     }
     if (immediate && (!latest || latest.id === runId)) return { key: runId, ...immediate };
@@ -635,9 +767,7 @@ 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)),
+      ...(watch.textOnly || text === GONE_TEXT || text === LOST_TEXT ? {} : await artifactFields(sessionId, turnId)),
     });
   if (!(await loadSession(sessionId))) return finish('cancelled', GONE_TEXT);
   let runtime;
@@ -737,6 +867,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(service(), 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.
@@ -796,18 +928,62 @@ export function createAgentTaskSessions({
       follow
     );
 
+  // Sends one turn answers settle together with the same `detail` object: a
+  // send steered into the turn while it ran, or queued and taken as one batch.
+  // That turn reports once, closing every one of them.
+  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 joinSettlement(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);
+  }
+
   /** 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 (joinSettlement).
+    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).
@@ -828,7 +1004,11 @@ export function createAgentTaskSessions({
             // may receive them (reportOrigin `textOnly`).
             ...(status === 'blocked' || status === 'working'
               ? {}
-              : { watchId: id, ...(origin.textOnly ? {} : await artifactFields(sessionId, id, runtime)) }),
+              : {
+                  watchId: id,
+                  ...(sendIds.length > 1 ? { watchIds: sendIds } : {}),
+                  ...(origin.textOnly ? {} : await artifactFields(sessionId, id, runtime)),
+                }),
           })
         )
         .catch((error) => log(`report of ${sessionId} failed: ${error?.message || error}`));
@@ -836,6 +1016,31 @@ export function createAgentTaskSessions({
     // 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` (joinSettlement). */
+    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) => {
+          unwatch();
+          await report(endStatus, endText);
+        },
+        progress: (progressText) => report('working', progressText),
+      });
+      follow.check();
+    };
     try {
       if (notify) {
         runtime = await sessions.materializeSession(sessionId);
@@ -854,6 +1059,9 @@ export function createAgentTaskSessions({
         ? wrapAgentMessage(prompt, { name: origin.envelopeName, agentId: origin.agentId })
         : prompt;
       const take = submit ?? ((options) => sessions.submitSession({ sessionId, prompt: sent, options }));
+      // Submission order: the earliest of the sends one turn answers reports for them.
+      sendCount += 1;
+      const seq = sendCount;
       result = await take({
         id,
         mode: 'prompt',
@@ -864,6 +1072,8 @@ export function createAgentTaskSessions({
           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 } : {}),
         },
         ...(notify
           ? {
@@ -871,29 +1081,13 @@ export function createAgentTaskSessions({
               // 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) =>
+                joinSettlement(detail, origin, {
+                  seq,
+                  id,
+                  unwatch: () => unwatch(),
+                  settle: (answered) => settleTurn(detail, answered),
+                }),
             }
           : {}),
       });
@@ -909,6 +1103,8 @@ export function createAgentTaskSessions({
     }
     return {
       accepted,
+      // Names this send; its terminal report carries it back (routine.sendId).
+      ...(accepted && notify ? { sendId: id } : {}),
       reportsBack: accepted && notify,
       ...(accepted && !notify ? { reportsBackReason: noReport } : {}),
     };
@@ -954,7 +1150,15 @@ 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() : '';
@@ -984,10 +1188,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,
@@ -1052,10 +1264,11 @@ export function createAgentTaskSessions({
     });
     // 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
     );

package/src/session-runtime/agent-tool-routing.mjs

@@ -4,12 +4,57 @@
  * status for the facade.
  */
 
-export function createRoutedAgentTool({ rt, agentTool, executeAgentControl = null }) {
+import { clean } from '../runtime/shared/clean.mjs';
+
+const lower = (value) => clean(value).toLowerCase();
+
+// A pinned model named by its catalog display name ("GPT-6.1-Sol") is not a
+// wire id. Canonicalize it only on an unambiguous EXACT match: the id itself,
+// or a display name / label, case-insensitively, within the requested provider
+// (or across providers when none is given and exactly one row matches).
+// Anything else — no match, several matches, an empty or partial catalog —
+// returns the args unchanged: the catalog never refuses a model and never
+// substitutes a near one.
+export function canonicalizePinnedModel(args, rows) {
+  const model = clean(args?.model);
+  if (!model || !Array.isArray(rows)) return args;
+  const provider = lower(args.provider);
+  const pool = rows.filter((row) => row && (!provider || lower(row.provider) === provider));
+  const wanted = model.toLowerCase();
+  const exactId = pool.filter((row) => row.id === model);
+  // A partial catalog may lack the real id a display name collides with, so
+  // only an exact id can pass there; aliases wait for a complete catalog.
+  const partial = pool.some((row) => row.catalogPartial === true);
+  const hits = exactId.length
+    ? exactId
+    : partial
+      ? []
+      : pool.filter((row) => lower(row.id) === wanted || lower(row.display) === wanted || lower(row.label) === wanted);
+  const distinct = [...new Map(hits.map((row) => [`${row.provider}\n${row.id}`, row])).values()];
+  if (distinct.length !== 1) return args;
+  const [hit] = distinct;
+  if (hit.id === model && hit.provider === args.provider) return args;
+  return { ...args, provider: hit.provider, model: hit.id };
+}
+
+// `listProviderModels` is this runtime's provider catalog. The agent control
+// behind `executeAgentControl` (the daemon's canonical agent) has none, so a
+// display-name model is canonicalized here before it is forwarded. Only the
+// cached/quick catalog is read, so a spawn never waits on provider listings.
+export function createRoutedAgentTool({ rt, agentTool, executeAgentControl = null, listProviderModels = null }) {
   const routedAgentTool = {
     ...agentTool,
-    execute(args, context = {}) {
-      if (typeof executeAgentControl === 'function') return executeAgentControl(args, context);
-      return agentTool.execute(args, context);
+    async execute(args, context = {}) {
+      if (typeof executeAgentControl !== 'function') return agentTool.execute(args, context);
+      let routedArgs = args;
+      if (typeof listProviderModels === 'function' && clean(args?.model) && (clean(args.type) || 'spawn') === 'spawn') {
+        try {
+          routedArgs = canonicalizePinnedModel(args, await listProviderModels({ quick: true }));
+        } catch {
+          routedArgs = args;
+        }
+      }
+      return executeAgentControl(routedArgs, context);
     },
     closeAll(reason, scope = {}) {
       if (typeof executeAgentControl !== 'function') {