mixdog 1.4.2 → 1.4.3

package/src/session-runtime/resource-mcp-secrets.mjs

@@ -6,7 +6,7 @@ import {
   gmailAppPasswordValue,
   connectorAccountServers,
 } from '../runtime/shared/connector-catalog.mjs';
-import { forgetConnectorAccountHealth, retireConnectorAccount } from '../runtime/connectors/connector-accounts-mcp.mjs';
+import { forgetConnectorAccountHealth } from '../runtime/connectors/connector-accounts-mcp.mjs';
 import { oauthCredentialOf } from './resource-mcp-servers.mjs';
 
 /** Every config `servers` connects with, a multi-account server's accounts
@@ -73,13 +73,13 @@ export function createMcpServerSecrets({
     await forgetUnusedGmailAppPassword(gmailAppPasswordAccount(cfg));
     if (!cfg?.url || !cfg.oauthClientId) return;
     const servers = expandedConfigs(resolveConfiguredMcpCatalog().servers);
-    if (!servers.some((other) => other.url === cfg.url && other.oauthClientId)) await saveOAuthClientSecret(cfg.url, '');
+    if (!servers.some((other) => other.url === cfg.url && other.oauthClientId))
+      await saveOAuthClientSecret(cfg.url, '');
   };
   // A removed account keeps no sign-in another configured server or account
   // does not share: `{ signIn, revoked }` as removeMcpServer reports it.
   const releaseAccount = async (accountCfg) => {
     forgetConnectorAccountHealth(accountCfg.name);
-    retireConnectorAccount(accountCfg.connector, accountCfg.name);
     const address = gmailAppPasswordAccount(accountCfg);
     if (address) {
       const forgotten = await forgetUnusedGmailAppPassword(address);

package/src/session-runtime/resource-plugins-api.mjs

@@ -29,6 +29,7 @@ export function createPluginsResourceApi({ deps, sync, decorate }) {
     pluginsStatus,
     resolveMcpCatalog = () => ({ adoption: null }),
     flushSkillsSave,
+    invalidateSkills,
   } = deps;
   const pluginData = () => cfgMod.getPluginData?.();
 
@@ -59,6 +60,9 @@ export function createPluginsResourceApi({ deps, sync, decorate }) {
       return { plugin, status: pluginsStatus() };
     },
     async updatePlugin(plugin = {}) {
+      // Windows refuses to rename a directory holding an open recursive
+      // skill watch, so drop the watchers before the root is swapped.
+      invalidateSkills?.();
       const updated = registryUpdatePlugin(pluginKey(plugin), { dataDir: pluginData() });
       await adoptPluginServerCopies();
       await sync.reconcilePluginsAndAnnounce();

package/src/session-runtime/routine-executor.mjs

@@ -0,0 +1,152 @@
+/**
+ * A routine (schedule or webhook) may name an executor: a workflow sub-agent
+ * (Worker, …) on its own configured route. Each fire is then carried out by
+ * that sub-agent first, headless and to its end, and only its final report
+ * goes to the owner bot's home thread, which relays it (routine-home-turn.mjs).
+ * No executor = the bot does the work itself, as before.
+ *
+ * The executor is a delegatable workflow agent: never a bot (contact agent) or
+ * Mixy, never one that is unknown or turned off — refused when the routine is
+ * saved (assertRoutineExecutor) and again when it fires (a sub-agent that
+ * disappeared or was turned off since fails the fire; nothing falls back).
+ *
+ * The run is unattended like the bot's own routine turn: it is created under a
+ * session id marked as that routine's run (held-requests.mjs markUnattendedRun)
+ * so the sub-agent's record carries the run stamp (human-gate/delegation.mjs):
+ * it never asks, payments and permanent deletes are refused
+ * (human-gate/run-policy.mjs). A sub-agent session has no `agent`, `session`
+ * or `ask_user` tool (AGENT_WORKER_DENIED_TOOLS), so it can start no task
+ * session and ask nobody.
+ */
+import { randomUUID } from 'node:crypto';
+import { MIXY_AGENT_ID } from '../runtime/agent/orchestrator/session/agent-home.mjs';
+import {
+  BUILTIN_SLOT_AGENT_IDS,
+  normalizeWorkflowId,
+} from '../runtime/agent/orchestrator/runtime-core/workflow-ids.mjs';
+import { storeInlineDocumentPart, storeInlineImagePart } from '../runtime/attachments/store.mjs';
+import { MIXY_BOT_ID } from '../runtime/shared/agent-store.mjs';
+import { automationPromptContent } from '../runtime/shared/automation-attachments.mjs';
+import { routineExecutorHeader } from '../runtime/shared/routine-trigger.mjs';
+import { scheduleOwnerAgentId } from './agent-home-delivery.mjs';
+import { markUnattendedRun } from './held-requests.mjs';
+
+/** `routineExecutorProblem` codes and the error each one raises. */
+export const ROUTINE_EXECUTOR_PROBLEMS = Object.freeze({
+  unknown: (id) => `executor agent "${id}" is not an available sub-agent: pick one from the workflow agents`,
+  'not-agent': (id) =>
+    `executor agent "${id}" is a bot, not a workflow sub-agent: pick a sub-agent such as Worker, or leave it unset`,
+  disabled: (id) => `executor agent "${id}" is turned off: turn it on in the workflow agents or pick another`,
+});
+
+/** The stored form of an executor id: lower-cased with dashes; null for none. */
+export function normalizeExecutorAgentId(value) {
+  const text = typeof value === 'string' ? value.trim() : '';
+  return text ? normalizeWorkflowId(text, text.toLowerCase()) : null;
+}
+
+async function defaultProbe(id) {
+  const [{ workflowHelpers }, { getPluginData, loadConfig }, { isAgentDisabled, isContactAgentId }] = await Promise.all(
+    [
+      import('./boot/shared.mjs'),
+      import('../runtime/agent/orchestrator/config.mjs'),
+      import('../runtime/shared/agent-route-config.mjs'),
+    ]
+  );
+  const dataDir = getPluginData();
+  // The fresh scan: an agent made a moment ago counts.
+  const listed = workflowHelpers.listCustomAgentIds(dataDir).includes(id) && !BUILTIN_SLOT_AGENT_IDS.has(id);
+  const definition = listed ? workflowHelpers.loadAgentDefinition(dataDir, id) : null;
+  return {
+    listed: Boolean(definition),
+    contact: Boolean(definition) && isContactAgentId(id, definition.kind),
+    disabled: isAgentDisabled(loadConfig({ secrets: false }), id),
+  };
+}
+
+/** Why `id` (normalized) cannot execute a routine: a ROUTINE_EXECUTOR_PROBLEMS
+ *  code, '' when it can. `probe(id)` → `{ listed, contact, disabled }`. */
+export async function routineExecutorProblem(id, probe = defaultProbe) {
+  if (id === MIXY_AGENT_ID || id === MIXY_BOT_ID) return 'not-agent';
+  const facts = await probe(id);
+  if (!facts.listed) return 'unknown';
+  if (facts.contact) return 'not-agent';
+  return facts.disabled ? 'disabled' : '';
+}
+
+/** The executor id to store for a save's `executorAgentId` (null/empty = none),
+ *  or the error naming why it cannot be one. */
+export async function assertRoutineExecutor(value, probe = defaultProbe) {
+  if (value == null) return null;
+  if (typeof value !== 'string') throw new Error('executorAgentId must be a sub-agent id (a string) or null');
+  const id = normalizeExecutorAgentId(value);
+  if (!id) return null;
+  const problem = await routineExecutorProblem(id, probe);
+  if (problem) throw new Error(ROUTINE_EXECUTOR_PROBLEMS[problem](id));
+  return id;
+}
+
+/** An inline image/PDF/Office part as the stored reference part a sub-agent's
+ *  prompt may carry (handoff-attachments.mjs admits references only). */
+const referencePart = (part) => (part.type === 'image' ? storeInlineImagePart(part) : storeInlineDocumentPart(part));
+
+/**
+ * Carry out one fire of routine `name` with sub-agent `agentId` and resolve its
+ * final report (trimmed text). `prompt` is the routine's instructions (plus a
+ * webhook's fenced payload); `ownerAgentId` the bot whose run it is. Rejects
+ * when the executor is no longer valid, fails, is cancelled, or `signal` aborts.
+ */
+export async function runRoutineExecutor(
+  {
+    agentId,
+    kind,
+    name,
+    ownerAgentId = null,
+    prompt,
+    // The trusted part of `prompt` (the routine's instructions): the only text
+    // the executor's skills are selected from, never a webhook payload.
+    skillSelection = '',
+    attachments = null,
+    cwd = null,
+    signal = null,
+  },
+  { surface, probe = defaultProbe } = {}
+) {
+  const problem = await routineExecutorProblem(agentId, probe);
+  if (problem) throw new Error(`${kind} "${name}" cannot run: ${ROUTINE_EXECUTOR_PROBLEMS[problem](agentId)}`);
+  if (typeof surface?.runAgent !== 'function') throw new Error('routine run: the agent service is not running');
+  const header = routineExecutorHeader({ kind, name, project: cwd ? String(cwd) : '' });
+  const content = automationPromptContent(`${header}\n\n${prompt}`, attachments);
+  const parts = Array.isArray(content) ? content : [{ type: 'text', text: content }];
+  const attachmentParts = parts.slice(1).map(referencePart).filter(Boolean);
+  // The id the executor is created under: marked as this routine's unattended
+  // run for as long as it works (its record keeps the run stamp afterwards).
+  const parentSessionId = `routine_exec_${randomUUID()}`;
+  const unmark = markUnattendedRun(parentSessionId, {
+    kind,
+    agentId: scheduleOwnerAgentId({ ownerAgentId }),
+    name,
+  });
+  try {
+    const result = await surface.runAgent(
+      {
+        agent: agentId,
+        prompt: parts[0].text,
+        skillSelection: String(skillSelection ?? ''),
+        ...(cwd ? { cwd: String(cwd) } : {}),
+        ...(attachmentParts.length ? { attachmentParts } : {}),
+      },
+      { callerSessionId: parentSessionId },
+      { signal }
+    );
+    return String(result?.content ?? '').trim();
+  } catch (error) {
+    // The caller's own cancellation stays as it is.
+    if (signal?.aborted) throw error;
+    throw new Error(`${kind} "${name}": executor agent "${agentId}" failed: ${error?.message || error}`, {
+      cause: error,
+    });
+  } finally {
+    unmark();
+  }
+}

package/src/session-runtime/routine-home-turn.mjs

@@ -14,7 +14,10 @@
  * (outbound actions are allowed within the bot's permissions; payments and
  * permanent deletes are refused, human-gate/run-policy.mjs). Resolves with the
  * reply once the turn ends; rejects when the turn fails, is cancelled, or the
- * caller's `signal` aborts (which also aborts the turn once it runs). A
+ * caller's `signal` aborts (which also aborts the turn once it runs). With an
+ * `executorAgentId` the fire is first carried out by that sub-agent
+ * (routine-executor.mjs) and the turn holds only its final report, which the
+ * bot relays; the quiet marker as the report wakes nobody and resolves it. A
  * heartbeat turn past its wall-clock cap is aborted and resolves with no reply
  * (`timedOut`).
  */
@@ -25,12 +28,16 @@ import { automationPromptContent } from '../runtime/shared/automation-attachment
 import { ROUTINE_LIMITS } from '../runtime/shared/routine-limits.mjs';
 import {
   HEARTBEAT_TURN_LIMITS,
+  ROUTINE_QUIET,
   isHeartbeatSession,
+  isRoutineQuietReply,
   normalizeRoutineTrigger,
+  routineRelayHeader,
   routineTriggerHeader,
 } from '../runtime/shared/routine-trigger.mjs';
 import { agentHomeLiveSurface, scheduleOwnerAgentId } from './agent-home-delivery.mjs';
 import { markUnattendedRun, unattendedRunOf } from './held-requests.mjs';
+import { runRoutineExecutor } from './routine-executor.mjs';
 
 // Routine turns waiting or running per home thread.
 const waiting = new Map();
@@ -72,6 +79,9 @@ export async function runRoutineTurn(
     // thread and the routine trigger header.
     sessionId = null,
     header = null,
+    // A workflow sub-agent that carries the fire out first (routine-executor.mjs):
+    // the bot's turn then holds only its final report, for the bot to relay.
+    executorAgentId = null,
   },
   {
     surface = agentHomeLiveSurface(),
@@ -79,9 +89,10 @@ export async function runRoutineTurn(
     limit = ROUTINE_LIMITS.homeQueueLimit,
     log = (line) => process.stderr.write(`mixdog routines: ${line}\n`),
     timers = globalThis,
+    executor = runRoutineExecutor,
   } = {}
 ) {
-  const body = String(prompt || '').trim();
+  let body = String(prompt || '').trim();
   if (!body) throw new Error(`${kind} "${name}" has no instructions`);
   if (signal?.aborted) throw abortError(signal);
   if (typeof surface?.submit !== 'function') throw new Error('routine run: the session service is not running');
@@ -91,12 +102,42 @@ export async function runRoutineTurn(
   if (!home || home.closed === true) {
     throw new Error(`the bot "${agentId}" has no chat yet: open it once in the app`);
   }
+  let opening = header || routineTriggerHeader({ kind, name, project: cwd ? String(cwd) : '' });
+  let selection = String(skillSelection ?? body);
+  let turnAttachments = attachments;
+  if (executorAgentId) {
+    const report = String(
+      (await executor(
+        {
+          agentId: executorAgentId,
+          kind,
+          name,
+          ownerAgentId: agentId,
+          prompt: body,
+          skillSelection: selection,
+          attachments,
+          cwd,
+          signal,
+        },
+        { surface }
+      )) ?? ''
+    ).trim();
+    if (signal?.aborted) throw abortError(signal);
+    if (!report) throw new Error(`${kind} "${name}": executor agent "${executorAgentId}" returned no report`);
+    // Nothing to tell: the bot is not woken.
+    if (isRoutineQuietReply(report)) return { sessionId: homeId, result: ROUTINE_QUIET };
+    // The bot only relays the report: it is derived from whatever the executor
+    // read (a webhook's payload included), so it selects no skill.
+    body = report;
+    opening = routineRelayHeader({ kind, name, executor: executorAgentId, project: cwd ? String(cwd) : '' });
+    selection = '';
+    turnAttachments = null;
+  }
   const queued = waiting.get(homeId) || 0;
   if (queued >= limit) throw new Error(`${limit} routine runs already wait in this bot's chat`);
   waiting.set(homeId, queued + 1);
   const trigger = normalizeRoutineTrigger({ kind, name, event });
-  const opening = header || routineTriggerHeader({ kind, name, project: cwd ? String(cwd) : '' });
-  const content = automationPromptContent(`${opening}\n\n${body}`, attachments);
+  const content = automationPromptContent(`${opening}\n\n${body}`, turnAttachments);
   return new Promise((resolve, reject) => {
     let started = false;
     let aborted = false;
@@ -150,7 +191,7 @@ export async function runRoutineTurn(
       restorable: false,
       // Esc ends this fire; it is never put back in the queue.
       abortDiscardOnAbort: true,
-      skillSelection: String(skillSelection ?? body),
+      skillSelection: selection,
       transcriptMeta: { routineTrigger: trigger },
       onCommitted: () => {
         if (started) return;

package/src/session-runtime/runtime-facade.mjs

@@ -24,6 +24,7 @@ export function createRuntimeFacade({
   getOrchestrationMode,
   getOutputStyle,
   getContextStatus,
+  getContextStatusSettled = async (options) => getContextStatus(options),
   getContextStatusForSession,
   renameSessionTitle,
 }) {
@@ -144,6 +145,10 @@ export function createRuntimeFacade({
     contextStatus(options) {
       return getContextStatus(options);
     },
+    /** The context status once an empty session took moved settings (async callers). */
+    contextStatusSettled(options) {
+      return getContextStatusSettled(options);
+    },
     contextStatusForSession(session) {
       return getContextStatusForSession(session);
     },

package/src/session-runtime/runtime-feature-gates.mjs

@@ -6,13 +6,10 @@
 // deps, so the runtime can hand them straight through.
 import {
   builtinFeatureActive,
-  featureDisallowedToolsFor,
   localGitToolsActive,
 } from '../runtime/agent/orchestrator/runtime-core/builtin-features.mjs';
 import { recapEnabled } from '../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
-import { browserBridgeAvailableSync } from '../runtime/browser-bridge/client.mjs';
-import { computerBridgeAvailableSync } from '../runtime/computer-bridge/client.mjs';
-import { terminalBridgeAvailableSync } from '../runtime/terminal-bridge/client.mjs';
+import { liveFeatureDisallowedTools } from '../runtime/agent/orchestrator/runtime-core/tool-availability.mjs';
 
 export function createRuntimeFeatureGates({ getConfig, getToolProfile }) {
   return {
@@ -29,12 +26,6 @@ export function createRuntimeFeatureGates({ getConfig, getToolProfile }) {
     tidyToolEnabledFn: () => builtinFeatureActive(getConfig(), 'tidy'),
     // Browser/Computer activate on live desktop-bridge presence, so the probe
     // runs per call instead of being captured at boot.
-    featureDisallowedTools: () =>
-      featureDisallowedToolsFor(getConfig(), {
-        browserAvailable: browserBridgeAvailableSync(),
-        computerAvailable: computerBridgeAvailableSync(),
-        terminalAvailable: terminalBridgeAvailableSync(),
-        toolProfile: getToolProfile(),
-      }),
+    featureDisallowedTools: () => liveFeatureDisallowedTools(getConfig(), { toolProfile: getToolProfile() }),
   };
 }

package/src/session-runtime/schedule-session-run.mjs

@@ -26,6 +26,7 @@ export async function runScheduleSession(
         kind: 'schedule',
         name: schedule.name,
         ownerAgentId: schedule.ownerAgentId,
+        executorAgentId: schedule.executorAgentId || null,
         prompt: body,
         attachments: schedule.attachments,
         cwd: schedule.cwd || null,

package/src/session-runtime/services/agent-tool/job-task-reconcile.mjs

@@ -84,11 +84,16 @@ export function reconcileJobCancelled(job, value) {
   } catch {}
 }
 
-export function reconcileJobStreamStalled(job, error) {
+/** A turn that threw. `identity` is the owner-facing result shape: a failure
+ *  after answers the turn went on past (error.carriedReport, turn-report.mjs)
+ *  reports them with the failure. */
+export function reconcileJobStreamStalled(job, error, identity = {}) {
   if (!job?.taskId || job._terminalResultValue !== undefined) return;
+  const report = typeof error?.carriedReport === 'string' ? error.carriedReport : '';
   try {
     reconcileBackgroundTask(job.taskId, {
       status: 'failed',
+      ...(report ? { result: { ...identity, content: report } } : {}),
       error,
       terminalReason: 'agent-stream-stalled',
     });

package/src/session-runtime/services/agent-tool/job-views/session-progress.mjs

@@ -4,6 +4,8 @@
 import { resolveAgentWatchdogPolicy } from '../../../../runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs';
 import { buildAgentTaskProgressFields } from '../../agent-task-status.mjs';
 import { getProgressWatchdogState } from '../../agent-watchdog-registry.mjs';
+import { _liveSessions } from '../../../../runtime/agent/orchestrator/session/store/live-state.mjs';
+import { todoProgress } from '../../../../runtime/agent/orchestrator/runtime-core/todo-list.mjs';
 
 // Job statuses that can never progress again (mirrors TERMINAL_STATUSES in
 // runtime/shared/background-tasks.mjs; 'canceled' accepted defensively).
@@ -46,6 +48,11 @@ export function terminalJobFrozenFields(status, now = Date.now()) {
  *  the diagnostics through renderJob/list directly. */
 export function liveAgentStatusRow(row) {
   if (!row || typeof row !== 'object') return row;
+  // The agent's own todo progress, from its live session only (an evicted
+  // idle worker is not re-read on every pulse).
+  const live = row.sessionId ? _liveSessions.get(row.sessionId) : null;
+  const todo = live ? todoProgress(live) : null;
+  if (todo) row = { ...row, todo };
   const {
     silent_for: _silentFor,
     staleSeconds: _staleSeconds,

package/src/session-runtime/services/agent-tool/send-flow.mjs

@@ -7,7 +7,20 @@ import {
   watchdogPartialHandoffFromError,
   watchdogStoppedHandoff,
 } from '../../../runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs';
-import { clean, normalizeAgentName, resolvePrompt } from './helpers.mjs';
+import { reconcileAgentSession } from '../../../runtime/agent/orchestrator/agent-runtime/session-builder.mjs';
+import {
+  agentPresetName,
+  clean,
+  normalizeAgentName,
+  presetKey,
+  readAgentFrontmatterPermission,
+  resolvePrompt,
+} from './helpers.mjs';
+import { normalizeAgentPermission } from '../../../runtime/shared/markdown-frontmatter.mjs';
+import { resolveAgentSessionPermission } from '../../../runtime/agent/orchestrator/internal-agents.mjs';
+import { resolveAgentSpawnPreset } from './spawn-preset.mjs';
+import { flushPendingSessionConfigWrites } from '../../config-lifecycle/config-writers.mjs';
+import { AGENT_ROUTE_KEYS } from '../../agent-profile-changes.mjs';
 import { abnormalEmptyFinishError, renderResult } from './render.mjs';
 import {
   reconcileJobCancelled,
@@ -22,15 +35,38 @@ import { rebindDelegation } from '../../../runtime/agent/orchestrator/session/hu
 import { settledWorkerStatus } from './worker-index/row-liveness.mjs';
 import { whileTurnDispatched } from '../../../runtime/agent/orchestrator/session/manager/runtime-state.mjs';
 import { takeStoppedShellJobs } from '../../../runtime/agent/orchestrator/session/manager/turn-reap.mjs';
+import { turnReportText } from '../../../runtime/agent/orchestrator/session/loop/turn-report.mjs';
 
 function workerResultIdentity({ session, tag, sessionId }) {
   return { tag, sessionId, agent: session.agent || null, provider: session.provider, model: session.model };
 }
 
+/** A reused worker runs with the permission its agent's definition grants
+ *  now, resolved as a spawn resolves it (spawn-plan.mjs). */
+export function followAgentPermission(session, { dataDir, sourceRoot }) {
+  const agent = normalizeAgentName(session?.agent);
+  if (!agent || !dataDir) return;
+  const defined = normalizeAgentPermission(readAgentFrontmatterPermission(agent, dataDir, sourceRoot));
+  const permission = resolveAgentSessionPermission(agent, defined || null);
+  if (permission) session.permission = permission;
+  else delete session.permission;
+}
+
 // `send` to an existing worker: resolve the live session, run one follow-up
 // turn under the progress watchdog, and reconcile the job/worker row. Busy
 // sessions queue the prompt instead.
-export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionSurface, registry, views, spawnFlow }) {
+export function createSendFlow({
+  mgr,
+  cfgMod = null,
+  dataDir = null,
+  STANDALONE_SOURCE_ROOT = null,
+  defaultCwd,
+  sessionSurface,
+  canUseSessionSurface,
+  registry,
+  views,
+  spawnFlow,
+}) {
   async function prepareSend(args, context = {}) {
     registry.refreshTagsFromSessions({ scanSessions: registry.wantsSessionScan(args), context });
     const target = clean(args.tag || args.sessionId);
@@ -51,7 +87,7 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
       const abnormalError = abnormalEmptyFinishError(result, session.agent || sendAgent);
       return {
         ...workerResultIdentity({ session, tag, sessionId }),
-        content: result?.content || '',
+        content: turnReportText(result),
         ...(sessionSurface?.canonical === true ? { handoffOnly: true } : {}),
         ...(abnormalError ? { error: abnormalError } : {}),
       };
@@ -82,6 +118,13 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
       if (canUseSessionSurface(session)) {
         return sessionSurface.runTurn({ session, prompt, context: args.context || null, cwd, ...turnHooks });
       }
+      // An in-process session has no turn start of its own to reconcile it
+      // (a canonical child's runtime does, reconcileTurnSettings): bring its
+      // settings-gated tools, connectors, compaction, prompt settings and its
+      // agent's permission (as its definition stands: a narrowed one applies)
+      // to the settings now.
+      reconcileAgentSession(session);
+      followAgentPermission(session, { dataDir, sourceRoot: STANDALONE_SOURCE_ROOT });
       return mgr.askSession(sessionId, prompt, args.context || null, null, cwd, null, turnHooks);
     });
   }
@@ -129,7 +172,7 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
       handoffMsgStart = resolveHandoffMessageStartIndex(mgr.getSession(sessionId));
       const turnHooks = buildTurnHooks({ sessionId, notifyContext, job, turnReview, completionValue });
       const result = await runTurn(prepared, turnHooks);
-      // Early preview no longer suppresses the canonical body notification;
+      // The early preview does not suppress the canonical body notification;
       // notifyTaskCompletion fires once with output via resolve/reconcile.
       const finalValue = completionValue(result);
       if (job?.status === 'cancelled') {
@@ -162,7 +205,7 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
       }
       finalStatus = 'error';
       noteStoppedShellJobsOnError(error, await takeStoppedShellJobs(sessionId));
-      reconcileJobStreamStalled(job, error);
+      reconcileJobStreamStalled(job, error, workerResultIdentity({ session, tag, sessionId }));
       throw error;
     } finally {
       turnReview.complete();
@@ -204,8 +247,69 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
   // `send` branch AND by the `spawn` branch when an explicit tag maps to a
   // live session (reuse path). Busy sessions queue the prompt; idle ones run a
   // background send job that continues the existing session (context kept).
+  // A worker that runs on its agent's configured route follows that route, as
+  // a bot's home chat does (agent-route-follow.mjs): a model picked for the
+  // agent since the spawn applies from this send. A worker started on an
+  // explicit model or preset keeps it.
+  async function agentRouteToFollow({ session }) {
+    const agent = normalizeAgentName(session?.agent);
+    if (!agent || !cfgMod?.loadConfig) return null;
+    await flushPendingSessionConfigWrites();
+    let current;
+    try {
+      current = resolveAgentSpawnPreset(cfgMod.loadConfig(), { agent });
+    } catch {
+      return null;
+    }
+    const spawnedOn = clean(session.presetName || session.preset);
+    const own = new Set([`agent-${agent}`, agentPresetName(agent), presetKey(current.preset), current.presetName]);
+    if (!spawnedOn || !own.has(spawnedOn)) return null;
+    const preset = current.preset;
+    if (!preset.provider || !preset.model) return null;
+    // Every route key the agent's route sets (an effort or Fast change alone
+    // included); a key it leaves unset is the route default either way.
+    const value = (key, source) => {
+      if (key === 'fast') return source?.fast === true;
+      if (key === 'autoEffort') return source?.autoEffort !== false;
+      return source?.[key] == null ? null : JSON.stringify(source[key]);
+    };
+    const set = AGENT_ROUTE_KEYS.filter(
+      (key) => key === 'fast' || key === 'autoEffort' || (preset[key] !== undefined && preset[key] !== null)
+    );
+    const matches = (target) => set.every((key) => value(key, preset) === value(key, target));
+    // Against the route the session's next turn runs on: one held for it
+    // (heldRoute, an in-process worker that was busy), else its own.
+    if (matches(session)) {
+      // Saved back to the running route: an earlier hold is obsolete.
+      if (session.heldRoute) mgr.holdSessionRoute?.(session.id, null);
+      return null;
+    }
+    if (session.heldRoute && matches({ ...session, ...session.heldRoute })) return null;
+    const route = {};
+    for (const key of set) {
+      if (key === 'fast') route.fast = preset.fast === true;
+      else if (key === 'autoEffort') {
+        if (preset.autoEffort === false) route.autoEffort = false;
+      } else route[key] = preset[key];
+    }
+    return route;
+  }
+
   async function dispatchToExistingSession(requested, notifyContext, extras = {}) {
-    const prepared = requested.route ? await applyRequestedRoute(requested) : requested;
+    let followed = requested.route ? null : await agentRouteToFollow(requested);
+    if (followed && !canUseSessionSurface(requested.session)) {
+      // An in-process session takes the followed route in place, between
+      // turns; a running one finishes on the route it started on and holds
+      // the new one for its next turn, which runs the queued work.
+      if (!views.isSessionBusy(requested.sessionId)) {
+        const { session } = requested;
+        const crossProvider = followed.provider !== session.provider || followed.model !== session.model;
+        mgr.updateSessionRoute?.(requested.sessionId, followed, { session, crossProvider });
+      } else mgr.holdSessionRoute?.(requested.sessionId, followed);
+      followed = null;
+    }
+    const routed = followed ? { ...requested, route: followed } : requested;
+    const prepared = routed.route ? await applyRequestedRoute(routed) : routed;
     const { session, sessionId, prompt } = prepared;
     const tag = registry.tagForSession(sessionId);
     if (canUseSessionSurface(session) && views.isSessionBusy(sessionId)) {

package/src/session-runtime/services/agent-tool/spawn-flow/job-start.mjs

@@ -10,6 +10,7 @@ import { clean, terminalPidForContext } from '../helpers.mjs';
 import { renderResult } from '../render.mjs';
 import { closeManagedSession } from '../../../lifecycle/shared.mjs';
 import { hopOf } from '../../../../runtime/shared/bot-hops.mjs';
+import { notDoneReport } from '../../../../runtime/agent/orchestrator/runtime-core/todo-list.mjs';
 
 /** The completion callback that hands a worker's result back to its caller session; null without a handoff. */
 function handoffNotifier(handoffSessionId, notifySessionCompletion) {
@@ -86,6 +87,17 @@ export function createJobStarter({ mgr, notifyStatusChange, notifySessionComplet
         }
       },
     });
+    // Success, failure or cancellation: the report names what the agent's own
+    // todo list leaves undone. The Lead never receives the list otherwise.
+    task.reportAppendix = () => {
+      const sessionId = task.meta?.sessionId || jobMeta?.sessionId;
+      if (!sessionId) return '';
+      try {
+        return notDoneReport(mgr.getSession(sessionId));
+      } catch {
+        return '';
+      }
+    };
     // The model's tool call that started this job owns it (its result message
     // carries the id: agent-task-starts.mjs).
     recordAgentTaskStart(notifyContext?.toolCallId, task.taskId);

package/src/session-runtime/services/agent-tool/spawn-flow/spawn-plan.mjs

@@ -22,6 +22,7 @@ import { workspaceCwdLock } from '../../../workspace/admission-gate.mjs';
 import { isContactAgentId } from '../../../../runtime/agent/orchestrator/runtime-core/workflow-ids.mjs';
 import { assertBotChainTarget } from '../../../../runtime/shared/bot-hops.mjs';
 import { actingAgentOf, delegationChainOf } from '../../../bot-chain.mjs';
+import { flushPendingSessionConfigWrites } from '../../../config-lifecycle/config-writers.mjs';
 
 export function createSpawnPlanner({
   mgr = null,
@@ -36,6 +37,10 @@ export function createSpawnPlanner({
 }) {
   /** Shared spawn-prep validations (agent/preset/tag/cwd/prompt). */
   async function resolveSpawnPlan(args, callerCwd, context, prepState) {
+    // A setting a runtime of this process adopted (an agent's model picked a
+    // moment ago) is written behind a debounce: drain it so the read below
+    // sees what the runtimes hold in memory.
+    await flushPendingSessionConfigWrites();
     const config = cfgMod.loadConfig();
     const agent = normalizeAgentName(args.agent);
     if (!agent) throw new Error('agent spawn: agent is required');