mixdog 0.9.87 → 0.9.89

package/src/standalone/agent-tool/job-views.mjs

@@ -9,6 +9,45 @@ import { buildAgentTaskProgressFields } from '../agent-task-status.mjs';
 import { clean, normalizeAgentName, positiveInt, presetKey, terminalPidForContext } from './helpers.mjs';
 import { getBackgroundTask, listBackgroundTasks, sanitizeTaskMeta, taskIdFromArgs } from '../../runtime/shared/background-tasks.mjs';
 import { resolveAgentSpawnPreset } from './spawn-preset.mjs';
+import { isTerminalWorkerStatus } from './worker-rows.mjs';
+
+// Job statuses that can never progress again (mirrors TERMINAL_STATUSES in
+// runtime/shared/background-tasks.mjs; 'canceled' accepted defensively).
+const TERMINAL_JOB_STATUSES = new Set(['completed', 'failed', 'cancelled', 'canceled']);
+
+export function isTerminalJobStatus(status) {
+  return TERMINAL_JOB_STATUSES.has(String(status ?? '').trim().toLowerCase());
+}
+
+// A finished job is frozen history. Tags are reused, so its meta.sessionId can
+// point at a session that is NOW running a *different* job; reading live
+// progress for it made every old completed row inherit the current worker's
+// stage ("20 completed rows all reporting streaming/model active"). Terminal
+// rows therefore report only their own recorded status: no live worker
+// snapshot, no silent_for/watchdog/queued_followups.
+export function terminalJobFrozenFields(status, now = Date.now()) {
+  const stage = String(status ?? '').trim().toLowerCase() || 'unknown';
+  return {
+    workerStatus: stage,
+    stage,
+    clientHostPid: null,
+    lastStreamDeltaAt: null,
+    ...buildAgentTaskProgressFields({ now, runtimeStage: stage, taskStatus: stage }),
+  };
+}
+
+// Default /agents worker section = workers that can still do work. Idle,
+// closed, errored and reaped/unknown rows are history and stay reachable
+// through the task section (status/read keep their terminal result).
+export function isActiveWorkerRow(row = {}) {
+  const stage = String(row.stage ?? '').trim().toLowerCase();
+  const status = String(row.status ?? '').trim().toLowerCase();
+  if (ACTIVE_STAGES.has(stage) || ACTIVE_STAGES.has(status)) return true;
+  const effective = stage || status;
+  if (!effective || effective === 'unknown') return false;
+  return !isTerminalWorkerStatus(effective);
+}
+
 export function createJobViews({
   mgr,
   getLiveSession,
@@ -32,7 +71,7 @@ export function createJobViews({
   // 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 = {} } = {}) {
+  function list({ scanSessions = false, context = {}, includeTerminal = false } = {}) {
     refreshTagsFromSessions({ scanSessions, context });
     const now = Date.now();
     const rows = [];
@@ -70,7 +109,7 @@ export function createJobViews({
         tools: Array.isArray(session.tools) ? session.tools.length : Math.max(0, Number(session.toolCount || 0)),
       });
     }
-    return rows;
+    return includeTerminal ? rows : rows.filter((row) => isActiveWorkerRow(row));
   }
 
   function sessionProgressExtras(sessionId, role, now = Date.now(), taskStatus = null) {
@@ -115,25 +154,32 @@ export function createJobViews({
 
   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),
-    }));
+    const now = Date.now();
+    const rows = listBackgroundTasks({ surface: 'agent', context }).map((task) => {
+      const head = {
+        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,
+      };
+      if (isTerminalJobStatus(task.status)) return { ...head, ...terminalJobFrozenFields(task.status, now) };
+      return {
+        ...head,
+        ...jobWorkerSnapshot(task.sessionId),
+        ...sessionProgressExtras(task.sessionId, task.agent || null, now, task.status),
+      };
+    });
     return wantedPid
       ? rows.filter((row) => {
         const pid = positiveInt(row.clientHostPid);
@@ -221,20 +267,7 @@ export function createJobViews({
 
   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 {
+    const head = {
       task_id: job.taskId,
       type: job.operation,
       status: job.status,
@@ -251,9 +284,30 @@ export function createJobViews({
       startedAt: job.startedAt,
       finishedAt: job.finishedAt || null,
       error: job.error || null,
+    };
+    const tail = includeResult && job.result !== undefined ? { result: job.result } : {};
+    // Frozen terminal view: never re-read the (possibly reused) live session.
+    if (isTerminalJobStatus(job.status)) {
+      return { ...head, ...terminalJobFrozenFields(job.status), ...tail };
+    }
+    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 {
+      ...head,
       ...jobWorkerSnapshot(meta.sessionId),
       ...progress,
-      ...(includeResult && job.result !== undefined ? { result: job.result } : {}),
+      ...tail,
     };
   }
 

package/src/standalone/agent-tool/spawn-flow.mjs

@@ -1,15 +1,13 @@
 // Spawn/job lifecycle, extracted from agent-tool.mjs: job start (foreground
 // deferral, admission control), the progress-idle watchdogs, spawn prep
-// (shard enqueue + in-process fallback paths), and the full runSpawn
+// (provider/session preparation), and the full runSpawn
 // execution with turn-review collection and terminal accounting.
-import { clean, clearAgentStatuslineRoute, nonNegativeInt, normalizeAgentName, positiveInt, presetKey, readAgentFrontmatterPermission, resolvePrompt, rowMatchesContext, terminalPidForContext, withCwdHeader, writeAgentStatuslineRoute } from './helpers.mjs';
+import { clean, clearAgentStatuslineRoute, nonNegativeInt, normalizeAgentName, positiveInt, presetKey, readAgentFrontmatterPermission, resolvePrompt, terminalPidForContext, withCwdHeader, writeAgentStatuslineRoute } from './helpers.mjs';
 import { createNotify } from './notify.mjs';
 import { reconcileBackgroundTask, sanitizeTaskMeta, startBackgroundTask } from '../../runtime/shared/background-tasks.mjs';
 import { abnormalEmptyFinishError, renderResult } from './render.mjs';
-import { agentShardEnabled, shardRequest } from '../agent-shard/shard-pool.mjs';
 import { resourceAdmission } from '../../runtime/shared/resource-admission.mjs';
 import { createProgressWatchdogRegistry } from '../agent-watchdog-registry.mjs';
-import { isTerminalWorkerStatus } from './worker-rows.mjs';
 import { resolve } from 'node:path';
 import { normalizeAgentPermission } from '../../runtime/shared/markdown-frontmatter.mjs';
 import { resolveAgentSpawnPreset } from './spawn-preset.mjs';
@@ -25,7 +23,6 @@ export function createSpawnFlow({
   preparedSpawnMeta,
   upsertWorkerSessionDeferred,
   refreshTagsFromSessions,
-  readWorkerRows,
   defaultCwd,
   nextTag,
   cancelReap,
@@ -74,17 +71,6 @@ export function createSpawnFlow({
         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', {
@@ -109,13 +95,6 @@ export function createSpawnFlow({
   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
@@ -158,6 +137,7 @@ export function createSpawnFlow({
         stage: 'running',
         task_id: job.taskId,
         startedAt: job.startedAt,
+        turnStartedAt: new Date().toISOString(),
       });
       if (job?.status === 'cancelled') {
         closePreparedSpawn(prepared);
@@ -170,202 +150,26 @@ export function createSpawnFlow({
   // 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);
+  const startProgressIdleWatchdog = (sessionId, watchdogPolicy, agent = null, options = {}) =>
+    progressWatchdogs.start(sessionId, watchdogPolicy, agent, options);
+
+  // Queued `agent type=send` prompts run as follow-up turns INSIDE one
+  // askSession call, so the dispatch stamp alone would keep the panel elapsed
+  // growing across them. The watchdog sweep reports each turn's start; re-stamp
+  // the worker-index row so elapsed resets at the queued-turn boundary.
+  const turnStartStamper = (session, tag) => (turnStartedAtMs) => {
+    upsertWorkerSessionDeferred(session, tag, {
+      status: 'running',
+      stage: 'running',
+      turnStartedAt: new Date(turnStartedAtMs).toISOString(),
+    });
+  };
 
   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);
@@ -442,7 +246,9 @@ export function createSpawnFlow({
 
   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 watchdog = startProgressIdleWatchdog(session.id, watchdogPolicy, agent, {
+      onTurnStart: turnStartStamper(session, tag),
+    });
     const turnReview = createTurnReviewCollector(session, tag, agent, notifyContext || {});
     let finalStatus = 'idle';
     // SubagentStart: a worker session is about to run its first turn.
@@ -456,6 +262,7 @@ export function createSpawnFlow({
       fast: preset.fast === true,
       status: 'running',
       stage: 'running',
+      turnStartedAt: new Date().toISOString(),
     });
     let handoffMsgStart = 0;
     try {
@@ -609,6 +416,9 @@ export function createSpawnFlow({
       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
+      // process-local provider, shell, watchdog and tool cache immediately.
+      try { mgr.unloadSessionRuntime?.(session.id, 'agent-turn-complete'); } catch {}
     }
   }
 
@@ -620,9 +430,8 @@ export function createSpawnFlow({
     startDeferredSpawnJob,
     progressWatchdogs,
     startProgressIdleWatchdog,
+    turnStartStamper,
     prepareSpawn,
-    tryShardEnqueue,
-    runShardSpawn,
     prepareSpawnInProcess,
     runSpawn,
   };

package/src/standalone/agent-tool/worker-index.mjs

@@ -54,6 +54,7 @@ export function createWorkerIndex({ dataDir, cfgMod, mgr, tags, tagAgents, tagCw
       .map((row) => ({
         tag: clean(row.tag),
         sessionId: clean(row.sessionId),
+        ownerSessionId: clean(row.ownerSessionId || row.parentSessionId) || null,
         agent: clean(row.agent) || null,
         provider: clean(row.provider) || null,
         model: clean(row.model) || null,
@@ -66,6 +67,7 @@ export function createWorkerIndex({ dataDir, cfgMod, mgr, tags, tagAgents, tagCw
         updatedAt: clean(row.updatedAt) || null,
         lastUsedAt: clean(row.lastUsedAt) || null,
         finishedAt: clean(row.finishedAt) || null,
+        turnStartedAt: clean(row.turnStartedAt) || null,
         clientHostPid: positiveInt(row.clientHostPid),
         cwd: clean(row.cwd) || null,
         task_id: clean(row.task_id || row.taskId) || null,
@@ -199,6 +201,9 @@ export function createWorkerIndex({ dataDir, cfgMod, mgr, tags, tagAgents, tagCw
     return {
       tag,
       sessionId,
+      ownerSessionId: clean(extra.ownerSessionId || extra.parentSessionId)
+        || clean(session?.ownerSessionId || session?.parentSessionId)
+        || null,
       agent: clean(extra.agent) || clean(session?.agent) || null,
       provider: clean(extra.provider) || clean(session?.provider) || null,
       model: clean(extra.model) || clean(session?.model) || null,
@@ -211,6 +216,9 @@ export function createWorkerIndex({ dataDir, cfgMod, mgr, tags, tagAgents, tagCw
       updatedAt: clean(extra.updatedAt) || nowIso,
       lastUsedAt: clean(session?.lastUsedAt) || null,
       finishedAt: clean(extra.finishedAt) || null,
+      // Turn dispatch stamps this; terminal upserts leave it null and the
+      // merge in applyWorkerRowUpsert preserves the running turn's value.
+      turnStartedAt: clean(extra.turnStartedAt) || null,
       clientHostPid: positiveInt(extra.clientHostPid) || positiveInt(session?.clientHostPid),
       cwd: clean(session?.cwd) || clean(extra.cwd) || null,
       task_id: clean(extra.task_id || extra.taskId) || null,

package/src/standalone/agent-tool/worker-rows.mjs

@@ -56,7 +56,7 @@ export function applyWorkerRowUpsert(byKey, normalized) {
   if (!key) return;
   const prev = byKey.get(key) || {};
   const merged = { ...prev, ...normalized };
-  for (const field of ['agent', 'provider', 'model', 'preset', 'effort', 'fast', 'clientHostPid', 'cwd', 'task_id', 'permission', 'toolPermission']) {
+  for (const field of ['ownerSessionId', 'agent', 'provider', 'model', 'preset', 'effort', 'fast', 'clientHostPid', 'cwd', 'task_id', 'permission', 'toolPermission', 'turnStartedAt']) {
     if ((merged[field] === null || merged[field] === '') && prev[field] != null && prev[field] !== '') {
       merged[field] = prev[field];
     }
@@ -71,6 +71,7 @@ export function applyWorkerRowUpsert(byKey, normalized) {
 export function workerRowToSession(row = {}) {
   return {
     id: row.sessionId,
+    ownerSessionId: row.ownerSessionId || null,
     agentTag: row.tag,
     agent: row.agent || null,
     provider: row.provider || null,

package/src/standalone/agent-tool.mjs

@@ -62,7 +62,6 @@ import {
 } from './agent-tool/worker-rows.mjs';
 import { resolveAgentTerminalReapMs } from '../session-runtime/config-helpers.mjs';
 import { createWorkerIndex } from './agent-tool/worker-index.mjs';
-import { agentShardEnabled, shardRequest } from './agent-shard/shard-pool.mjs';
 import {
   beginAgentTurnReview,
   completeAgentTurnReview,
@@ -192,9 +191,8 @@ export function createStandaloneAgent({
       startDeferredSpawnJob,
       progressWatchdogs,
       startProgressIdleWatchdog,
+      turnStartStamper,
       prepareSpawn,
-      tryShardEnqueue,
-      runShardSpawn,
       prepareSpawnInProcess,
       runSpawn,
     } = createSpawnFlow({
@@ -242,11 +240,19 @@ export function createStandaloneAgent({
   async function runSend(prepared, notifyContext = null, job = null) {
     const { args, session, sessionId, prompt } = prepared;
     const sendAgent = session.agent || normalizeAgentName(args.agent);
-    const watchdog = startProgressIdleWatchdog(sessionId, resolveAgentWatchdogPolicy(sendAgent), sendAgent);
     const tag = 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 = startProgressIdleWatchdog(sessionId, resolveAgentWatchdogPolicy(sendAgent), sendAgent, {
+      onTurnStart: turnStartStamper(session, tag),
+    });
     const turnReview = createTurnReviewCollector(session, tag, sendAgent, notifyContext || {});
     let finalStatus = 'idle';
-    upsertWorkerSessionDeferred(session, tag, { status: 'running', stage: 'running' });
+    upsertWorkerSessionDeferred(session, tag, {
+      status: 'running',
+      stage: 'running',
+      turnStartedAt: new Date().toISOString(),
+    });
     let handoffMsgStart = 0;
     try {
       const completionValue = (result) => {
@@ -366,6 +372,9 @@ export function createStandaloneAgent({
         } catch {}
       }
       scheduleReap(sessionId);
+      // Same lifecycle as a fresh spawn: the transcript/tag stays resumable,
+      // while heavy process-local runtime state is reclaimed immediately.
+      try { mgr.unloadSessionRuntime?.(sessionId, 'agent-turn-complete'); } catch {}
     }
   }
 
@@ -458,7 +467,9 @@ export function createStandaloneAgent({
       tasksRemoved: cleaned.removed,
       tagsRemoved: beforeTags - tags.size,
       tasks: listJobs(scopedContext).length,
-      workers: list({ scanSessions: wantsSessionScan(args), context: scopedContext }).length,
+      // Cleanup reports how many worker rows remain known (idle/terminal
+      // included); only the /agents worker section hides terminal rows.
+      workers: list({ scanSessions: wantsSessionScan(args), context: scopedContext, includeTerminal: true }).length,
     };
   }
 
@@ -537,11 +548,6 @@ export function createStandaloneAgent({
       if (type === 'cancel') return renderResult(close(args, scopedContext));
       if (type === 'close') return renderResult(close(args, scopedContext));
       if (type === 'send') {
-        // Sharded busy worker: queue the follow-up into the shard-owned live
-        // session (in-process busy sessions are handled below via
-        // dispatchToExistingSession; their lead session resolves live).
-        const shardQueued = await tryShardEnqueue(clean(args.tag || args.sessionId), args, scopedContext);
-        if (shardQueued) return shardQueued;
         try {
           const prepared = await prepareSend(args, scopedContext);
           return dispatchToExistingSession(prepared, notifyContext);
@@ -614,12 +620,6 @@ export function createStandaloneAgent({
         let respawned = false;
         let spawnArgs = args;
         if (explicitTag) {
-          // Sharded busy worker under this tag: queue into the shard-owned
-          // live session BEFORE the live-reuse resolve — the lead's disk-read
-          // session view would otherwise misroute this into an in-process
-          // send against a shard-owned session file (dual writer).
-          const shardQueued = await tryShardEnqueue(explicitTag, args, scopedContext, { reused: true });
-          if (shardQueued) return shardQueued;
           // Resolve a LIVE same-tag session in this terminal (busy or idle).
           let liveSessionId = null;
           try {

package/src/standalone/agent-watchdog-registry.mjs

@@ -32,6 +32,15 @@ export function createProgressWatchdogRegistry({ mgr }) {
     const snapshot = typeof mgr.getSessionProgressSnapshot === 'function'
       ? mgr.getSessionProgressSnapshot(sessionId)
       : null;
+    // Turn boundary: askStartedAt is re-stamped by markSessionAskStart for
+    // EVERY turn of one askSession call, including the follow-up turns drained
+    // from the pending-message queue. The sweep already reads this snapshot, so
+    // observing the change is the cheapest per-turn signal available here.
+    const askStartedAt = Number(snapshot?.askStartedAt || 0);
+    if (askStartedAt > 0 && askStartedAt !== state.lastAskStartedAt) {
+      state.lastAskStartedAt = askStartedAt;
+      try { state.onTurnStart?.(askStartedAt); } catch { /* bookkeeping only */ }
+    }
     const abortErr = snapshot ? evaluateAgentWatchdogAbort(snapshot, now, watchdogPolicy) : null;
     const sess = typeof mgr.getSession === 'function' ? mgr.getSession(sessionId) : null;
     const iteration = typeof sess?.lastIterationIndex === 'number' ? sess.lastIterationIndex : null;
@@ -79,7 +88,7 @@ export function createProgressWatchdogRegistry({ mgr }) {
   return {
     /** Watch a session until the returned handle is stopped; null when the
      *  policy is off or the manager cannot link an abort signal. */
-    start(sessionId, watchdogPolicy, agent = null) {
+    start(sessionId, watchdogPolicy, agent = null, { onTurnStart = null } = {}) {
       if (!sessionId || !agentWatchdogPolicyActive(watchdogPolicy)) return null;
       if (typeof mgr.getSessionProgressSnapshot !== 'function'
         && typeof mgr.getSessionLastProgressAt !== 'function') return null;
@@ -87,7 +96,15 @@ export function createProgressWatchdogRegistry({ mgr }) {
       const controller = new AbortController();
       const anchorTs = Date.now();
       try { mgr.linkParentSignalToSession(sessionId, controller.signal); } catch { return null; }
-      const state = { sessionId, watchdogPolicy, agent, controller, anchorTs };
+      const state = {
+        sessionId,
+        watchdogPolicy,
+        agent,
+        controller,
+        anchorTs,
+        onTurnStart: typeof onTurnStart === 'function' ? onTurnStart : null,
+        lastAskStartedAt: 0,
+      };
       watched.set(sessionId, state);
       ensureTimer();
       return {