mixdog 1.2.2 → 1.2.4

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

@@ -15,11 +15,13 @@ import { ACTIVE_LEAD_STATUS, isActiveLeadRow } from './lead-worker-index/lead-ro
 import { createLeadIndexFile } from './lead-worker-index/index-file.mjs';
 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 settlement = createRowSettlement({ dataDir, cfgMod });
+  const forgotten = createForgottenLeads(dataDir);
+  const settlement = createRowSettlement({ cfgMod, isSessionRunning });
   const reaps = createLeadReapTimers({ removeRow: (sessionId, reapAt) => removeLeadWorkerRow(sessionId, reapAt) });
 
   function removeLeadWorkerRow(sessionId, expectedReapAt = '') {
@@ -36,8 +38,25 @@ export function createLeadWorkerIndex({ dataDir, cfgMod, workerRowFromSession })
     return true;
   }
 
+  /** A deleted Lead leaves the pool now, running or not, and never returns. A
+   *  turn still unwinding after the delete settles by upserting its idle row —
+   *  possibly through another index instance of this process — so the guard is
+   *  process-wide (forgotten-leads.mjs). */
+  function forgetLeadSession(sessionId) {
+    const id = clean(sessionId);
+    if (!id) return false;
+    forgotten.forget(id);
+    reaps.cancel(id);
+    activeLeadSessions.delete(id);
+    index.write((byKey) => {
+      byKey.delete(id);
+    });
+    return true;
+  }
+
   function upsertLeadSession(session, extra = {}) {
     if (!session?.id || typeof workerRowFromSession !== 'function') return false;
+    if (forgotten.isForgotten(session.id)) return false;
     const owner = clean(session.owner).toLowerCase();
     const agent = clean(session.agent).toLowerCase();
     if (owner === 'agent' || (agent && agent !== 'lead')) return false;
@@ -54,20 +73,31 @@ 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,
       reapAt: reapMs == null ? null : new Date(now + reapMs).toISOString(),
     };
-    index.write((byKey) => byKey.set(session.id, normalized));
-    if (ACTIVE_LEAD_STATUS.test(status) || ACTIVE_LEAD_STATUS.test(stage)) {
-      activeLeadSessions.add(session.id);
-      reaps.cancel(session.id);
-    } else {
+    // Re-run against the locked fresh document at persist time: a delete that
+    // lands (here or in another instance) between this call and the write must
+    // still win over the queued row.
+    index.write(
+      (byKey) => {
+        if (!forgotten.isForgotten(session.id)) byKey.set(session.id, normalized);
+      },
+      { rerun: true }
+    );
+    if (settled) {
       activeLeadSessions.delete(session.id);
       reaps.schedule(normalized);
+    } else {
+      activeLeadSessions.add(session.id);
+      reaps.cancel(session.id);
     }
     return true;
   }
@@ -95,6 +125,7 @@ export function createLeadWorkerIndex({ dataDir, cfgMod, workerRowFromSession })
     const now = Date.now();
     index.write((byKey) => {
       for (const id of ids) {
+        if (forgotten.isForgotten(id)) continue;
         const current = byKey.get(id);
         if (!current || !isActiveLeadRow(current)) continue;
         byKey.set(id, settlement.idleLeadRow(current, now, true));
@@ -133,29 +164,66 @@ export function createLeadWorkerIndex({ dataDir, cfgMod, workerRowFromSession })
   recoverStaleLeadRows();
   function flushLeadIndexOnExit() {
     flushActiveLeadRows();
-    // Writes are persisted by an async queue; the loop is gone at exit.
+    // Writes are persisted by an async queue; the loop is gone at exit. This
+    // is the best-effort last resort: a persist still running is left alone
+    // (the graceful shutdown path drains before exit).
     index.flushSync();
   }
   const unregisterExitFlush = registerExitFlush(flushLeadIndexOnExit);
   let disposed = false;
+  let disposePromise = null;
+
+  function teardown() {
+    reaps.cancelAll();
+    unregisterExitFlush();
+  }
+
+  async function drainThenTeardown() {
+    await index.flush();
+    teardown();
+  }
 
   /** Persist queued rows, drop owned reap timers, unregister. `settle` (a real
    *  teardown) also idles this runtime's own active Lead rows; a dispose that
-   *  keeps background work (idle eviction) leaves them for the next owner. */
+   *  keeps background work (idle eviction) leaves them for the next owner.
+   *  If the sync flush cannot run (our async writer holds the lock), the exit
+   *  hook stays until the async drain settles. */
   function dispose({ settle = false } = {}) {
     if (disposed) return;
     disposed = true;
+    let flushed = false;
     try {
       if (settle) flushActiveLeadRows();
-      index.flushSync();
-    } finally {
-      reaps.cancelAll();
-      unregisterExitFlush();
+      flushed = index.flushSync();
+    } catch {}
+    if (flushed) {
+      teardown();
+      return;
+    }
+    disposePromise = drainThenTeardown().catch(reopenAfterFailedDrain);
+  }
+
+  /** A failed drain tears nothing down; allow a later dispose to retry it. */
+  function reopenAfterFailedDrain() {
+    disposed = false;
+    disposePromise = null;
+  }
+
+  function disposeAsync({ settle = false } = {}) {
+    if (!disposePromise) {
+      disposed = true;
+      if (settle) flushActiveLeadRows();
+      disposePromise = drainThenTeardown().catch((error) => {
+        reopenAfterFailedDrain();
+        throw error;
+      });
     }
+    return disposePromise;
   }
 
   return {
     dispose,
+    disposeAsync,
     leadWorkerIndexPath: index.path,
     readLeadWorkerRows: index.read,
     /** Resolves once every queued Lead index write is on disk. */
@@ -163,6 +231,7 @@ export function createLeadWorkerIndex({ dataDir, cfgMod, workerRowFromSession })
     upsertLeadSession,
     updateLeadWorkerCwd,
     removeLeadWorkerRow,
+    forgetLeadSession,
     flushActiveLeadRows,
     recoverStaleLeadRows,
   };

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,
   };
 }

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

@@ -41,6 +41,9 @@ export function resolveAgentSpawnPreset(config, args = {}) {
         type: 'agent',
         provider: agentRoute.provider,
         model: agentRoute.model,
+        ...(config.agents?.[agentName]?.fallbacks?.length
+          ? { fallbacks: config.agents[agentName].fallbacks.map(normalizeAgentRoute) }
+          : {}),
         effort: agentRoute.effort,
         fast: agentRoute.fast === true,
         ...(agentRoute.autoEffort === false ? { autoEffort: false } : {}),

package/src/session-runtime/services/agent-tool/tag-registry/tag-lookup.mjs

@@ -61,15 +61,13 @@ export function createTagLookup({ tags, mgr, readWorkerRows, reaper, getLiveSess
     };
     for (const row of readWorkerRows(context)) addIndexRow(row);
     if (scanSessions) {
-      const pendingTerminal = [];
       for (const session of mgr.listSessions({ includeClosed: false }) || []) {
         if (session?.closed === true) continue;
         const tag = agentTagOf(session);
         if (tag && reaper.tombstoneBlocksScan(session, tag, tombstones)) continue;
         add(session, tag);
-        if (tag) reaper.scanUpsertSession(session, tag, tombstones, pendingTerminal);
+        if (tag) reaper.scanUpsertSession(session, tag, tombstones);
       }
-      reaper.settleScannedTerminalRows(pendingTerminal);
     }
     for (const [tag, sessionId] of tags.entries()) {
       const session = getLiveSession(sessionId);

package/src/session-runtime/services/agent-tool/tag-registry/tag-refresh.mjs

@@ -18,7 +18,6 @@ export function createTagRefresh({ tags, tagMaps, mgr, reaper, refreshTagsFromIn
     // Tags missing from the index are exactly the ones a reap just removed, so
     // the tombstone (not the still-open session record) decides whether this
     // scan may re-bind them.
-    const pendingTerminal = [];
     for (const session of mgr.listSessions({ includeClosed: false }) || []) {
       if (isLeadPoolAgent(session?.agent)) continue;
       if (session?.closed === true) continue;
@@ -27,8 +26,7 @@ export function createTagRefresh({ tags, tagMaps, mgr, reaper, refreshTagsFromIn
       if (!sessionMatchesContext(session, context)) continue;
       if (reaper.tombstoneBlocksScan(session, tag, tombstones)) continue;
       tagMaps.bind(tag, session);
-      reaper.scanUpsertSession(session, tag, tombstones, pendingTerminal);
+      reaper.scanUpsertSession(session, tag, tombstones);
     }
-    reaper.settleScannedTerminalRows(pendingTerminal);
   };
 }