mixdog 0.9.86 → 0.9.87

package/src/standalone/agent-tool.mjs

@@ -49,6 +49,9 @@ import {
 import { abnormalEmptyFinishError, renderResult } from './agent-tool/render.mjs';
 import { createProviderInit } from './agent-tool/provider-init.mjs';
 import { createNotify } from './agent-tool/notify.mjs';
+import { createTagRegistry } from './agent-tool/tag-registry.mjs';
+import { createJobViews } from './agent-tool/job-views.mjs';
+import { createSpawnFlow } from './agent-tool/spawn-flow.mjs';
 import { resolveAgentSpawnPreset } from './agent-tool/spawn-preset.mjs';
 import {
   TAG_TOMBSTONE_TTL_MS,
@@ -116,1162 +119,108 @@ export function createStandaloneAgent({
       },
     };
   }
-  const tags = new Map();
-  const tagAgents = new Map();
-  const tagCwds = new Map();
-  const reapTimers = new Map();
-  // Worker-index persistence (row store, parse cache, batched atomic writer,
-  // tag projection) lives in agent-tool/worker-index.mjs; the tag maps are
-  // shared by reference so both sides see the same live state.
-  const {
-    readAllTagTombstones,
-    readTagTombstones,
-    readWorkerRows,
-    writeWorkerRows,
-    flushWorkerIndexMutations,
-    upsertWorkerSession,
-    upsertWorkerSessionDeferred,
-    removeWorkerRow,
-    refreshTagsFromIndex,
-  } = createWorkerIndex({ dataDir, cfgMod, mgr, tags, tagAgents, tagCwds });
-
-  function wantsSessionScan(args = {}) {
-    return args.recover === true || args.scanSessions === true || args.scan_sessions === true;
-  }
-
-  function resolveTag(target, context = {}, options = {}) {
-    const scanSessions = options.scanSessions === true;
-    const excludeTerminalTraces = options.excludeTerminalTraces === true;
-    refreshTagsFromSessions({ scanSessions, context });
-    const value = clean(target);
-    if (!value) return null;
-    if (value.startsWith('sess_')) {
-      const session = getLiveSession(value);
-      if (session && sessionMatchesContext(session, context)) return value;
-      const row = readWorkerRows(context).find((item) => item.sessionId === value);
-      return row ? value : null;
-    }
-    const matches = agentSessionEntries({ scanSessions, context, excludeTerminalTraces })
-      .filter((entry) => entry.tag === value);
-    if (matches.length === 1) return matches[0].session.id;
-    if (matches.length > 1) {
-      throw new Error(`agent: tag "${value}" is ambiguous across terminals; use sessionId`);
-    }
-    const sessionId = tags.get(value) || null;
-    const session = getLiveSession(sessionId);
-    return session && sessionMatchesContext(session, context) ? sessionId : null;
-  }
-
-  function getLiveSession(sessionId) {
-    if (!sessionId) return null;
-    const session = mgr.getSession(sessionId);
-    return session && session.closed !== true ? session : null;
-  }
-
-  function tagForSession(sessionId) {
-    const session = getLiveSession(sessionId);
-    const persistedTag = agentTagOf(session);
-    if (persistedTag) return persistedTag;
-    for (const [tag, sid] of tags.entries()) {
-      if (sid === sessionId) return tag;
-    }
-    return null;
-  }
-
-  function agentSessionEntries({ scanSessions = false, context = {}, excludeTerminalTraces = false } = {}) {
-    const rows = [];
-    const seen = new Set();
-    const add = (session, fallbackTag = '') => {
-      const tag = agentTagOf(session) || clean(fallbackTag);
-      if (!tag || !session?.id || session.closed === true) return;
-      if (!sessionMatchesContext(session, context)) return;
-      if (seen.has(session.id)) return;
-      seen.add(session.id);
-      rows.push({ tag, session });
-    };
-    const addIndexRow = (row) => {
-      const tag = clean(row?.tag);
-      const sessionId = clean(row?.sessionId);
-      if (!tag || !sessionId || !rowMatchesContext(row, context)) return;
-      if (seen.has(sessionId)) return;
-      // Collision/resolution enumeration only: a row that is in a terminal
-      // (or idle-but-finished) state AND has no live session behind it is a
-      // lingering trace kept for the reap grace window. excludeTerminalTraces drops those
-      // rows so live-session reuse/spawn resolution can proceed; list/status
-      // keep excludeTerminalTraces=false so finished workers still appear.
-      if (excludeTerminalTraces
-        && isTerminalWorkerStatus(row.status || row.stage)
-        && !getLiveSession(sessionId)) {
-        return;
-      }
-      seen.add(sessionId);
-      rows.push({ tag, session: workerRowToSession(row), indexRow: row });
-    };
-    for (const row of readWorkerRows(context)) addIndexRow(row);
-    if (scanSessions) {
-      for (const session of mgr.listSessions({ includeClosed: false }) || []) {
-        const tag = agentTagOf(session);
-        add(session, tag);
-        if (tag) upsertWorkerSessionDeferred(session, tag);
-      }
-    }
-    for (const [tag, sessionId] of tags.entries()) {
-      add(getLiveSession(sessionId), tag);
-    }
-    return rows;
-  }
-
-  function nextTag(agent, context = {}) {
-    refreshTagsFromSessions({ context });
-    // Auto tags are agent + a per-agent local index with NO hyphen
-    // ("worker3", "heavy-worker7", or "agent1" when the agent is unset). The
-    // index is the max existing `^agent(\d+)$` + 1, escaping the agent so a
-    // hyphenated agent ("heavy-worker") is matched literally. Keep incrementing
-    // on any live collision.
-    const base = clean(agent) || 'agent';
-    const escaped = base.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const re = new RegExp(`^${escaped}(\\d+)$`);
-    let maxN = 0;
-    for (const existing of tags.keys()) {
-      const match = re.exec(existing);
-      if (!match) continue;
-      const n = Number(match[1]);
-      if (Number.isFinite(n) && n > maxN) maxN = n;
-    }
-    let n = maxN + 1;
-    let tag = `${base}${n}`;
-    while (resolveTag(tag, context)) tag = `${base}${++n}`;
-    return tag;
-  }
-
-  function refreshTagsFromSessions({ scanSessions = false, context = {} } = {}) {
-    transitionStaleNonterminalRows(context);
-    const indexedRows = refreshTagsFromIndex(context);
-    const indexedKeys = new Set(indexedRows.map((row) => `${row.tag}\0${row.sessionId}`));
-    for (const [tag, sessionId] of [...tags.entries()]) {
-      if (indexedKeys.has(`${tag}\0${sessionId}`)) continue;
-      const session = getLiveSession(sessionId);
-      if (!session || session.closed) {
-        tags.delete(tag);
-        tagAgents.delete(tag);
-        tagCwds.delete(tag);
-      }
-    }
-    if (!scanSessions) return;
-    for (const session of mgr.listSessions({ includeClosed: false }) || []) {
-      const tag = agentTagOf(session);
-      if (!tag || tags.has(tag)) continue;
-      if (!sessionMatchesContext(session, context)) continue;
-      tags.set(tag, session.id);
-      if (session.agent) tagAgents.set(tag, session.agent);
-      if (session.cwd) tagCwds.set(tag, session.cwd);
-      upsertWorkerSessionDeferred(session, tag);
-    }
-  }
-
-  function bindTag(tag, session, extra = {}) {
-    if (!tag || !session?.id) return;
-    tags.set(tag, session.id);
-    if (session.agent) tagAgents.set(tag, session.agent);
-    if (session.cwd) tagCwds.set(tag, session.cwd);
-    upsertWorkerSessionDeferred(session, tag, extra);
-  }
-
-  function forgetTag(tag) {
-    if (!tag) return;
-    const sessionId = tags.get(tag) || '';
-    tags.delete(tag);
-    tagAgents.delete(tag);
-    tagCwds.delete(tag);
-    removeWorkerRow({ tag, sessionId });
-  }
-
-  function forgetTerminalSession(tag, sessionId) {
-    const value = clean(tag);
-    const id = clean(sessionId);
-    if (value && id && tags.get(value) === id) {
-      tags.delete(value);
-      tagAgents.delete(value);
-      tagCwds.delete(value);
-    }
-    if (id) removeWorkerRow({ sessionId: id });
-  }
-
-  function tombstoneTerminalSession(tag, sessionId, session = null) {
-    const value = clean(tag);
-    const id = clean(sessionId);
-    if (!value || !id) {
-      forgetTerminalSession(value, id);
-      return;
-    }
-    if (tags.get(value) === id) {
-      tags.delete(value);
-      tagAgents.delete(value);
-      tagCwds.delete(value);
-    }
-    const tombstone = {
-      tag: value,
-      agent: clean(session?.agent) || null,
-      cwd: clean(session?.cwd) || null,
-      clientHostPid: positiveInt(session?.clientHostPid),
-      reapedAt: new Date().toISOString(),
-    };
-    flushWorkerIndexMutations();
-    writeWorkerRows((byKey, tombstonesByKey, priorityTombstoneKeys) => {
-      for (const [key, row] of [...byKey.entries()]) {
-        if (clean(row.sessionId) === id) byKey.delete(key);
-      }
-      const tombstoneKey = tagTombstoneKey(tombstone);
-      tombstonesByKey.set(tombstoneKey, tombstone);
-      priorityTombstoneKeys.add(tombstoneKey);
+    // Tag maps + resolve/bind/reap lifecycle: agent-tool/tag-registry.mjs.
+    const {
+      tags,
+      tagAgents,
+      tagCwds,
+      reapTimers,
+      wantsSessionScan,
+      resolveTag,
+      getLiveSession,
+      tagForSession,
+      agentSessionEntries,
+      nextTag,
+      refreshTagsFromSessions,
+      bindTag,
+      forgetTag,
+      forgetTerminalSession,
+      tombstoneTerminalSession,
+      tagTombstoneForTag,
+      consumeTagTombstone,
+      cancelReap,
+      scheduleReap,
+      transitionStaleNonterminalRows,
+      readAllTagTombstones,
+      readTagTombstones,
+      readWorkerRows,
+      writeWorkerRows,
+      flushWorkerIndexMutations,
+      upsertWorkerSession,
+      upsertWorkerSessionDeferred,
+      removeWorkerRow,
+      refreshTagsFromIndex,
+    } = createTagRegistry({
+      dataDir,
+      cfgMod,
+      mgr,
+      emitSubagentEvent,
     });
-  }
-
-  function tagTombstoneForTag(tag, context = {}) {
-    const value = clean(tag);
-    if (!value || value.startsWith('sess_')) return null;
-    return readTagTombstones(context).find((row) => row.tag === value) || null;
-  }
-
-  function consumeTagTombstone(tombstone) {
-    if (!tombstone?.tag) return false;
-    const key = tagTombstoneKey(tombstone);
-    flushWorkerIndexMutations();
-    writeWorkerRows((_byKey, tombstonesByKey) => tombstonesByKey.delete(key));
-    return true;
-  }
 
-  function cancelReap(sessionId) {
-    const handle = reapTimers.get(sessionId);
-    if (!handle) return false;
-    clearTimeout(handle);
-    reapTimers.delete(sessionId);
-    return true;
-  }
-
-  function scheduleReap(sessionId, provider = null) {
-    if (!sessionId) return;
-    cancelReap(sessionId);
-    const reapProvider = provider || getLiveSession(sessionId)?.provider || null;
-    const reapMs = resolveAgentTerminalReapMs(cfgMod.loadConfig(), reapProvider);
-    if (reapMs == null) return;
-    const handle = setTimeout(() => {
-      reapTimers.delete(sessionId);
-      const session = getLiveSession(sessionId);
-      try { mgr.hideSessionFromList?.(sessionId); } catch {}
-      const tag = tagForSession(sessionId);
-      tombstoneTerminalSession(tag, sessionId, session);
-      clearAgentStatuslineRoute(sessionId);
-      try { mgr.closeSession(sessionId, 'terminal-reap'); } catch {}
-    }, reapMs);
-    handle.unref?.();
-    reapTimers.set(sessionId, handle);
-  }
-
-  function transitionStaleNonterminalRows(context = {}) {
-    const staleRows = readWorkerRows(context).filter((row) => {
-      if (isTerminalWorkerStatus(row.status || row.stage)) return false;
-      if (getLiveSession(clean(row.sessionId))) return false;
-      const rowTime = workerRowTime(row);
-      const reapMs = resolveAgentTerminalReapMs(cfgMod.loadConfig(), row.provider);
-      // A row with no timestamp has no usable heartbeat at all. Explicitly
-      // disabled terminal reaping still gets the tombstone TTL as a finite
-      // stale-heartbeat bound, so malformed/running index rows cannot block a
-      // tag forever.
-      return rowTime <= 0 || Date.now() - rowTime >= (reapMs ?? TAG_TOMBSTONE_TTL_MS);
+    // Job/session views (list/getJob/render/spawn-meta): agent-tool/job-views.mjs.
+    const {
+      isSessionBusy,
+      ensureProvider,
+      list,
+      sessionProgressExtras,
+      jobWorkerSnapshot,
+      listJobs,
+      getJob,
+      workerFallbackJob,
+      getJobOrWorker,
+      renderJob,
+      preparedSpawnMeta,
+      pendingSpawnMeta,
+      mergeJobMeta,
+    } = createJobViews({
+      mgr,
+      getLiveSession,
+      reg,
+      DEFAULT_SPAWN_PREP_TIMEOUT_MS,
+      refreshTagsFromSessions,
+      agentSessionEntries,
+      tags,
+      cfgMod,
     });
-    if (staleRows.length === 0) return false;
-    flushWorkerIndexMutations();
-    const nowIso = new Date().toISOString();
-    writeWorkerRows((byKey, tombstonesByKey, priorityTombstoneKeys) => {
-      for (const row of staleRows) {
-        const sessionId = clean(row.sessionId);
-        for (const [key, candidate] of [...byKey.entries()]) {
-          if (clean(candidate.sessionId) === sessionId) byKey.delete(key);
-        }
-        const tombstone = {
-          tag: clean(row.tag),
-          agent: clean(row.agent) || null,
-          cwd: clean(row.cwd) || null,
-          clientHostPid: positiveInt(row.clientHostPid),
-          reapedAt: nowIso,
-        };
-        const tombstoneKey = tagTombstoneKey(tombstone);
-        tombstonesByKey.set(tombstoneKey, tombstone);
-        priorityTombstoneKeys.add(tombstoneKey);
-        if (tags.get(tombstone.tag) === sessionId) {
-          tags.delete(tombstone.tag);
-          tagAgents.delete(tombstone.tag);
-          tagCwds.delete(tombstone.tag);
-        }
-      }
-    });
-    return true;
-  }
 
-  function isSessionBusy(sessionId) {
-    const runtime = mgr.getSessionRuntime?.(sessionId);
-    if (runtime?.controller?.signal && !runtime.controller.signal.aborted) return true;
-    if (runtime?.stage) return ACTIVE_STAGES.has(runtime.stage);
-    const session = getLiveSession(sessionId);
-    return ACTIVE_STAGES.has(session?.status || '');
-  }
-
-  // Provider init de-dup lives in ./agent-tool/provider-init.mjs; the factory
-  // keeps its per-provider chain/ready state private per agent instance. The
-  // chain-gate defaults to the spawn-prep cap (see provider-init.mjs comments).
-  const { ensureProvider } = createProviderInit(reg, DEFAULT_SPAWN_PREP_TIMEOUT_MS);
-
-  function list({ scanSessions = false, context = {} } = {}) {
-    refreshTagsFromSessions({ scanSessions, context });
-    const now = Date.now();
-    const rows = [];
-    for (const { tag, session } of agentSessionEntries({ scanSessions, context })) {
-      const sessionId = session.id;
-      const runtime = mgr.getSessionRuntime?.(sessionId);
-      const status = session.closed === true ? 'closed' : (session.status || 'idle');
-      const stage = session.stage || (status === 'idle' || status === 'error' || status === 'closed'
-        ? status
-        : (runtime?.stage || status));
-      const progress = sessionProgressExtras(sessionId, session.agent || null, now);
-      rows.push({
-        tag,
-        sessionId,
-        agent: session.agent || null,
-        provider: session.provider,
-        model: session.model,
-        preset: session.presetName || null,
-        effort: session.effort || null,
-        fast: session.fast === true,
-        status,
-        stage,
-        ...progress,
-        createdAt: session.createdAt || null,
-        updatedAt: session.updatedAt || null,
-        lastUsedAt: session.lastUsedAt || null,
-        clientHostPid: session.clientHostPid || null,
-        lastStreamDeltaAt: runtime?.lastStreamDeltaAt ? new Date(runtime.lastStreamDeltaAt).toISOString() : null,
-        staleSeconds: runtime?.lastStreamDeltaAt ? Math.floor((now - runtime.lastStreamDeltaAt) / 1000) : null,
-        windowTokens: Number(session.lastContextTokens ?? session.lastInputTokens) || 0,
-        windowCap: Number(session.contextWindow) || null,
-        permission: session.permission || null,
-        toolPermission: session.toolPermission || null,
-        messages: Array.isArray(session.messages) ? session.messages.length : Math.max(0, Number(session.messageCount || 0)),
-        tools: Array.isArray(session.tools) ? session.tools.length : Math.max(0, Number(session.toolCount || 0)),
-      });
-    }
-    return rows;
-  }
-
-  function sessionProgressExtras(sessionId, role, now = Date.now(), taskStatus = null) {
-    if (!sessionId) return {};
-    const session = mgr.getSession(sessionId);
-    const runtime = mgr.getSessionRuntime?.(sessionId) || null;
-    const snapshot = typeof mgr.getSessionProgressSnapshot === 'function'
-      ? mgr.getSessionProgressSnapshot(sessionId)
-      : null;
-    const policy = role ? resolveAgentWatchdogPolicy(role) : null;
-    const queuedFollowups = typeof mgr.getSessionPendingMessageDepth === 'function'
-      ? mgr.getSessionPendingMessageDepth(sessionId)
-      : null;
-    return buildAgentTaskProgressFields({
-      now,
-      sessionStatus: session?.status || null,
-      runtimeStage: runtime?.stage || snapshot?.stage || session?.status || null,
-      snapshot,
-      runtime,
-      policy,
-      queuedFollowups,
-      taskStatus,
-      lastToolCall: runtime?.lastToolCall || null,
-    });
-  }
-
-  function jobWorkerSnapshot(sessionId) {
-    if (!sessionId) return null;
-    const session = mgr.getSession(sessionId);
-    if (!session) return null;
-    const runtime = mgr.getSessionRuntime?.(sessionId);
-    const status = session.closed === true ? 'closed' : (session.status || 'idle');
-    const progress = sessionProgressExtras(sessionId, session.agent || null);
-    return {
-      workerStatus: status,
-      stage: progress.worker_stage || runtime?.stage || status,
-      clientHostPid: session.clientHostPid || null,
-      lastStreamDeltaAt: runtime?.lastStreamDeltaAt ? new Date(runtime.lastStreamDeltaAt).toISOString() : null,
-      ...progress,
-    };
-  }
-
-  function listJobs(context = {}) {
-    const wantedPid = terminalPidForContext(context);
-    const rows = listBackgroundTasks({ surface: 'agent', context }).map((task) => ({
-      task_id: task.task_id,
-      type: task.operation,
-      status: task.status,
-      tag: task.tag || null,
-      sessionId: task.sessionId || null,
-      agent: task.agent || null,
-      preset: task.preset || null,
-      provider: task.provider || null,
-      model: task.model || null,
-      effort: task.effort || null,
-      fast: task.fast === true || task.fast === false ? task.fast : null,
-      maxLoopIterations: task.maxLoopIterations || null,
-      startedAt: task.startedAt,
-      finishedAt: task.finishedAt || null,
-      error: task.error || null,
-      ...jobWorkerSnapshot(task.sessionId),
-      ...sessionProgressExtras(task.sessionId, task.agent || null, Date.now(), task.status),
-    }));
-    return wantedPid
-      ? rows.filter((row) => {
-        const pid = positiveInt(row.clientHostPid);
-        // Spawn-prep rows have no worker session (and therefore no pid) yet;
-        // they already passed taskMatchesScope, so the queued spawn stays
-        // visible instead of vanishing until a pool slot frees up (user bug:
-        // "spawned 5, only 4 listed").
-        return pid ? pid === wantedPid : true;
-      })
-      : rows;
-  }
-
-  function getJob(args, context = {}) {
-    const taskId = taskIdFromArgs(args);
-    if (taskId) {
-      const task = getBackgroundTask(taskId, { surface: 'agent', context });
-      if (!task) throw new Error(`agent read/status: task "${taskId}" not found`);
-      return task;
-    }
-    // Fall back to tag/sessionId resolution, same precedence as close()
-    // (agent-tool.mjs close()): clean(args.tag || args.sessionId || ...).
-    const target = clean(args.tag || args.sessionId);
-    if (!target) throw new Error('agent read/status: task_id, tag, or sessionId is required');
-    const candidates = listBackgroundTasks({ surface: 'agent', context })
-      .filter(Boolean)
-      .filter((row) => row.tag === target || row.sessionId === target);
-    if (!candidates.length) throw new Error(`agent read/status: no task found for tag/sessionId "${target}"`);
-    // Prefer most recent when multiple tasks match the same tag.
-    candidates.sort((a, b) => new Date(b.startedAt || 0) - new Date(a.startedAt || 0));
-    const task = getBackgroundTask(candidates[0].task_id, { surface: 'agent', context });
-    if (!task) throw new Error(`agent read/status: task "${candidates[0].task_id}" not found`);
-    return task;
-  }
-
-  // Background tasks are process-memory only; a worker SESSION can outlive
-  // its spawn task (task pruned, engine restarted). read/status by tag then
-  // used to throw "no task found" even though the worker exists. Fall back to
-  // a synthetic job view built from the worker session, with the last
-  // assistant message as the readable result.
-  function workerFallbackJob(target, context = {}) {
-    refreshTagsFromSessions({ scanSessions: true, context });
-    const sessionId = tags.get(target) || (mgr.getSession(target) ? target : null);
-    if (!sessionId) return null;
-    const session = mgr.getSession(sessionId);
-    if (!session) return null;
-    const status = session.closed === true ? 'closed' : (session.status || 'idle');
-    const msgs = Array.isArray(session.messages) ? session.messages : [];
-    const lastAssistant = [...msgs].reverse().find((m) => m?.role === 'assistant'
-      && (typeof m.content === 'string' ? m.content.trim() : m.content));
-    const resultText = lastAssistant
-      ? (typeof lastAssistant.content === 'string' ? lastAssistant.content : JSON.stringify(lastAssistant.content))
-      : '(worker session has no assistant output yet)';
-    return {
-      taskId: null,
-      operation: 'worker',
-      status,
-      startedAt: session.createdAt || null,
-      finishedAt: null,
-      error: null,
-      result: resultText,
-      meta: {
-        tag: tags.has(target) ? target : (session.tag || null),
-        sessionId,
-        agent: session.agent || null,
-        preset: session.presetName || null,
-        provider: session.provider || null,
-        model: session.model || null,
-        effort: session.effort || null,
-        fast: session.fast === true,
-        maxLoopIterations: null,
-      },
-    };
-  }
-
-  function getJobOrWorker(args, context = {}) {
-    try {
-      return getJob(args, context);
-    } catch (error) {
-      const target = clean(args.tag || args.sessionId);
-      const fallback = target ? workerFallbackJob(target, context) : null;
-      if (fallback) return fallback;
-      throw error;
-    }
-  }
-
-  function renderJob(job, includeResult = false) {
-    const meta = job.meta || {};
-    let progress = sessionProgressExtras(meta.sessionId, meta.agent || null, Date.now(), job.status);
-    // Spawn is deferred: before the worker session exists, sessionProgressExtras
-    // returns {} and the status card would show only "status: running" with no
-    // stage/progress. Fill a minimal stage so the caller can tell the job is
-    // still spinning up rather than silently stalled.
-    if (!meta.sessionId && (!progress || Object.keys(progress).length === 0)) {
-      const spawning = job.status === 'running';
-      progress = {
-        worker_stage: spawning ? 'spawning' : (job.status || 'unknown'),
-        last_progress: spawning ? 'spawning worker session' : (job.status || 'unknown'),
-        diagnostic: spawning ? 'worker session not started yet' : (job.status || 'unknown'),
-      };
-    }
-    return {
-      task_id: job.taskId,
-      type: job.operation,
-      status: job.status,
-      tag: meta.tag || null,
-      sessionId: meta.sessionId || null,
-      agent: meta.agent || null,
-      ...(meta.respawned === true ? { respawned: true, note: 'previous session reaped — fresh session, no prior context; re-supply anchors if needed' } : {}),
-      preset: meta.preset || null,
-      provider: meta.provider || null,
-      model: meta.model || null,
-      effort: meta.effort || null,
-      fast: meta.fast === true || meta.fast === false ? meta.fast : null,
-      maxLoopIterations: meta.maxLoopIterations || null,
-      startedAt: job.startedAt,
-      finishedAt: job.finishedAt || null,
-      error: job.error || null,
-      ...jobWorkerSnapshot(meta.sessionId),
-      ...progress,
-      ...(includeResult && job.result !== undefined ? { result: job.result } : {}),
-    };
-  }
-
-  function preparedSpawnMeta(prepared, extras = {}) {
-    return sanitizeTaskMeta({
-      ...(extras || {}),
-      tag: prepared.tag,
-      sessionId: prepared.session.id,
-      agent: prepared.agent,
-      preset: presetKey(prepared.preset) || prepared.presetName,
-      provider: prepared.preset.provider,
-      model: prepared.preset.model,
-      effort: prepared.preset.effort || null,
-      fast: prepared.preset.fast === true,
-      maxLoopIterations: prepared.maxLoopIterations || null,
-    });
-  }
-
-  function pendingSpawnMeta(args = {}, extras = {}) {
-    const agent = normalizeAgentName(args.agent);
-    // Best-effort resolve the default preset so the pending "Spawn …" card can
-    // already show the model (e.g. "Spawn Heavy Worker (Opus 4.8)") even when
-    // the caller did not pass an explicit provider/model. Never throw: fall back
-    // to whatever raw args carry.
-    let resolved = null;
-    if (!clean(args.model) || !clean(args.provider)) {
-      try { resolved = resolveAgentSpawnPreset(cfgMod.loadConfig(), args)?.preset || null; }
-      catch { resolved = null; }
-    }
-    return sanitizeTaskMeta({
-      ...(extras || {}),
-      tag: clean(args.tag) || null,
-      sessionId: null,
-      agent: agent || null,
-      preset: clean(args.preset) || presetKey(resolved) || null,
-      provider: clean(args.provider) || clean(resolved?.provider) || null,
-      model: clean(args.model) || clean(resolved?.model) || null,
-      effort: clean(args.effort) || clean(resolved?.effort) || null,
-      fast: args.fast === true ? true : (resolved?.fast === true ? true : null),
-    });
-  }
-
-  function mergeJobMeta(job, meta = {}) {
-    if (!job || !meta || typeof meta !== 'object') return;
-    const next = sanitizeTaskMeta({ ...(job.meta || {}), ...meta });
-    job.meta = next;
-    if (job.input && typeof job.input === 'object') {
-      job.input = {
-        ...job.input,
-        tag: next.tag || job.input.tag || null,
-        sessionId: next.sessionId || job.input.sessionId || null,
-        agent: next.agent || job.input.agent || null,
-      };
-    }
-    job.label = next.tag || next.sessionId || job.label;
-  }
-
-  function closePreparedSpawn(prepared, reason = 'agent-task-cancel') {
-    if (!prepared?.session?.id) return;
-    try { mgr.closeSession(prepared.session.id, reason); } catch {}
-    try { clearAgentStatuslineRoute(prepared.session.id); } catch {}
-    forgetTerminalSession(prepared.tag, prepared.session.id);
-  }
-
-  // Owner/worker completion notification lives in ./agent-tool/notify.mjs; the
-  // factory captures mgr and registers the canonical completion fallback.
-  const { workerNotifyFn, notifyOwnerAgentCompletionEarly } = createNotify(mgr);
-
-  function startJob(type, meta, run, notifyContext = null) {
-    const clientHostPid = terminalPidForContext(notifyContext);
-    const jobMeta = sanitizeTaskMeta({
-      ...(meta || {}),
-      ...(clientHostPid ? { clientHostPid } : {}),
+    // Spawn/job lifecycle (startJob/watchdogs/prepare/run): agent-tool/spawn-flow.mjs.
+    const {
+      closePreparedSpawn,
+      workerNotifyFn,
+      notifyOwnerAgentCompletionEarly,
+      startJob,
+      startDeferredSpawnJob,
+      progressWatchdogs,
+      startProgressIdleWatchdog,
+      prepareSpawn,
+      tryShardEnqueue,
+      runShardSpawn,
+      prepareSpawnInProcess,
+      runSpawn,
+    } = createSpawnFlow({
+      mgr,
+      forgetTerminalSession,
+      pendingSpawnMeta,
+      DEFAULT_SPAWN_PREP_TIMEOUT_MS,
+      mergeJobMeta,
+      preparedSpawnMeta,
+      upsertWorkerSessionDeferred,
+      refreshTagsFromSessions,
+      readWorkerRows,
+      defaultCwd,
+      nextTag,
+      cancelReap,
+      bindTag,
+      emitSubagentEvent,
+      scheduleReap,
+      cfgMod,
+      dataDir,
+      STANDALONE_SOURCE_ROOT,
+      ensureProvider,
+      resolveTag,
+      wantsSessionScan,
+      createTurnReviewCollector,
     });
-    let task;
-    const admissionController = new AbortController();
-    task = startBackgroundTask({
-      surface: 'agent',
-      operation: type,
-      label: jobMeta?.tag || jobMeta?.sessionId || type,
-      input: { type, tag: jobMeta?.tag || null, sessionId: jobMeta?.sessionId || null, agent: jobMeta?.agent || null },
-      context: notifyContext,
-      meta: jobMeta,
-      resultType: 'agent_task_result',
-      renderResult: (result) => renderResult(result),
-      cancel: () => {
-        try { admissionController.abort(new Error('agent task cancelled before resource admission')); } catch {}
-        const currentMeta = task?.meta || jobMeta;
-        if (currentMeta?.sessionId) {
-          try { mgr.closeSession(currentMeta.sessionId, 'agent-task-cancel'); } catch {}
-        }
-        // Sharded spawn: the live session exists only in the shard child —
-        // forward the cancel by sessionId (known after the `spawned` progress
-        // event) or tag.
-        if (agentShardEnabled() && (currentMeta?.tag || currentMeta?.sessionId)) {
-          try {
-            void shardRequest('cancel', {
-              tag: currentMeta?.tag || null,
-              sessionId: currentMeta?.sessionId || null,
-            }).catch(() => {});
-          } catch { /* best-effort */ }
-        }
-      },
-      run: async () => {
-        const lease = await resourceAdmission.acquire('agent', {
-          signal: admissionController.signal,
-          label: jobMeta?.tag || type,
-        });
-        try {
-          // Yield one macrotask before doing agent work. startBackgroundTask uses
-          // a Promise microtask, which otherwise begins CPU-heavy spawn prep
-          // before the TUI receives/render the "running" result.
-          await new Promise((resolve) => setImmediate(resolve));
-          if (task?.status === 'cancelled') return null;
-          return await resourceAdmission.runWithLease(lease, () => run(task));
-        } finally {
-          await lease.release();
-        }
-      },
-    });
-    return task;
-  }
-
-  function startDeferredSpawnJob(args, callerCwd, context, notifyContext, extras = {}) {
-    return startJob('spawn', pendingSpawnMeta(args, extras), async (job) => {
-      if (job?.status === 'cancelled') return null;
-      // P1 agent sharding (MIXDOG_AGENT_SHARD=1, default off): run the worker
-      // session in a shard child process instead of this event loop. Prompt
-      // resolution stays here (cheap); prep + the full agent loop run in the
-      // shard. Tag/index/watchdog parity lands in P2 (docs/agent-shard-design.md).
-      if (agentShardEnabled()) {
-        return await runShardSpawn(args, callerCwd, context, job);
-      }
-      // prepareSpawn (ensureProvider/prepareAgentSession) runs before runSpawn
-      // installs its progress watchdog, so guard prep with an internal env-
-      // backed cap rather than exposing per-call timeout knobs on the agent
-      // tool surface.
-      const prepDeadlineMs = nonNegativeInt(args.spawnPrepTimeoutMs ?? args.prepTimeoutMs)
-        ?? DEFAULT_SPAWN_PREP_TIMEOUT_MS;
-      let prepared;
-      const prepState = { timedOut: false };
-      if (prepDeadlineMs > 0) {
-        let prepTimer = null;
-        let timedOut = false;
-        // If prep wins the race we use its result. If the timeout wins, the
-        // prepareSpawn promise may still resolve later with a fully-built
-        // session/tag/route — attach a cleanup so the late-arriving prepared is
-        // torn down, otherwise the orphaned tag would collide on re-spawn.
-        const prepPromise = prepareSpawn(args, callerCwd, context, prepState);
-        prepPromise.then((late) => {
-          if (timedOut) closePreparedSpawn(late, 'agent-spawn-prep-timeout');
-        }, () => {});
-        const timeout = new Promise((_resolve, reject) => {
-          prepTimer = setTimeout(() => {
-            timedOut = true;
-            prepState.timedOut = true;
-            reject(new Error(`agent spawn prep timed out (${prepDeadlineMs}ms) before model request`));
-          }, prepDeadlineMs);
-          prepTimer.unref?.();
-        });
-        try {
-          prepared = await Promise.race([prepPromise, timeout]);
-        } finally {
-          if (prepTimer) clearTimeout(prepTimer);
-        }
-      } else {
-        prepared = await prepareSpawn(args, callerCwd, context, prepState);
-      }
-      mergeJobMeta(job, preparedSpawnMeta(prepared, extras));
-      upsertWorkerSessionDeferred(prepared.session, prepared.tag, {
-        ...preparedSpawnMeta(prepared, extras),
-        status: 'running',
-        stage: 'running',
-        task_id: job.taskId,
-        startedAt: job.startedAt,
-      });
-      if (job?.status === 'cancelled') {
-        closePreparedSpawn(prepared);
-        return null;
-      }
-      return await runSpawn(prepared, notifyContext, job);
-    }, notifyContext);
-  }
-
-  // Idle-progress watchdogs (shared sweep timer) live in
-  // agent-watchdog-registry.mjs.
-  const progressWatchdogs = createProgressWatchdogRegistry({ mgr });
-  const startProgressIdleWatchdog = (sessionId, watchdogPolicy, agent = null) =>
-    progressWatchdogs.start(sessionId, watchdogPolicy, agent);
-
-  async function prepareSpawn(args, callerCwd = null, context = {}, prepState = null) {
-    // (sharded spawns never reach here — see startDeferredSpawnJob)
-    refreshTagsFromSessions({ context });
-    return prepareSpawnInProcess(args, callerCwd, context, prepState);
-  }
-
-  // Tag-reuse routing for sharded workers (P2): a same-tag spawn/send while
-  // the shard runs the session mirrors the in-process busy-session enqueue.
-  // Discriminator: a non-terminal worker-index row whose session has no live
-  // runtime in THIS process. (mgr.getSession must not be used here — it
-  // falls back to the on-disk session file the shard child persists, which
-  // makes a shard-owned session look lead-live.) Returns the rendered queued
-  // result, or null to fall through to the normal path (unknown tag,
-  // terminal row, lead-owned runtime, or the shard no longer owns the
-  // session — e.g. after a shard crash, where respawn is the correct
-  // recovery).
-  async function tryShardEnqueue(target, args, context, extras = {}) {
-    if (!agentShardEnabled()) return null;
-    const value = clean(target);
-    if (!value) return null;
-    const row = readWorkerRows(context).find((r) => (
-      (clean(r.tag) === value || clean(r.sessionId) === value)
-      && rowMatchesContext(r, context)
-      && !isTerminalWorkerStatus(r.status || r.stage)
-    ));
-    if (!row) return null;
-    const rowSessionId = clean(row.sessionId);
-    const runtime = rowSessionId ? mgr.getSessionRuntime?.(rowSessionId) : null;
-    if (runtime?.controller?.signal && !runtime.controller.signal.aborted) return null;
-    const prompt = await resolvePrompt(args, clean(row.cwd) || defaultCwd || process.cwd());
-    if (!clean(prompt)) return null;
-    let queued = null;
-    try {
-      queued = await shardRequest('enqueue', {
-        tag: clean(row.tag) || null,
-        sessionId: rowSessionId || null,
-        prompt,
-      });
-    } catch { return null; }
-    if (queued?.queued !== true) return null;
-    return renderResult({
-      queued: true,
-      ...extras,
-      tag: clean(row.tag) || null,
-      sessionId: rowSessionId || null,
-      agent: clean(row.agent) || null,
-      queueDepth: queued.queueDepth || 1,
-    });
-  }
-
-  async function runShardSpawn(args, callerCwd, context, job) {
-    const agent = normalizeAgentName(args.agent);
-    if (!agent) throw new Error('agent spawn: agent is required');
-    const tag = clean(args.tag) || nextTag(agent, context);
-    const baseCwd = resolve(callerCwd || defaultCwd || process.cwd());
-    const workerCwd = clean(args.cwd) ? resolve(baseCwd, args.cwd) : baseCwd;
-    const prompt = withCwdHeader(await resolvePrompt(args, workerCwd), workerCwd);
-    const clientHostPid = terminalPidForContext(context) || null;
-    // P2 progress parity: the shard reports the bound session the moment it
-    // exists (`spawned`), so the lead mirrors its in-process spawn
-    // bookkeeping — tag maps, worker-index row, statusline route, job meta,
-    // SubagentStart — while the worker loop runs in the child.
-    let spawned = null;
-    const onSpawned = (payload = {}) => {
-      if (spawned || !payload.sessionId) return;
-      spawned = payload;
-      const sessionLike = {
-        id: payload.sessionId,
-        agent,
-        cwd: payload.cwd || workerCwd,
-        provider: payload.provider || null,
-        model: payload.model || null,
-        presetName: payload.presetName || null,
-        effort: payload.effort || null,
-        fast: payload.fast === true,
-        clientHostPid,
-        status: 'running',
-      };
-      cancelReap(payload.sessionId);
-      writeAgentStatuslineRoute(payload.sessionId, {
-        provider: payload.provider || null,
-        model: payload.model || null,
-        effort: payload.effort || null,
-        fast: payload.fast === true,
-      });
-      bindTag(tag, sessionLike, {
-        agent,
-        preset: payload.presetName || null,
-        provider: payload.provider || null,
-        model: payload.model || null,
-        effort: payload.effort || null,
-        fast: payload.fast === true,
-        status: 'running',
-        stage: 'running',
-      });
-      if (job) {
-        mergeJobMeta(job, {
-          tag,
-          sessionId: payload.sessionId,
-          agent,
-          preset: payload.presetName || null,
-          provider: payload.provider || null,
-          model: payload.model || null,
-          effort: payload.effort || null,
-          fast: payload.fast === true,
-        });
-      }
-      emitSubagentEvent('start', agent, { session_id: payload.sessionId, tag });
-      // Cancel raced the shard prep: the task is already terminal on the lead
-      // but the child just started its loop — abort it now that the sessionId
-      // is known, instead of letting it burn tokens to completion.
-      if (job?.status === 'cancelled') {
-        try { void shardRequest('cancel', { tag, sessionId: payload.sessionId }).catch(() => {}); } catch { /* best-effort */ }
-      }
-    };
-    let finalStatus = 'error';
-    try {
-      const response = await shardRequest('spawn', {
-        args: {
-          agent,
-          provider: args.provider,
-          model: args.model,
-          effort: args.effort,
-          fast: args.fast,
-          preset: args.preset,
-        },
-        tag,
-        cwd: workerCwd,
-        prompt,
-        context: args.context || null,
-        parentSessionId: clean(context?.callerSessionId || context?.sessionId) || null,
-        ownerSessionId: clean(context?.callerSessionId || context?.sessionId) || null,
-        clientHostPid,
-      }, {
-        onProgress: (event, payload) => { if (event === 'spawned') onSpawned(payload); },
-      });
-      // Same abnormal-empty promotion as the in-process completionValue; a
-      // watchdog partial handoff (stallAbort) is a valid completion and is
-      // exempt, matching runSpawn's catch path.
-      const abnormalError = response?.stallAbort === true
-        ? null
-        : abnormalEmptyFinishError(response, agent);
-      const value = {
-        tag,
-        sessionId: response.sessionId,
-        agent,
-        preset: response.presetName || null,
-        provider: response.provider || null,
-        model: response.model || null,
-        effort: response.effort || null,
-        fast: response.fast === true,
-        content: response.content || '',
-        ...(response.stallAbort === true ? { stallAbort: true } : {}),
-        ...(abnormalError ? { error: abnormalError } : {}),
-      };
-      if (job) job._terminalResultValue = value;
-      if (value.error) throw new Error(value.error);
-      finalStatus = 'idle';
-      return value;
-    } finally {
-      // Terminal bookkeeping parity with runSpawn's finally: worker-index row
-      // transitions to idle/error, the terminal-reap timer starts (tombstone +
-      // statusline cleanup), and SubagentStop fires. Only after `spawned` —
-      // a prep failure inside the shard bound nothing on the lead.
-      if (spawned?.sessionId) {
-        upsertWorkerSessionDeferred({
-          id: spawned.sessionId,
-          agent,
-          cwd: spawned.cwd || workerCwd,
-          provider: spawned.provider || null,
-          model: spawned.model || null,
-          presetName: spawned.presetName || null,
-          effort: spawned.effort || null,
-          fast: spawned.fast === true,
-          clientHostPid,
-          status: finalStatus,
-        }, tag, {
-          agent,
-          preset: spawned.presetName || null,
-          provider: spawned.provider || null,
-          model: spawned.model || null,
-          effort: spawned.effort || null,
-          fast: spawned.fast === true,
-          status: finalStatus,
-          stage: finalStatus,
-          finishedAt: new Date().toISOString(),
-        });
-        scheduleReap(spawned.sessionId, spawned.provider || null);
-        emitSubagentEvent('stop', agent, { session_id: spawned.sessionId, tag, status: finalStatus });
-      }
-    }
-  }
-
-  async function prepareSpawnInProcess(args, callerCwd = null, context = {}, prepState = null) {
-    const config = cfgMod.loadConfig();
-    const agent = normalizeAgentName(args.agent);
-    if (!agent) throw new Error('agent spawn: agent is required');
-    const agentPermission = readAgentFrontmatterPermission(agent, dataDir, STANDALONE_SOURCE_ROOT);
-    const agentPerm = normalizeAgentPermission(agentPermission) || null;
-    const { presetName, preset } = resolveAgentSpawnPreset(config, args);
-    await ensureProvider(config, preset.provider);
-    if (prepState?.timedOut) {
-      throw new Error('agent spawn prep timed out before session bind');
-    }
-
-    const tag = clean(args.tag) || nextTag(agent, context);
-    // Any resolved same-tag binding in this terminal (live or lingering trace)
-    // blocks a fresh spawn. execute() routes live reuse before prepareSpawn.
-    if (resolveTag(tag, context, { scanSessions: wantsSessionScan(args) })) {
-      throw new Error(`agent spawn: tag "${tag}" already exists`);
-    }
-    const baseCwd = resolve(callerCwd || defaultCwd || process.cwd());
-    const workerCwd = clean(args.cwd) ? resolve(baseCwd, args.cwd) : baseCwd;
-    const prompt = withCwdHeader(await resolvePrompt(args, workerCwd), workerCwd);
-    if (prepState?.timedOut) {
-      throw new Error('agent spawn prep timed out before session bind');
-    }
-    const runtimeSpec = cfgMod.resolveRuntimeSpec(preset, { lane: 'agent', agentId: tag });
-    const maxLoopIterations = positiveInt(args.maxLoopIterations) || null;
-    const watchdogPolicy = resolveAgentWatchdogPolicy(agent);
-    const { session, effectiveCwd } = prepareAgentSession({
-      agent,
-      presetName,
-      preset,
-      runtimeSpec,
-      owner: AGENT_OWNER,
-      cwd: workerCwd,
-      sourceType: 'cli',
-      sourceName: agent,
-      parentSessionId: clean(context?.callerSessionId || context?.sessionId) || null,
-      ownerSessionId: clean(context?.callerSessionId || context?.sessionId) || null,
-      clientHostPid: terminalPidForContext(context) || null,
-      agentTag: tag,
-      taskType: clean(args.taskType) || clean(args.typeHint) || undefined,
-      maxLoopIterations: maxLoopIterations || undefined,
-      permission: agentPerm || undefined,
-      cacheKeyOverride: args.cacheKey || undefined,
-    });
-    // Lead sessions write a gateway-session route when created; agent sessions
-    // are built through prepareAgentSession(), so mirror that registration here
-    // or the vendored L1/L2 statusline cannot resolve the agent route/model.
-    writeAgentStatuslineRoute(session.id, preset);
-    bindTag(tag, session, {
-      agent,
-      preset: presetKey(preset) || presetName,
-      provider: preset.provider,
-      model: preset.model,
-      effort: preset.effort || null,
-      fast: preset.fast === true,
-      status: 'idle',
-      stage: 'idle',
-    });
-    cancelReap(session.id);
-    return {
-      args,
-      tag,
-      session,
-      agent,
-      preset,
-      presetName,
-      workerCwd: effectiveCwd || workerCwd,
-      prompt,
-      maxLoopIterations,
-      watchdogPolicy,
-    };
-  }
-
-  async function runSpawn(prepared, notifyContext = null, job = null) {
-    const { args, tag, session, agent, preset, presetName, workerCwd, prompt, watchdogPolicy } = prepared;
-    const watchdog = startProgressIdleWatchdog(session.id, watchdogPolicy, agent);
-    const turnReview = createTurnReviewCollector(session, tag, agent, notifyContext || {});
-    let finalStatus = 'idle';
-    // SubagentStart: a worker session is about to run its first turn.
-    emitSubagentEvent('start', agent, { session_id: session.id, tag });
-    upsertWorkerSessionDeferred(session, tag, {
-      agent,
-      preset: presetKey(preset) || presetName,
-      provider: preset.provider,
-      model: preset.model,
-      effort: preset.effort || null,
-      fast: preset.fast === true,
-      status: 'running',
-      stage: 'running',
-    });
-    let handoffMsgStart = 0;
-    try {
-      const completionValue = (result) => {
-        // Promote an abnormal finish (iteration cap, truncation, or a public
-        // agent's empty terminal turn) to an explicit error, so the Lead
-        // receives it as a failure with an accurate reason instead of a silent
-        // `completed` empty result. Keyed off loop.mjs terminationReason;
-        // hidden agents finishing normally-empty are left untagged (benign).
-        const abnormalError = abnormalEmptyFinishError(result, agent);
-        return {
-          tag,
-          sessionId: session.id,
-          agent,
-          preset: presetKey(preset) || presetName,
-          provider: preset.provider,
-          model: preset.model,
-          effort: preset.effort || null,
-          fast: preset.fast === true,
-          content: result?.content || '',
-          ...(abnormalError ? { error: abnormalError } : {}),
-        };
-      };
-      handoffMsgStart = resolveHandoffMessageStartIndex(mgr.getSession(session.id));
-      const result = await mgr.askSession(session.id, prompt, args.context || null, null, workerCwd, null, {
-        notifyFn: workerNotifyFn(session.id, notifyContext || {}),
-        onToolResult: (message) => turnReview.onToolResult(message),
-        ...(job ? {
-          onTerminalResult: (terminalResult) => {
-            turnReview.complete();
-            const value = completionValue(terminalResult);
-            if (job) job._terminalResultValue = value;
-            notifyOwnerAgentCompletionEarly(job, value, notifyContext || {});
-            // Mark the task terminal the moment the worker produces its final
-            // result, so a hung/slow post-result session save cannot strand the
-            // task (and the status card) in `running`. Idempotent; the finally
-            // reconcile remains a backup for the error/no-terminal-result path.
-            if (job?.taskId) {
-              try {
-                // An empty/abnormal finish is a failure, not a completion:
-                // reconcile as `failed` with the accurate error so the Lead
-                // card renders `error: …` instead of a header-only empty card.
-                reconcileBackgroundTask(job.taskId, value.error
-                  ? {
-                      status: 'failed',
-                      result: value,
-                      error: value.error,
-                      terminalReason: 'agent-empty-final',
-                    }
-                  : {
-                      status: 'completed',
-                      result: value,
-                      terminalReason: 'agent-terminal-result',
-                    });
-              } catch {}
-            }
-          },
-        } : {}),
-      });
-      // The early preview no longer promises body suppression, so the canonical
-      // notifyTaskCompletion is left to fire exactly once with output via the
-      // resolve/reconcile/finally path.
-      const finalValue = completionValue(result);
-      // Non-job return path (or job path where the terminal-result reconcile
-      // already ran): if the finish was abnormal-empty, surface it as a thrown
-      // error so finalStatus becomes 'error' and the caller's error path (and
-      // the finally reconcile below, as `failed`) render the accurate reason.
-      if (finalValue.error) {
-        finalStatus = 'error';
-        if (job) job._terminalResultValue = finalValue;
-        throw new Error(finalValue.error);
-      }
-      return finalValue;
-    } catch (error) {
-      const partial = watchdogPartialHandoffFromError(error, mgr.getSession(session.id), handoffMsgStart);
-      if (partial) {
-        finalStatus = 'idle';
-        const value = {
-          tag,
-          sessionId: session.id,
-          agent,
-          preset: presetKey(preset) || presetName,
-          provider: preset.provider,
-          model: preset.model,
-          effort: preset.effort || null,
-          fast: preset.fast === true,
-          content: partial,
-          stallAbort: true,
-        };
-        if (job) job._terminalResultValue = value;
-        if (job?.taskId) {
-          try {
-            reconcileBackgroundTask(job.taskId, {
-              status: 'completed',
-              result: value,
-              terminalReason: 'agent-watchdog-partial',
-            });
-          } catch {}
-        }
-        return value;
-      }
-      finalStatus = 'error';
-      // Part C: a mid-stream stall (StreamStalledError / ESTREAMSTALL) throws
-      // here WITHOUT a terminal result, so the finally reconcile below (gated on
-      // _terminalResultValue) would be skipped and only the outer task-reject
-      // path would notify. Belt-and-suspenders: reconcile this job to `failed`
-      // now so the owner (Lead) always gets a failure notification instead of a
-      // task stranded in `running`. Idempotent — completeBackgroundTask no-ops
-      // once terminal, so the outer reject path can't double-notify.
-      if (job?.taskId && job._terminalResultValue === undefined) {
-        try {
-          reconcileBackgroundTask(job.taskId, {
-            status: 'failed',
-            error,
-            terminalReason: 'agent-stream-stalled',
-          });
-        } catch {}
-      }
-      throw error;
-    } finally {
-      turnReview.complete();
-      watchdog?.stop?.();
-      upsertWorkerSessionDeferred(session, tag, {
-        agent,
-        preset: presetKey(preset) || presetName,
-        provider: preset.provider,
-        model: preset.model,
-        effort: preset.effort || null,
-        fast: preset.fast === true,
-        status: finalStatus,
-        stage: finalStatus,
-        finishedAt: new Date().toISOString(),
-      });
-      // Safety net: if a post-result step (session save) hung or threw after the
-      // worker already produced a terminal result, the task could otherwise be
-      // stranded in `running`. Reconcile it to a terminal state using the
-      // captured result so the owner gets a completion notification + the
-      // statusline clears. Idempotent once the task is already terminal.
-      if (job && job._terminalResultValue !== undefined) {
-        try {
-          reconcileBackgroundTask(job.taskId, {
-            status: finalStatus === 'error' ? 'failed' : 'completed',
-            result: job._terminalResultValue,
-            ...(finalStatus === 'error' && job._terminalResultValue?.error
-              ? { error: job._terminalResultValue.error }
-              : {}),
-            terminalReason: 'agent-finally-reconcile',
-          });
-        } catch {}
-      }
-      scheduleReap(session.id);
-      // SubagentStop: worker finished (terminal), regardless of outcome.
-      emitSubagentEvent('stop', agent, { session_id: session.id, tag, status: finalStatus });
-    }
-  }
 
   async function spawn(args) {
     return await runSpawn(await prepareSpawn(args));