mixdog 1.2.3 → 1.2.5

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

@@ -38,8 +38,8 @@ export function createSendDispatch({ registry, defaultCwd, sendFlow, spawnFlow,
     if (inherited.tombstone) registry.consumeTagTombstone(inherited.tombstone);
   }
 
-  // Reaped/dead-tag fallback: with the 5m terminal-reap window a same-scope
-  // follow-up often lands after the session is gone. Instead of bouncing an
+  // Dead-tag fallback: a same-scope follow-up can land after its session was
+  // closed or deleted. Instead of bouncing an
   // error back to Lead (who would just re-issue the same content as a spawn),
   // respawn a FRESH session under the same tag with the message as its brief.
   // `respawned: true` in the result tells Lead the worker has no prior session

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

@@ -1,4 +1,22 @@
 import { clean, rowMatchesContext } from './helpers.mjs';
+import { resolveRequestedModel } from './model-select.mjs';
+
+// What an explicit (already resolved) spawn asks a reused session to change:
+// the model, the tuning, or both — only what it names, or null when it names
+// nothing. It is a partial request: the session's route write completes it
+// against the latest selected route (and drops it when nothing differs), so
+// no descriptor snapshot decides what the other tuning becomes.
+function requestedRoute(args) {
+  const model = clean(args.model);
+  const effort = clean(args.effort);
+  const route = {
+    ...(model ? { provider: clean(args.provider), model } : {}),
+    ...(effort ? { effort } : {}),
+    ...(args.fast === undefined ? {} : { fast: args.fast === true }),
+    ...(args.autoEffort === undefined ? {} : { autoEffort: args.autoEffort !== false }),
+  };
+  return Object.keys(route).length ? route : null;
+}
 
 // Spawn request dispatch: deciding what an explicitly tagged spawn means before
 // a job is started, and starting it.
@@ -6,7 +24,14 @@ import { clean, rowMatchesContext } from './helpers.mjs';
 // Inputs: `registry` (tag resolution, live sessions, tombstones),
 // `terminalTrace`, `sendFlow` (reuse path), `spawnFlow`, and `spawnResult`
 // (job -> rendered tool output). Output: { spawn }.
-export function createSpawnDispatch({ registry, terminalTrace, sendFlow, spawnFlow, spawnResult }) {
+export function createSpawnDispatch({
+  registry,
+  terminalTrace,
+  sendFlow,
+  spawnFlow,
+  spawnResult,
+  listProviderModels = null,
+}) {
   // Explicit-tag spawn priority (auto nextTag always creates a fresh session):
   //   1) live + busy -> queue the prompt (reuse)
   //   2) live + idle -> continue existing session (reuse)
@@ -26,7 +51,12 @@ export function createSpawnDispatch({ registry, terminalTrace, sendFlow, spawnFl
     }
     if (liveSessionId && registry.getLiveSession(liveSessionId)) {
       const prepared = await sendFlow.prepareSend({ ...args, tag: explicitTag }, scopedContext);
-      return { reused: sendFlow.dispatchToExistingSession(prepared, notifyContext, { reused: true }) };
+      const route = requestedRoute(args);
+      return {
+        reused: sendFlow.dispatchToExistingSession(route ? { ...prepared, route } : prepared, notifyContext, {
+          reused: true,
+        }),
+      };
     }
     if (terminalTrace.hasTerminalTrace(explicitTag, scopedContext)) {
       terminalTrace.reapTerminalTraceForTag(explicitTag, scopedContext);
@@ -52,7 +82,10 @@ export function createSpawnDispatch({ registry, terminalTrace, sendFlow, spawnFl
     return { spawnArgs: args, respawned: false };
   }
 
-  async function spawn(args, request) {
+  async function spawn(requestArgs, request) {
+    // Resolve a user-pinned model before deferring, so a miss or an ambiguous
+    // name answers this call instead of failing the background job.
+    const args = await resolveRequestedModel(requestArgs, listProviderModels);
     const explicitTag = clean(args.tag);
     let spawnArgs = args;
     let respawned = false;

package/src/session-runtime/services/agent-tool/execute.mjs

@@ -17,6 +17,7 @@ export function createAgentExecute({
   sendFlow,
   closeFlow,
   terminalTrace,
+  listProviderModels = null,
 }) {
   const spawnResult = (job) => renderResult(views.renderJob(job, false));
 
@@ -30,7 +31,14 @@ export function createAgentExecute({
   }
 
   const { send } = createSendDispatch({ registry, defaultCwd, sendFlow, spawnFlow, spawnResult });
-  const { spawn } = createSpawnDispatch({ registry, terminalTrace, sendFlow, spawnFlow, spawnResult });
+  const { spawn } = createSpawnDispatch({
+    registry,
+    terminalTrace,
+    sendFlow,
+    spawnFlow,
+    spawnResult,
+    listProviderModels,
+  });
 
   return async function execute(args = {}, context = {}) {
     try {

package/src/session-runtime/services/agent-tool/helpers.mjs

@@ -316,29 +316,52 @@ function agentDefinitionFiles(cleanAgent, dataDir, standaloneSourceRoot) {
   return candidates;
 }
 
-export function readAgentFrontmatterPermission(agent, dataDir, standaloneSourceRoot) {
+const _frontmatterFirstResponseCache = new Map(); // key -> { value, atMs }
+
+// The first definition (in precedence order) whose frontmatter yields a value
+// through `pick`, cached per agent for the frontmatter TTL.
+function cachedFrontmatterValue(cache, agent, dataDir, standaloneSourceRoot, pick) {
   const cleanAgent = clean(agent);
   if (!cleanAgent) return null;
   if (agentDeleted(cleanAgent, dataDir)) return null;
   const cacheKey = `${dataDir || ''}\u0000${cleanAgent}`;
-  const cached = _frontmatterPermCache.get(cacheKey);
+  const cached = cache.get(cacheKey);
   if (cached && Date.now() - cached.atMs < FRONTMATTER_PERM_CACHE_TTL_MS) {
     return cached.value;
   }
   let resolved = null;
   for (const file of agentDefinitionFiles(cleanAgent, dataDir, standaloneSourceRoot)) {
     if (!existsSync(file)) continue;
-    const fm = parseMarkdownFrontmatter(readFileSync(file, 'utf8'));
-    const permission = normalizeAgentPermissionOrNone(fm.permission);
-    if (permission) {
-      resolved = permission;
+    const value = pick(parseMarkdownFrontmatter(readFileSync(file, 'utf8')));
+    if (value != null) {
+      resolved = value;
       break;
     }
   }
-  _frontmatterPermCache.set(cacheKey, { value: resolved, atMs: Date.now() });
+  cache.set(cacheKey, { value: resolved, atMs: Date.now() });
   return resolved;
 }
 
+export function readAgentFrontmatterPermission(agent, dataDir, standaloneSourceRoot) {
+  return cachedFrontmatterValue(
+    _frontmatterPermCache,
+    agent,
+    dataDir,
+    standaloneSourceRoot,
+    (fm) => normalizeAgentPermissionOrNone(fm.permission) || null
+  );
+}
+
+/** The agent definition's `firstResponseTimeoutMs` (a non-negative integer;
+ *  0 disables the first-response deadline), or null when it sets none. */
+export function readAgentFirstResponseTimeoutMs(agent, dataDir, standaloneSourceRoot) {
+  return cachedFrontmatterValue(_frontmatterFirstResponseCache, agent, dataDir, standaloneSourceRoot, (fm) => {
+    const raw = String(fm.firstResponseTimeoutMs ?? '').trim();
+    const ms = Number(raw);
+    return raw && Number.isFinite(ms) && ms >= 0 ? Math.floor(ms) : null;
+  });
+}
+
 // Agents are global definitions (agents/<id>/ under the data dir or the
 // shipped source root). A spawn of an id with no definition anywhere —
 // typically a custom agent deleted in settings — must fail loudly instead of

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

@@ -57,13 +57,18 @@ export function terminalResultHook({ job, turnReview, completionValue, notifyEar
   };
 }
 
-/** Watchdog stall that still recovered a partial handoff: a completion. */
+/** Watchdog stall that still recovered a partial handoff: the turn never
+ *  finished, so the owner is told it FAILED (stalled), with the partial
+ *  output it produced before the stop. */
+export const WATCHDOG_STOP_ERROR = 'stalled: the progress watchdog stopped the turn';
+
 export function reconcileJobWatchdogPartial(job, value) {
   if (!job?.taskId) return;
   try {
     reconcileBackgroundTask(job.taskId, {
-      status: 'completed',
+      status: 'failed',
       result: value,
+      error: WATCHDOG_STOP_ERROR,
       terminalReason: 'agent-watchdog-partial',
     });
   } catch {}

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

@@ -38,7 +38,7 @@ export function terminalJobFrozenFields(status, now = Date.now()) {
 }
 
 /** A worker/job row as the published session state carries it. That state
- *  (statusline, desktop, phone, live-share viewers) re-reads agent status on a
+ *  (statusline, desktop, phone) re-reads agent status on a
  *  2s pulse, and these fields are the agent card's diagnostics, derived from
  *  the read time or the last stream delta: they changed on every read while
  *  nothing a surface shows did, so each pulse re-sent both row lists. Surfaces
@@ -64,7 +64,10 @@ export function createSessionProgress({ mgr }) {
     const runtime = mgr.getSessionRuntime?.(sessionId) || null;
     const snapshot =
       typeof mgr.getSessionProgressSnapshot === 'function' ? mgr.getSessionProgressSnapshot(sessionId) : null;
-    const policy = role ? resolveAgentWatchdogPolicy(role) : null;
+    // The armed watchdog's own policy (agent definition and provider budget
+    // applied); the role default only when none is registered.
+    const watchdogState = getProgressWatchdogState(mgr, sessionId);
+    const policy = watchdogState.policy || (role ? resolveAgentWatchdogPolicy(role) : null);
     const queuedFollowups =
       typeof mgr.getSessionPendingMessageDepth === 'function' ? mgr.getSessionPendingMessageDepth(sessionId) : null;
     return buildAgentTaskProgressFields({
@@ -74,7 +77,7 @@ export function createSessionProgress({ mgr }) {
       snapshot,
       runtime,
       policy,
-      watchdogState: getProgressWatchdogState(mgr, sessionId),
+      watchdogState,
       queuedFollowups,
       taskStatus,
       lastToolCall: runtime?.lastToolCall || null,

package/src/session-runtime/services/agent-tool/lead-worker-index/lead-rows.mjs

@@ -6,10 +6,9 @@ import { leadPoolTag } from '../worker-rows.mjs';
 export const ACTIVE_LEAD_STATUS =
   /^(?:connecting|requesting|streaming|tool[-_\s]?running|running|queued|pending|starting|cancelling)$/i;
 
-// Mirror of the pool reader's freshness window (store-summary-reader): a row is
-// only believed to be working while its heartbeat sidecar or its own stamp sits
-// inside this window. Recovery applies the SAME rule, so the index can never
-// keep claiming work the panel has already stopped believing.
+// Recovery's freshness window: an active row whose turn is not in flight in
+// this daemon is only believed while its own stamp sits inside this window
+// (it covers a row written just before its turn's runtime entry exists).
 export const LEAD_POOL_FRESH_MS = 2 * 60 * 1000;
 
 export const isActiveLeadRow = (row) => ACTIVE_LEAD_STATUS.test(clean(row?.status || row?.stage));

package/src/session-runtime/services/agent-tool/lead-worker-index/reap-timers.mjs

@@ -1,5 +1,7 @@
-// One reap timer per settled Lead row: fires at the row's reapAt and removes
-// the row only when it still carries that same deadline.
+// One reap timer per settled Lead row: fires at the row's reapAt — never
+// before the row has been listed in the Agents pane for its full visibility
+// window — and removes the row only when it still carries that same deadline.
+import { AGENT_PANE_VISIBLE_MS } from '../../../../runtime/shared/agent-reap-state.mjs';
 import { clean } from '../helpers.mjs';
 
 export function createLeadReapTimers({ removeRow }) {
@@ -18,7 +20,11 @@ export function createLeadReapTimers({ removeRow }) {
     const reapAt = clean(row?.reapAt);
     if (!sessionId || !reapAt) return;
     cancel(sessionId);
-    const delay = Math.max(0, (Date.parse(reapAt) || 0) - Date.now());
+    // The provider reap window may be shorter than the pane window; deleting
+    // the row then would drop a finished Lead the pane still has to show.
+    const finishedMs = Date.parse(clean(row.finishedAt)) || Date.parse(clean(row.updatedAt)) || 0;
+    const deadline = Math.max(Date.parse(reapAt) || 0, finishedMs + AGENT_PANE_VISIBLE_MS);
+    const delay = Math.max(0, deadline - Date.now());
     const handle = setTimeout(() => {
       reapTimers.delete(sessionId);
       removeRow(sessionId, reapAt);

package/src/session-runtime/services/agent-tool/lead-worker-index/row-settlement.mjs

@@ -1,34 +1,23 @@
 // When an active Lead row is no longer believable, and how it settles to idle:
-// runtime liveness, the heartbeat sidecar, the stamp freshness window, and the
-// terminal reap deadline from config.
-import { statSync } from 'node:fs';
-import { resolve } from 'node:path';
+// runtime liveness, the daemon's in-memory turn state, the stamp freshness
+// window, and the terminal reap deadline from config.
 import { clean, runtimeAlive } from '../helpers.mjs';
 import { createRowLiveness } from '../worker-index/row-liveness.mjs';
 import { isActiveLeadRow, LEAD_POOL_FRESH_MS } from './lead-rows.mjs';
 
-export function createRowSettlement({ dataDir, cfgMod }) {
+/** `isSessionRunning(sessionId)`: whether that Lead's turn is in flight in
+ *  this process (every session runs inline in the daemon). */
+export function createRowSettlement({ cfgMod, isSessionRunning = () => false }) {
   // Lead rows settle to idle exactly like worker rows: same stamps, same
   // config-driven terminal reap deadline.
-  const { idleRow } = createRowLiveness({ dataDir, cfgMod });
-
-  function leadHeartbeatFresh(sessionId, now) {
-    const id = clean(sessionId);
-    if (!dataDir || !id) return false;
-    try {
-      const mtimeMs = statSync(resolve(dataDir, 'sessions', `${id}.hb`)).mtimeMs || 0;
-      return mtimeMs > 0 && now - mtimeMs <= LEAD_POOL_FRESH_MS;
-    } catch {
-      return false;
-    }
-  }
+  const { idleRow } = createRowLiveness({ cfgMod });
 
   function staleActiveLeadRow(row, now) {
     if (!isActiveLeadRow(row)) return false;
     // The runtime that stamped the turn is gone: no wall-clock window can make
     // that row true again, so the panel must not wait one out.
     if (!runtimeAlive(row.runtimePid)) return true;
-    if (leadHeartbeatFresh(row.sessionId, now)) return false;
+    if (isSessionRunning(clean(row.sessionId))) return false;
     const updated = Date.parse(clean(row.updatedAt)) || 0;
     return !(updated > 0 && now - updated <= LEAD_POOL_FRESH_MS);
   }

package/src/session-runtime/services/agent-tool/lead-worker-index.mjs

@@ -17,11 +17,11 @@ import { createRowSettlement } from './lead-worker-index/row-settlement.mjs';
 import { createLeadReapTimers } from './lead-worker-index/reap-timers.mjs';
 import { createForgottenLeads } from './lead-worker-index/forgotten-leads.mjs';
 
-export function createLeadWorkerIndex({ dataDir, cfgMod, workerRowFromSession }) {
+export function createLeadWorkerIndex({ dataDir, cfgMod, workerRowFromSession, isSessionRunning }) {
   const activeLeadSessions = new Set();
   const index = createLeadIndexFile({ dataDir });
   const forgotten = createForgottenLeads(dataDir);
-  const settlement = createRowSettlement({ dataDir, cfgMod });
+  const settlement = createRowSettlement({ cfgMod, isSessionRunning });
   const reaps = createLeadReapTimers({ removeRow: (sessionId, reapAt) => removeLeadWorkerRow(sessionId, reapAt) });
 
   function removeLeadWorkerRow(sessionId, expectedReapAt = '') {
@@ -73,8 +73,11 @@ export function createLeadWorkerIndex({ dataDir, cfgMod, workerRowFromSession })
       updatedAt: new Date(now).toISOString(),
     });
     if (!row) return false;
+    const settled = !ACTIVE_LEAD_STATUS.test(status) && !ACTIVE_LEAD_STATUS.test(stage);
     const normalized = {
       ...row,
+      // The pane lists a settled Lead for a fixed window from this stamp.
+      finishedAt: settled ? row.finishedAt || new Date(now).toISOString() : row.finishedAt,
       // Liveness identity of the runtime that owns this status. A row stamped
       // by a process that no longer exists is recovered on the next boot.
       runtimePid: process.pid,
@@ -89,12 +92,12 @@ export function createLeadWorkerIndex({ dataDir, cfgMod, workerRowFromSession })
       },
       { rerun: true }
     );
-    if (ACTIVE_LEAD_STATUS.test(status) || ACTIVE_LEAD_STATUS.test(stage)) {
-      activeLeadSessions.add(session.id);
-      reaps.cancel(session.id);
-    } else {
+    if (settled) {
       activeLeadSessions.delete(session.id);
       reaps.schedule(normalized);
+    } else {
+      activeLeadSessions.add(session.id);
+      reaps.cancel(session.id);
     }
     return true;
   }

package/src/session-runtime/services/agent-tool/model-select.mjs

@@ -0,0 +1,82 @@
+// One-off model selection for a spawn the user explicitly pinned to a model.
+// The agent's preset route stays the default; this only runs when `model` is
+// passed. The query is matched against the live provider catalog — exact id,
+// then exact display name, then every query word — and a catalog miss retries
+// once on a refreshed catalog. One match runs; several or none fail with
+// candidates instead of substituting another model.
+import { clean } from './helpers.mjs';
+
+const CANDIDATE_LIMIT = 8;
+
+const norm = (value) =>
+  String(value || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '');
+const terms = (value) =>
+  String(value || '')
+    .toLowerCase()
+    .split(/\s+/)
+    .map(norm)
+    .filter(Boolean);
+const label = (row) => `${row.provider}/${row.id}`;
+
+function providerRows(rows, provider) {
+  if (!provider) return rows;
+  const wanted = norm(provider);
+  const exact = rows.filter((row) => norm(row.provider) === wanted);
+  return exact.length ? exact : rows.filter((row) => norm(row.provider).includes(wanted));
+}
+
+function matchModels(rows, query) {
+  const wanted = norm(query);
+  const words = terms(query);
+  // Nothing to match on ("???"): `[].every` would accept every row.
+  if (!words.length) return [];
+  const tiers = [
+    (row) => norm(row.id) === wanted,
+    (row) => norm(row.display) === wanted,
+    (row) => words.every((word) => `${norm(row.id)} ${norm(row.display)}`.includes(word)),
+  ];
+  for (const test of tiers) {
+    const hits = rows.filter(test);
+    if (hits.length) return hits;
+  }
+  return [];
+}
+
+function candidates(rows) {
+  const shown = rows.slice(0, CANDIDATE_LIMIT).map(label).join(', ');
+  return rows.length > CANDIDATE_LIMIT ? `${shown}, … (${rows.length} total)` : shown;
+}
+
+/** Resolve args.provider/args.model to one exact catalog route. Without a
+ *  catalog (headless/daemon surfaces) exact provider + model pass through. */
+export async function resolveRequestedModel(args, listProviderModels) {
+  const model = clean(args.model);
+  const provider = clean(args.provider);
+  if (!model) {
+    if (provider) throw new Error('agent spawn: provider requires model');
+    return args;
+  }
+  if (typeof listProviderModels !== 'function') {
+    if (!provider) throw new Error('agent spawn: model requires provider on this surface');
+    // Punctuation alone names no model; the catalog path rejects it the same way.
+    if (!terms(model).length) throw new Error(`agent spawn: model "${model}" for provider "${provider}" not found`);
+    return args;
+  }
+  let pool = providerRows(await listProviderModels(), provider);
+  let hits = matchModels(pool, model);
+  if (!hits.length) {
+    pool = providerRows(await listProviderModels({ force: true }), provider);
+    hits = matchModels(pool, model);
+  }
+  if (hits.length === 1) return { ...args, provider: hits[0].provider, model: hits[0].id };
+  const scope = provider ? ` for provider "${provider}"` : '';
+  if (hits.length > 1) {
+    throw new Error(`agent spawn: model "${model}"${scope} is ambiguous: ${candidates(hits)}; pass the exact one`);
+  }
+  if (!pool.length) {
+    throw new Error(`agent spawn: provider "${provider}" has no available models`);
+  }
+  throw new Error(`agent spawn: model "${model}"${scope} not found; available: ${candidates(pool)}`);
+}

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

@@ -1,4 +1,5 @@
 import {
+  isAgentProgressWatchdogAbortError,
   resolveAgentWatchdogPolicy,
   resolveHandoffMessageStartIndex,
   turnPartialHandoff,
@@ -15,6 +16,7 @@ import {
   terminalResultHook,
 } from './job-task-reconcile.mjs';
 import { createTurnReviewCollector } from './turn-review.mjs';
+import { settledWorkerStatus } from './worker-index/row-liveness.mjs';
 
 // `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
@@ -28,7 +30,6 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
     if (!sessionId) throw new Error(`agent send: target "${target}" not found`);
     const session = mgr.getSession(sessionId);
     if (!session || session.closed) throw new Error(`agent send: session "${sessionId}" is closed`);
-    registry.cancelReap(sessionId);
     const prompt = await resolvePrompt(args, session.cwd || defaultCwd);
     return { args, session, sessionId, prompt };
   }
@@ -82,13 +83,18 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
     const tag = registry.tagForSession(sessionId);
     // Queued sends run as follow-up turns inside this same askSession call;
     // the watchdog sweep re-stamps turnStartedAt at each turn boundary.
-    const watchdog = spawnFlow.startProgressIdleWatchdog(sessionId, resolveAgentWatchdogPolicy(sendAgent), sendAgent, {
+    const watchdogPolicy = resolveAgentWatchdogPolicy(
+      sendAgent,
+      spawnFlow.agentWatchdogOverrides({ agent: sendAgent, provider: session.provider, model: session.model })
+    );
+    const watchdog = spawnFlow.startProgressIdleWatchdog(sessionId, watchdogPolicy, sendAgent, {
       onTurnStart: spawnFlow.turnStartStamper(session, tag),
       onProgress: spawnFlow.progressStamper(session, tag),
     });
     const turnReview = createTurnReviewCollector(session, tag, sendAgent, notifyContext || {});
     const completionValue = completionValueFor({ session, tag, sessionId, sendAgent });
     let finalStatus = 'idle';
+    let stalled = false;
     registry.upsertWorkerSessionDeferred(session, tag, {
       status: 'running',
       stage: 'running',
@@ -129,6 +135,7 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
         settleCancelled(error);
         throw error;
       }
+      stalled = isAgentProgressWatchdogAbortError(error);
       const partial = watchdogPartialHandoffFromError(error, mgr.getSession(sessionId), handoffMsgStart);
       if (partial) {
         finalStatus = 'idle';
@@ -152,12 +159,10 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
       turnReview.complete();
       watchdog?.stop?.();
       registry.upsertWorkerSessionDeferred(session, tag, {
-        status: finalStatus,
-        stage: finalStatus,
+        ...settledWorkerStatus(finalStatus, stalled),
         finishedAt: new Date().toISOString(),
       });
       reconcileJobFinally(job, finalStatus);
-      registry.scheduleReap(sessionId);
       // Same lifecycle as a fresh spawn: the transcript/tag stays resumable,
       // while heavy process-local runtime state is reclaimed immediately.
       try {
@@ -166,11 +171,24 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
     }
   }
 
+  // An explicit model on a reused tag goes through the session's own route
+  // API, which saves it and applies it from the session's next turn: the
+  // dispatched prompt when the session is idle, a later one while it is busy.
+  async function applyRequestedRoute(prepared) {
+    const { session, sessionId, route } = prepared;
+    if (!canUseSessionSurface(session) || typeof sessionSurface.setRoute !== 'function') {
+      throw new Error(`agent spawn: this surface cannot change the model of reused session "${sessionId}"`);
+    }
+    await sessionSurface.setRoute({ session, route });
+    return { ...prepared, session: mgr.getSession(sessionId) || session };
+  }
+
   // Shared send dispatch for an already-resolved live session. Used by the
   // `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).
-  async function dispatchToExistingSession(prepared, notifyContext, extras = {}) {
+  async function dispatchToExistingSession(requested, notifyContext, extras = {}) {
+    const prepared = requested.route ? await applyRequestedRoute(requested) : requested;
     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

@@ -53,7 +53,9 @@ export function createJobStarter({ mgr, notifyStatusChange, notifySessionComplet
         const currentMeta = task?.meta || jobMeta;
         if (currentMeta?.sessionId) {
           try {
-            Promise.resolve(mgr.closeSession(currentMeta.sessionId, 'agent-task-cancel')).catch(() => {});
+            Promise.resolve(mgr.closeSession(currentMeta.sessionId, 'agent-task-cancel', { tombstone: false })).catch(
+              () => {}
+            );
           } catch {}
         }
         setImmediate(notifyStatusChange);

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

@@ -4,7 +4,7 @@
  * route, and the transport prewarm. The validated spawn plan and the session
  * spec it produces live in ./spawn-plan.mjs.
  */
-import { presetKey, writeAgentStatuslineRoute } from '../helpers.mjs';
+import { presetKey, readAgentFirstResponseTimeoutMs, writeAgentStatuslineRoute } from '../helpers.mjs';
 import { resolveAgentWatchdogPolicy } from '../../../../runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs';
 import { prepareAgentSession } from '../../../../runtime/agent/orchestrator/agent-runtime/session-builder.mjs';
 import { getProvider } from '../../../../runtime/agent/orchestrator/providers/registry.mjs';
@@ -55,7 +55,6 @@ export function createSpawnPreparer({
   resolveTag,
   wantsSessionScan,
   bindTag,
-  cancelReap,
   ensureProvider,
   sessionSurface = null,
   refreshTagsFromSessions,
@@ -71,6 +70,19 @@ export function createSpawnPreparer({
     wantsSessionScan,
   });
 
+  /** Watchdog inputs for one agent run: the agent definition's own
+   *  first-response deadline and the provider's first-response budget for the
+   *  routed model (headers, and first output), handed to
+   *  resolveAgentWatchdogPolicy. A provider on the shared window names none. */
+  function agentWatchdogOverrides({ agent, provider, model }) {
+    const budget = getProvider(provider)?.firstResponseBudget?.(model);
+    return {
+      firstResponseTimeoutMs: readAgentFirstResponseTimeoutMs(agent, dataDir, STANDALONE_SOURCE_ROOT) ?? undefined,
+      providerFirstByteTimeoutMs: budget?.transportMs,
+      providerFirstOutputTimeoutMs: budget?.semanticMs,
+    };
+  }
+
   /** Shared post-create wiring. Lead sessions write a gateway-session route on
    *  create; agent sessions are built through prepareAgentSession()/the remote
    *  runtime, so mirror that registration here or the vendored L1/L2
@@ -79,7 +91,6 @@ export function createSpawnPreparer({
     const { agent, presetName, preset, tag } = plan;
     writeAgentStatuslineRoute(session.id, preset);
     bindTag(tag, session, { ...presetDescriptor(agent, preset, presetName), status: 'idle', stage: 'idle' });
-    cancelReap(session.id);
   }
 
   async function createSpawnedSession(plan, spec, prepState) {
@@ -127,7 +138,10 @@ export function createSpawnPreparer({
       presetName: plan.presetName,
       workerCwd: effectiveCwd || plan.workerCwd,
       prompt: plan.prompt,
-      watchdogPolicy: resolveAgentWatchdogPolicy(plan.agent),
+      watchdogPolicy: resolveAgentWatchdogPolicy(
+        plan.agent,
+        agentWatchdogOverrides({ agent: plan.agent, provider: plan.preset.provider, model: plan.preset.model })
+      ),
     };
   }
 
@@ -136,5 +150,5 @@ export function createSpawnPreparer({
     return prepareSpawnInProcess(args, callerCwd, context, prepState);
   }
 
-  return { prepareSpawn, prepareSpawnInProcess, createSpawnedSession };
+  return { prepareSpawn, prepareSpawnInProcess, createSpawnedSession, agentWatchdogOverrides };
 }

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

@@ -15,11 +15,13 @@ import {
 import { abnormalEmptyFinishError } from '../render.mjs';
 import { createProgressWatchdogRegistry } from '../../agent-watchdog-registry.mjs';
 import {
+  isAgentProgressWatchdogAbortError,
   resolveHandoffMessageStartIndex,
   turnPartialHandoff,
   watchdogPartialHandoffFromError,
   watchdogStoppedHandoff,
 } from '../../../../runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs';
+import { settledWorkerStatus } from '../worker-index/row-liveness.mjs';
 import { saveSessionAsync } from '../../../../runtime/agent/orchestrator/session/store.mjs';
 import { presetDescriptor } from './spawn-prep.mjs';
 import { workerStageForStatus } from '../worker-rows.mjs';
@@ -35,7 +37,6 @@ export function createSpawnRunner({
   notifyStatusChange = () => {},
   notifySessionCompletion,
   emitSubagentEvent,
-  scheduleReap,
   sessionSurface = null,
   createTurnReviewCollector,
 }) {
@@ -128,6 +129,7 @@ export function createSpawnRunner({
     const turnReview = createTurnReviewCollector(session, tag, agent, notifyContext || {});
     const completionValue = completionValueFor(prepared);
     let finalStatus = 'idle';
+    let stalled = false;
     // SubagentStart: a worker session is about to run its first turn.
     emitSubagentEvent('start', agent, { session_id: session.id, tag });
     upsertWorkerSessionDeferred(session, tag, {
@@ -189,6 +191,7 @@ export function createSpawnRunner({
         settleCancelled(error);
         throw error;
       }
+      stalled = isAgentProgressWatchdogAbortError(error);
       const partial = watchdogPartialHandoffFromError(error, mgr.getSession(session.id), handoffMsgStart);
       if (partial) {
         finalStatus = 'idle';
@@ -211,13 +214,11 @@ export function createSpawnRunner({
       watchdog?.stop?.();
       upsertWorkerSessionDeferred(session, tag, {
         ...presetDescriptor(agent, preset, presetName),
-        status: finalStatus,
-        stage: finalStatus,
+        ...settledWorkerStatus(finalStatus, stalled),
         finishedAt: new Date().toISOString(),
       });
       setImmediate(notifyStatusChange);
       reconcileJobFinally(job, finalStatus);
-      scheduleReap(session.id);
       // SubagentStop: worker finished (terminal), regardless of outcome.
       emitSubagentEvent('stop', agent, { session_id: session.id, tag, status: finalStatus });
       // Keep the durable session/tag for same-tag follow-ups, but release every

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

@@ -14,7 +14,7 @@ export function createSpawnFlow(deps) {
     notifyStatusChange: deps.notifyStatusChange ?? (() => {}),
     notifySessionCompletion: deps.notifySessionCompletion,
   });
-  const { prepareSpawn, prepareSpawnInProcess } = createSpawnPreparer(deps);
+  const { prepareSpawn, prepareSpawnInProcess, agentWatchdogOverrides } = createSpawnPreparer(deps);
   const runner = createSpawnRunner(deps);
   const { closePreparedSpawn, startDeferredSpawnJob } = createDeferredSpawn({
     ...deps,
@@ -35,6 +35,7 @@ export function createSpawnFlow(deps) {
     progressStamper: runner.progressStamper,
     prepareSpawn,
     prepareSpawnInProcess,
+    agentWatchdogOverrides,
     runSpawn: runner.runSpawn,
   };
 }