mixdog 1.2.2 → 1.2.4

package/src/session-runtime/resource-scope-decorate.mjs

@@ -14,8 +14,13 @@ function listOf(status, key) {
 }
 
 export function createScopeDecorators({ getConfig, getCurrentCwd }) {
-  function scopeInfo(kind, name, pluginId = '', cwd = getCurrentCwd()) {
-    const scopes = extensionScopesFromConfig(getConfig());
+  function scopeInfo(
+    kind,
+    name,
+    pluginId = '',
+    cwd = getCurrentCwd(),
+    scopes = extensionScopesFromConfig(getConfig())
+  ) {
     const scope = extensionScopeProjects(scopes, kind, name);
     const inheritedScope = pluginId ? extensionScopeProjects(scopes, 'plugins', pluginId) : null;
     const activeHere =
@@ -35,11 +40,13 @@ export function createScopeDecorators({ getConfig, getCurrentCwd }) {
     },
     /** `cwd`: decide `activeHere` for that folder instead of the current one. */
     skills(status, cwd = getCurrentCwd()) {
+      // One scope read for the whole list, not one per skill.
+      const scopes = extensionScopesFromConfig(getConfig());
       return {
         ...status,
         skills: listOf(status, 'skills').map((skill) => ({
           ...skill,
-          ...scopeInfo('skills', skill.name, skill?.owner?.kind === 'plugin' ? clean(skill.owner.id) : '', cwd),
+          ...scopeInfo('skills', skill.name, skill?.owner?.kind === 'plugin' ? clean(skill.owner.id) : '', cwd, scopes),
         })),
       };
     },

package/src/session-runtime/route-resolution.mjs

@@ -35,7 +35,7 @@ export function createRouteResolution({ rt, collectProviderModels, ensureProvide
     return rt.route;
   }
 
-  async function refreshRouteEffort(modelMetaOverride = null, expectedRoute = null, signal = null) {
+  async function refreshRouteEffort(modelMetaOverride = null, expectedRoute = null, signal = null, lease = null) {
     const targetRoute = expectedRoute || rt.route;
     await runAbortable(signal, () => ensureProvidersReady(ensureProviderEnabled(rt.config, targetRoute.provider)));
     const modelMeta =
@@ -43,7 +43,9 @@ export function createRouteResolution({ rt, collectProviderModels, ensureProvide
     throwIfAborted(signal);
     // A rapid second resume/model change can replace the route while provider
     // metadata is loading. Never let the older completion overwrite it.
+    // A selection whose session was replaced while this loaded owns nothing.
     if (expectedRoute && rt.route !== expectedRoute) return null;
+    if (lease && !lease.valid()) return null;
     const { effectiveEffort, fastCapable } = resolveRouteEffortState(targetRoute, modelMeta);
     const contextState = resolveRouteContextState(targetRoute, modelMeta);
     const contextValue = clean(targetRoute.modelParameters?.context);

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

@@ -18,6 +18,7 @@ function bootParams({
   model,
   effort,
   fast,
+  autoEffort,
   modelParameters,
   contextPercent,
   contextTokens,
@@ -33,12 +34,14 @@ function bootParams({
   sessionProfile = null,
   worktree = null,
   executeAgentControl = null,
+  executeSessionControl = null,
 } = {}) {
   return {
     provider,
     model,
     effort,
     fast,
+    autoEffort,
     modelParameters,
     contextPercent,
     contextTokens,
@@ -55,6 +58,7 @@ function bootParams({
     // Creation-time worktree intent (workspace/transitions.mjs creationIntent).
     worktree,
     executeAgentControl,
+    executeSessionControl,
   };
 }
 

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

@@ -31,6 +31,7 @@ export function createRuntimeFacade({
   const currentSessionId = () => state.session?.id || state.reservedSessionId || state.addressedSessionId || null;
   return {
     ...leadingApi,
+    isSessionTerminal: () => state.admission === 'terminal',
     /** Bind the durable address to the conversation this runtime just
      *  loaded (resume / load-on-demand). Idempotent for the same id. */
     bindSessionAddress(sessionId) {
@@ -135,6 +136,11 @@ export function createRuntimeFacade({
     get session() {
       return state.session;
     },
+    /** Advances whenever another conversation (or none) is installed; a route
+     *  selection captures it when enqueued (see model-route/route-ownership). */
+    get sessionGeneration() {
+      return state.sessionGeneration;
+    },
     contextStatus(options) {
       return getContextStatus(options);
     },

package/src/session-runtime/runtime-review-api.mjs

@@ -3,8 +3,10 @@ import { turnReviewReply } from '../runtime/shared/turn-review-reply.mjs';
 import {
   clearSessionChangeHistory,
   getSessionReviewDiff,
+  getSessionReviewFilePatch,
   getTurnChanges,
   getTurnReviewDiff,
+  getTurnReviewFilePatch,
   reapplyTurnChanges,
   revertTurnChanges,
   revertTurnReview,
@@ -24,8 +26,9 @@ registerSessionPurgeHook((sessionId) => {
 });
 
 // Tool writes (apply_patch, mutating shell commands, git, watcher events)
-// reach the live review snapshot as its change signal: a review poll right
-// after them captures the worktree, an unsignaled poll may reuse the last one.
+// reach the turn's worktree snapshot as its change signal: a session review
+// read right after them captures the worktree, an unsignaled one may reuse
+// the last capture.
 registerCacheInvalidationListener((paths) => noteTurnWorktreeChange(paths));
 
 export function createRuntimeReviewApi({ getCwd, getSessionId }) {
@@ -35,6 +38,9 @@ export function createRuntimeReviewApi({ getCwd, getSessionId }) {
     getTurnReviewDiff: (options = {}) =>
       turnReviewReply((reviewOptions) => getTurnReviewDiff(getCwd(), getSessionId(), reviewOptions), options),
     getSessionReviewDiff: () => getSessionReviewDiff(getCwd(), getSessionId()),
+    // One listed file's whole patch (a reply lists a large one `patchOmitted`).
+    getSessionReviewFilePatch: (file, oldPath) => getSessionReviewFilePatch(getCwd(), getSessionId(), file, oldPath),
+    getTurnReviewFilePatch: (file) => getTurnReviewFilePatch(getCwd(), getSessionId(), file),
     revertTurnReview: (checkpointId) => revertTurnReview(getCwd(), getSessionId(), checkpointId),
     revertTurnReviewFile: (file, checkpointId) => revertTurnReviewFile(getCwd(), getSessionId(), file, checkpointId),
     // Historical per-turn changes, addressed by checkpointId (TurnChangesReply).

package/src/session-runtime/services/agent-task-status.mjs

@@ -111,6 +111,7 @@ function cleanStage(value) {
 }
 
 function describeLastProgress({ stage, snapshot, runtime, silentFor, lastToolCall, now }) {
+  if (snapshot?.awaitingModelResponse) return 'model thinking (request sent; awaiting response headers)';
   if (snapshot?.waitingForTransport) return 'awaiting model transport';
   if (snapshot?.waitingForFirstSemantic) {
     return 'transport active; awaiting first model event';
@@ -169,6 +170,7 @@ function describeAgentDiagnostic({ taskStatus, sessionStatus, stage, snapshot, s
     if (abortErr) return `stale: ${abortErr.message.replace(/^agent /i, '')}`;
   }
 
+  if (snapshot?.awaitingModelResponse) return 'model thinking; request sent, response headers pending';
   if (snapshot?.waitingForTransport) return 'waiting for model transport';
   if (snapshot?.waitingForFirstSemantic) {
     return 'transport healthy; waiting for first semantic model event';

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

@@ -10,9 +10,6 @@ export function createCloseAll({ registry, close }) {
   const { tags, tagAgents, tagCwds } = registry;
 
   function resetLocalTagState() {
-    for (const timer of registry.reapTimers.values()) clearTimeout(timer);
-    registry.reapTimers.clear();
-    registry.clearScheduledReaps();
     tags.clear();
     tagAgents.clear();
     tagCwds.clear();

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

@@ -58,21 +58,20 @@ export function createCloseFlow({ mgr, registry, views }) {
     if (isLeadPoolAgent(registry.getLiveSession(sessionId)?.agent)) {
       throw new Error(`agent close: target "${target}" is a Lead session`);
     }
-    registry.cancelReap(sessionId);
     const descendantSessionIds =
       typeof mgr.descendantSessionIds === 'function' ? mgr.descendantSessionIds(sessionId) : [];
     const tag = registry.tagForSession(sessionId);
     clearAgentStatuslineRoute(sessionId);
     cancelSessionTasks(sessionId, target, scopedContext);
-    // Close (and stamp cancelStatus) BEFORE dropping the worker row. Removing
-    // the row first left the next pool read with only a leftover heartbeat,
-    // which republished the session as `running`. The explicit task_id cancel
+    // Close (and stamp cancelStatus) BEFORE dropping the worker row, so the
+    // row never outlives an unrecorded cancel. The explicit task_id cancel
     // below is an idempotent no-op fallback once terminal.
-    const ok = await mgr.closeSession(sessionId, 'cli-agent-close');
+    // Closing a runtime cancels its work; only explicit session deletion
+    // may tombstone the conversation.
+    const ok = await mgr.closeSession(sessionId, 'cli-agent-close', { tombstone: false });
     if (task?.taskId) cancelBackgroundTask(task.taskId, CLOSE_REASON);
     // Drop the row only once the cancellation is DURABLY recorded: a failed
-    // close that still forgot the row left a fresh heartbeat with no cancelled
-    // state — the exact lingering row this path exists to prevent.
+    // close that still forgot the row would leave no cancelled state behind.
     if (ok) {
       registry.forgetTerminalSession(tag, sessionId);
       for (const descendantSessionId of descendantSessionIds) {

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

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

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

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

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

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

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

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

package/src/session-runtime/services/agent-tool/index-write-queue.mjs

@@ -20,6 +20,7 @@ import { registerJsonProjection } from '../../../runtime/shared/pending-json-pro
 import { sleep } from '../../../runtime/shared/sleep.mjs';
 
 const RETRY_DELAYS_MS = [50, 250, 1000];
+const RETRY_AFTER_FAILURE_MS = 15_000;
 const unsettled = new Set(); // queues holding unpersisted writes
 // Exit is the one place a bounded synchronous lock wait is acceptable: the
 // loop is gone, and a dropped settlement would leave rows "running" forever.
@@ -122,8 +123,15 @@ function replayBatch(batch, args, mergeSet) {
   replayRun();
 }
 
+// A write that cannot reach disk loses a state change other processes rely on
+// (e.g. a deleted Lead row that never leaves the pool), so every failure is
+// reported. In the daemon stderr IS daemon.log (daemon-log.mjs installRedirect).
 function reportFailure(file, what, error) {
-  process.stderr.write(`[index-write] ${file}: ${what}: ${error?.message || error}\n`);
+  try {
+    process.stderr.write(`[index-write] ${file}: ${what}: ${error?.message || error}\n`);
+  } catch {
+    /* logging is best effort */
+  }
 }
 
 /**
@@ -151,9 +159,15 @@ export function createIndexWriteQueue({
   let pending = []; // op sets not yet handed to a job
   let inflight = []; // op sets of the running job
   let running = null;
+  const failures = new WeakMap(); // settled job → the error that failed it
   let timer = null;
+  let retryTimer = null;
 
   function clearTimer() {
+    if (retryTimer) {
+      clearTimeout(retryTimer);
+      retryTimer = null;
+    }
     if (!timer) return;
     clearImmediate(timer);
     timer = null;
@@ -173,8 +187,8 @@ export function createIndexWriteQueue({
         return;
       } catch (error) {
         if (attempt >= RETRY_DELAYS_MS.length) {
-          reportFailure(file, `dropped ${batch.length} unpersisted write(s)`, error);
-          return;
+          reportFailure(file, `${batch.length} unpersisted write(s) kept queued after retries`, error);
+          throw error;
         }
         await sleep(RETRY_DELAYS_MS[attempt]);
       }
@@ -187,23 +201,45 @@ export function createIndexWriteQueue({
     inflight = pending;
     pending = [];
     const batch = inflight;
-    running = persist(batch).then(() => {
-      inflight = [];
-      running = null;
-      onPersisted();
-      if (pending.length === 0) {
-        projection = null;
-        unsettled.delete(self);
+    const job = persist(batch).then(
+      () => {
+        inflight = [];
+        running = null;
+        onPersisted();
+        if (pending.length === 0) {
+          projection = null;
+          unsettled.delete(self);
+        }
+        schedule();
+      },
+      (error) => {
+        // Persistent failure: nothing reached disk. Requeue the batch ahead of
+        // newer writes (the projection and `unsettled` keep covering it) so a
+        // later flush, write or exit flush retries. Do not reschedule at once,
+        // a held foreign lock would otherwise be hammered; a slow unref'd retry
+        // keeps a failed LAST write (a delete) from waiting for unrelated traffic.
+        failures.set(job, error);
+        pending = [...batch, ...pending];
+        inflight = [];
+        running = null;
+        retryTimer = setTimeout(() => {
+          retryTimer = null;
+          schedule();
+        }, RETRY_AFTER_FAILURE_MS);
+        retryTimer.unref?.();
       }
-      schedule();
-    });
+    );
+    running = job;
   }
 
-  /** Resolves once everything written so far is on disk (or dropped). */
+  /** Resolves once everything written so far is on disk; rejects when a persist
+   *  failed for good (the writes stay queued for a later flush). */
   async function flush() {
     for (;;) {
       if (running) {
-        await running;
+        const job = running;
+        await job;
+        if (failures.has(job)) throw failures.get(job);
         continue;
       }
       if (pending.length === 0) return;
@@ -212,10 +248,16 @@ export function createIndexWriteQueue({
     }
   }
 
-  /** Exit path: persist inflight + pending ops synchronously (bounded lock wait). */
+  /** Persist pending ops synchronously (bounded lock wait). While an async job
+   *  runs it owns the lock (and its ops are in flight): never wait on it, take
+   *  over its lock, or replay its ops — report false and let that job and its
+   *  follow-ups drain. At the last-resort process 'exit' hook that is
+   *  best-effort: the graceful shutdown path drains before exit. */
   function flushSync() {
-    const ops = [...inflight, ...pending];
-    if (!file || ops.length === 0) return true;
+    if (!file) return true;
+    if (running) return false;
+    const ops = pending;
+    if (ops.length === 0) return true;
     clearTimer();
     pending = [];
     try {
@@ -225,10 +267,10 @@ export function createIndexWriteQueue({
       });
     } catch (error) {
       reportFailure(file, `synchronous flush of ${ops.length} write(s) failed; kept queued`, error);
-      pending = ops;
+      pending = [...ops, ...pending];
+      schedule();
       return false;
     }
-    inflight = [];
     projection = null;
     unsettled.delete(self);
     onPersisted();
@@ -251,9 +293,11 @@ export function createIndexWriteQueue({
         version += 1;
         pending.push(rerun ? mutator : ops);
         unsettled.add(self);
+        installProcessExitFlush();
         schedule();
         return next;
-      } catch {
+      } catch (error) {
+        reportFailure(file, 'write rejected (mutator or document rewrite threw); nothing queued', error);
         return null;
       }
     },
@@ -266,6 +310,23 @@ export function createIndexWriteQueue({
   };
 }
 
+let processExitFlushInstalled = false;
+
+/** The process owns last-resort exit flushing of every queue holding unpersisted
+ *  writes, so a disposed (e.g. evicted) runtime needs no exit callback of its
+ *  own. Best effort: a persist still running is left to the graceful drain. */
+function installProcessExitFlush() {
+  if (processExitFlushInstalled) return;
+  processExitFlushInstalled = true;
+  process.on('exit', () => {
+    try {
+      flushAllIndexWritesSync();
+    } catch {
+      /* exit flush is best effort */
+    }
+  });
+}
+
 /** Synchronous variant (exit paths, tests that read the file directly). */
 export function flushAllIndexWritesSync() {
   for (const queue of [...unsettled]) queue.flushSync();

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

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

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

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

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

@@ -0,0 +1,29 @@
+// Ids of deleted Leads, shared by every lead-index instance of the process that
+// uses one data dir. The delete runs in the control runtime while the deleted
+// session's own (still loaded) runtime keeps settling turns through ITS index
+// instance; a per-instance set never sees the delete, so that late idle upsert
+// wrote the row back. The store's write fence (explicit deletes) is consulted
+// as well, so a fenced id can never be added whichever instance asks.
+import { resolve } from 'node:path';
+import { isSessionWriteFenced } from '../../../../runtime/agent/orchestrator/session/store/live-state.mjs';
+
+const FORGOTTEN_LEADS_MAX = 1024;
+const registries = new Map(); // resolved data dir -> Set<sessionId>
+
+export function createForgottenLeads(dataDir) {
+  const key = dataDir ? resolve(dataDir) : '';
+  let ids = registries.get(key);
+  if (!ids) {
+    ids = new Set();
+    registries.set(key, ids);
+  }
+  return {
+    /** A deleted Lead must never be written to the index again. */
+    forget(sessionId) {
+      ids.delete(sessionId);
+      ids.add(sessionId);
+      if (ids.size > FORGOTTEN_LEADS_MAX) ids.delete(ids.values().next().value);
+    },
+    isForgotten: (sessionId) => ids.has(sessionId) || isSessionWriteFenced(sessionId),
+  };
+}

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

@@ -42,7 +42,7 @@ export function createLeadIndexFile({ dataDir }) {
     return parsed ? normalizeLeadRows(parsed) : [];
   }
 
-  const write = (mutator) => queue.write(mutator);
+  const write = (mutator, options) => queue.write(mutator, options);
 
   return { path, read, write, flush: queue.flush, flushSync: queue.flushSync };
 }

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

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