mixdog 1.2.1 → 1.2.3

package/src/session-runtime/quick-web-search-models.mjs

@@ -1,41 +1,16 @@
-// Static quick-pick model ids surfaced during onboarding / web-search setup.
-// Limits are intentionally not hardcoded here: rows are hydrated from live
-// provider caches and provider-scoped metadata during catalog construction.
+// Offline quick-pick model rows for onboarding / web-search setup. No model id
+// is listed here: when a provider has no live roster yet, its newest rows come
+// from the provider-scoped public catalog, so a new release appears without a
+// code change. Rows are hydrated further during catalog construction.
+import { getModelsDevProviderModelsSync } from '../runtime/shared/llm/model-catalog.mjs';
 
 export const ONBOARDING_VERSION = 1;
 
-export const QUICK_WEB_SEARCH_MODELS = Object.freeze({
-  'openai-oauth': [
-    { id: 'gpt-6-sol', display: 'GPT-6 Sol', latest: true },
-    { id: 'gpt-6-luna', display: 'GPT-6 Luna', latest: true },
-    { id: 'gpt-5.6-sol', display: 'GPT-5.6 Sol' },
-    { id: 'gpt-5.6-terra', display: 'GPT-5.6 Terra' },
-    { id: 'gpt-5.6-luna', display: 'GPT-5.6 Luna' },
-  ],
-  openai: [
-    { id: 'gpt-5.5', display: 'GPT-5.5', latest: true },
-    { id: 'gpt-5.4', display: 'GPT-5.4', latest: true },
-    { id: 'gpt-5', display: 'GPT-5' },
-    { id: 'gpt-4.1', display: 'GPT-4.1' },
-    { id: 'gpt-4o', display: 'GPT-4o' },
-  ],
-  'grok-oauth': [{ id: 'grok-4.5', display: 'Grok 4.5', latest: true }],
-  xai: [{ id: 'grok-4.5', display: 'Grok 4.5', latest: true }],
-  gemini: [
-    { id: 'gemini-3.6-flash', display: 'Gemini 3.6 Flash', latest: true },
-    { id: 'gemini-3.5-flash-lite', display: 'Gemini 3.5 Flash Lite', latest: true },
-    { id: 'gemini-3.1-pro-preview', display: 'Gemini 3.1 Pro Preview' },
-  ],
-  'anthropic-oauth': [
-    { id: 'claude-opus-5-5', display: 'Claude Opus 5.5', latest: true },
-    { id: 'claude-sonnet-5', display: 'Claude Sonnet 5', latest: true },
-    { id: 'claude-fable-5', display: 'Claude Fable 5', latest: true },
-    { id: 'claude-haiku-4-5-20251001', display: 'Claude Haiku 4.5' },
-  ],
-  anthropic: [
-    { id: 'claude-opus-5-5', display: 'Claude Opus 5.5', latest: true },
-    { id: 'claude-sonnet-5', display: 'Claude Sonnet 5', latest: true },
-    { id: 'claude-fable-5', display: 'Claude Fable 5', latest: true },
-    { id: 'claude-haiku-4-5-20251001', display: 'Claude Haiku 4.5' },
-  ],
-});
+const QUICK_ROWS_PER_PROVIDER = 5;
+
+export function quickWebSearchModels(provider, models = getModelsDevProviderModelsSync(provider)) {
+  return Object.entries(models || {})
+    .map(([id, row]) => ({ id, display: row?.name || id, releaseDate: row?.release_date || null }))
+    .sort((a, b) => (Date.parse(b.releaseDate) || 0) - (Date.parse(a.releaseDate) || 0))
+    .slice(0, QUICK_ROWS_PER_PROVIDER);
+}

package/src/session-runtime/resource-extension-sync.mjs

@@ -5,6 +5,7 @@ import { publishGlobalExtensionChange, subscribeGlobalExtensionChanges } from '.
 
 export function createExtensionSync({
   connectConfiguredMcp,
+  cancelMcpLogin,
   invalidatePreSessionToolSurface,
   refreshEmptySessionToolPolicy,
   reloadFullConfig,
@@ -60,6 +61,9 @@ export function createExtensionSync({
     const chain = mcpToggleChains.get(serverName) || { desired: enabled, running: null };
     chain.desired = enabled;
     mcpToggleChains.set(serverName, chain);
+    // A disable riding the chain would otherwise wait out an explicit sign-in
+    // (beginMcpOAuthLogin) of this server still in flight.
+    if (enabled === false) cancelMcpLogin?.(serverName);
     if (!chain.running) {
       chain.running = (async () => {
         let status;

package/src/session-runtime/resource-mcp-api.mjs

@@ -7,8 +7,20 @@ import {
   mergeMcpServerConfig,
   MCP_TIMEOUT_FIELD_GROUPS,
 } from '../runtime/agent/orchestrator/runtime-core/plugin-mcp.mjs';
+import { resolveMcpOAuthUrl } from '../runtime/agent/orchestrator/mcp/client-config.mjs';
 import { withAdoptedCopies, withPinnedCollisionNames, withPluginServerIntent } from './mcp-glue/plugin-servers.mjs';
 import { findRegisteredPlugin } from './resource-plugins-api.mjs';
+import { createMcpOAuthLogins } from './mcp-oauth-login.mjs';
+
+/** The URL a server's OAuth credentials are stored under, or null. */
+function oauthUrlOf(cfg) {
+  try {
+    return resolveMcpOAuthUrl(cfg);
+  } catch {
+    // No valid remote URL: such a server never logged in.
+    return null;
+  }
+}
 
 /** The `mcpServers` map of a config as a fresh object (never the live one). */
 function mcpServersOf(config) {
@@ -59,14 +71,45 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
     mcpStatus,
     getMcpServerConfig,
     connectConfiguredMcp,
+    clearMcpServerOAuth,
     reloadFullConfig,
     awaitKeychainPrewarm,
     pluginsStatus,
-    resolveMcpCatalog = () => ({ adoption: null, plugins: {}, entries: {} }),
+    resolveMcpCatalog = () => ({ servers: {}, adoption: null, plugins: {}, entries: {} }),
+    resolveConfiguredMcpCatalog = resolveMcpCatalog,
     pluginMcpServer = () => null,
     flushSkillsSave,
+    cancelMcpLogin = () => {},
+    completeMcpLogin,
+    getMcpServerOAuthState = () => null,
+    probeMcpServerAuth,
   } = deps;
 
+  // Explicit OAuth sign-in: the one interactive MCP connect. On success the
+  // other runtimes reconnect the server non-interactively with the new tokens.
+  const oauthLogins = createMcpOAuthLogins({
+    async connect(name, openBrowser) {
+      const status = await connectConfiguredMcp({ only: name, enabled: true, login: { openBrowser } });
+      const row = status?.servers?.find((server) => server.name === name);
+      return { connected: row?.connected === true, error: row?.error || null };
+    },
+    cancel: (name) => cancelMcpLogin(name),
+    completeCallback: completeMcpLogin,
+    onComplete: (name) => sync.announce('mcp', { detail: { mcpChanges: [{ name, enabled: true }] } }),
+  });
+  /** The effective config of a server that signs in with MCP OAuth (HTTP/SSE
+   *  without configured authentication). */
+  const oauthServerConfig = async (name) => {
+    const serverName = clean(name);
+    if (!serverName) throw new Error('MCP server name is required');
+    await awaitKeychainPrewarm();
+    reloadFullConfig();
+    const cfg = resolveMcpCatalog().servers[serverName];
+    if (!cfg) throw new Error(`MCP server not configured: ${serverName}`);
+    if (!getMcpServerOAuthState(cfg)) throw new Error(`MCP server "${serverName}" does not use OAuth sign-in`);
+    return { serverName, cfg };
+  };
+
   /** The config with any adoptable plugin server copies already adopted, so
    *  every write also persists the adoption and never re-adds a copy. */
   const adoptedConfig = () => withAdoptedCopies(getConfig(), resolveMcpCatalog().adoption);
@@ -115,6 +158,49 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
       const { enabled } = getMcpServerConfig(serverName);
       return sync.reconnectMcpAndAnnounce({ only: serverName, enabled });
     },
+    /** `{ flowId, state: 'pending', url }` once the browser login starts
+     *  (`options.openBrowser === false` leaves opening `url` to the caller), or
+     *  `{ flowId, state: 'complete' }` when stored credentials sufficed. */
+    async beginMcpOAuthLogin(name, options = {}) {
+      const { serverName, cfg } = await oauthServerConfig(name);
+      if (cfg.enabled === false) throw new Error(`MCP server is disabled: ${serverName}`);
+      return oauthLogins.begin(serverName, options);
+    },
+    /** `{ flowId, state: 'pending' | 'complete' | 'failed' | 'cancelled', error? }` */
+    getMcpOAuthLoginStatus(flowId) {
+      return oauthLogins.status(flowId);
+    },
+    cancelMcpOAuthLogin(flowId) {
+      return oauthLogins.cancel(flowId);
+    },
+    /** Remote / headless sign-in: complete the pending flow with the redirect
+     *  URL pasted from the browser. `{ flowId, state: 'complete' | 'failed',
+     *  error? }`; an invalid paste throws a fixed message and stays pending. */
+    completeMcpOAuthLogin(flowId, callbackUrl) {
+      return oauthLogins.complete(flowId, callbackUrl);
+    },
+    /** Forget the server's stored OAuth credentials (shared by every server
+     *  with the same exact URL) and reconnect without a login, here and on
+     *  peers, so it reports sign-in required. */
+    async signOutMcpServer(name) {
+      const { serverName, cfg } = await oauthServerConfig(name);
+      // A begin issued meanwhile waits until the credentials are gone.
+      return oauthLogins.cancelServer(serverName, async () => {
+        await clearMcpServerOAuth(cfg);
+        return sync.reconnectMcpAndAnnounce({ only: serverName, enabled: cfg.enabled !== false });
+      });
+    },
+    /** `{ auth: 'oauth' | 'none' | 'configured' | 'unreachable', error? }` for an
+     *  HTTP/SSE config, without credentials or a browser. */
+    probeMcpServerAuth(cfg) {
+      if (!cfg || typeof cfg !== 'object' || Array.isArray(cfg)) throw new TypeError('MCP server config is required');
+      const probe = {};
+      for (const key of ['type', 'url', 'headers', 'bearer_token_env_var', 'env_http_headers']) {
+        if (cfg[key] !== undefined) probe[key] = cfg[key];
+      }
+      if (probe.type !== 'http' && probe.type !== 'sse') throw new TypeError("type must be 'http' or 'sse'");
+      return probeMcpServerAuth(probe);
+    },
     async addMcpServer(input = {}) {
       const { name, config: serverConfig } = normalizeMcpServerInput(input);
       const servers = userServers();
@@ -162,9 +248,19 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
         refusePluginServer(serverName);
         throw new Error(`MCP server not configured: ${serverName}`);
       }
+      const removed = servers[serverName];
       delete servers[serverName];
       saveServers(servers);
-      return sync.reconnectMcpAndAnnounce({ drop: [serverName] });
+      const status = await sync.reconnectMcpAndAnnounce({ drop: [serverName] });
+      // A removed server keeps no OAuth tokens or client registration, unless
+      // another configured server (plugin or disabled ones included, even
+      // with MCP disabled for this runtime) still uses them through the same
+      // exact URL.
+      const url = oauthUrlOf(removed);
+      if (url && !Object.values(resolveConfiguredMcpCatalog().servers).some((cfg) => oauthUrlOf(cfg) === url)) {
+        await clearMcpServerOAuth(removed);
+      }
+      return status;
     },
     async setMcpServerEnabled(name, enabled) {
       const serverName = clean(name);

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/runtime-review-api.mjs

@@ -1,19 +1,34 @@
 import { registerCacheInvalidationListener } from '../runtime/agent/orchestrator/tools/builtin/cache-layers.mjs';
 import { turnReviewReply } from '../runtime/shared/turn-review-reply.mjs';
 import {
+  clearSessionChangeHistory,
   getSessionReviewDiff,
+  getSessionReviewFilePatch,
   getTurnChanges,
   getTurnReviewDiff,
+  getTurnReviewFilePatch,
   reapplyTurnChanges,
   revertTurnChanges,
   revertTurnReview,
   revertTurnReviewFile,
 } from '../runtime/shared/turn-snapshot.mjs';
 import { noteTurnWorktreeChange } from '../runtime/shared/turn-worktree-snapshot.mjs';
+import { forgetSessionChangeHistoryMarker } from '../runtime/shared/turn-snapshot-store.mjs';
+import { forgetSessionBaselines } from '../runtime/shared/session-baseline-store.mjs';
+import { registerSessionPurgeHook } from '../runtime/agent/orchestrator/session/store.mjs';
+
+// A deleted history stays deleted for as long as its session exists; the
+// session's own deletion takes the marker — and its stored first-seen file
+// contents — with it.
+registerSessionPurgeHook((sessionId) => {
+  void forgetSessionChangeHistoryMarker(sessionId);
+  void forgetSessionBaselines(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 }) {
@@ -23,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).
@@ -31,5 +49,6 @@ export function createRuntimeReviewApi({ getCwd, getSessionId }) {
       revertTurnChanges(getSessionId(), checkpointId, file, revision),
     reapplyTurnChanges: (checkpointId, file, revision) =>
       reapplyTurnChanges(getSessionId(), checkpointId, file, revision),
+    clearSessionChangeHistory: () => clearSessionChangeHistory(getSessionId()),
   };
 }

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

@@ -19,7 +19,7 @@
 // Every call is idempotent (the first terminal state wins, so the outer reject
 // path cannot double-notify) and absorbs its own errors, so reporting on a
 // turn can never break the turn.
-import { reconcileBackgroundTask } from '../../../runtime/shared/background-tasks.mjs';
+import { reconcileBackgroundTask, settleCancelledBackgroundTask } from '../../../runtime/shared/background-tasks.mjs';
 
 function reconcileJobTerminalResult(job, value) {
   if (!job?.taskId) return;
@@ -50,6 +50,8 @@ export function terminalResultHook({ job, turnReview, completionValue, notifyEar
     turnReview.complete();
     const value = completionValue(terminalResult);
     job._terminalResultValue = value;
+    // A cancelled job reports once, as `cancelled`, when its turn settles.
+    if (job.status === 'cancelled') return;
     notifyEarly(job, value, notifyContext || {});
     reconcileJobTerminalResult(job, value);
   };
@@ -67,6 +69,16 @@ export function reconcileJobWatchdogPartial(job, value) {
   } catch {}
 }
 
+/** The cancelled turn stopped: deliver the owner's single `cancelled`
+ *  notification, carrying the output the turn produced before it stopped
+ *  (header-only when it produced none). */
+export function reconcileJobCancelled(job, value) {
+  if (!job?.taskId) return;
+  try {
+    settleCancelledBackgroundTask(job.taskId, value?.content ? { result: value } : {});
+  } catch {}
+}
+
 export function reconcileJobStreamStalled(job, error) {
   if (!job?.taskId || job._terminalResultValue !== undefined) return;
   try {

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

@@ -5,6 +5,8 @@ import { ACTIVE_STAGES } from '../tool-def.mjs';
 import { isTerminalWorkerStatus } from '../worker-rows.mjs';
 import { sessionUsageTotals } from '../../../../runtime/shared/session-usage-totals.mjs';
 
+const CANCELLED_WORKER_STATUS = /^(?:cancelled|canceled|killed|cancel[-_\s]?(?:unconfirmed|pending))$/;
+
 // 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 = {}) {
@@ -14,8 +16,11 @@ export function isActiveWorkerRow(row = {}) {
   const status = String(row.status ?? '')
     .trim()
     .toLowerCase();
-  if (ACTIVE_STAGES.has(stage) || ACTIVE_STAGES.has(status)) return true;
-  const effective = stage || status;
+  // `status` decides; the stage is the runtime phase and only stands in for a
+  // row with no status. A cancel in either field is not work.
+  if (CANCELLED_WORKER_STATUS.test(stage) || CANCELLED_WORKER_STATUS.test(status)) return false;
+  const effective = status || stage;
+  if (ACTIVE_STAGES.has(effective)) return true;
   if (!effective || effective === 'unknown') return false;
   return !isTerminalWorkerStatus(effective);
 }

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