mixdog 0.9.41 → 0.9.44

package/src/runtime/agent/orchestrator/tools/builtin/shell-jobs.mjs

@@ -985,10 +985,12 @@ function startBackgroundPowerShellJob({ command, timeoutMs, workDir, mergeStderr
         // the execution policy on Windows PowerShell; pwsh on macOS/Linux
         // accepts the parameter as a no-op, so it is safe unconditionally.
         "    $argList = @('-NoLogo', '-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File', $innerPath)",
-        // -WindowStyle is a Windows-only Start-Process parameter; pwsh on
-        // macOS/Linux throws "not supported on this platform". Add it only on win32.
+        // Do not set WindowStyle: Hidden creates a separate transient conhost.
+        // On Windows, explicitly reuse the wrapper's CREATE_NO_WINDOW console.
+        // NoNewWindow is unavailable on non-Windows pwsh, so only add it for
+        // Windows (where $IsWindows is absent/null in Windows PowerShell 5.1).
         '    $spArgs = @{ FilePath = $exe; ArgumentList = $argList; RedirectStandardOutput = $stdoutPath; RedirectStandardError = $stderrPath; PassThru = $true }',
-        '    if ($IsWindows -or $null -eq $IsWindows) { $spArgs[\'WindowStyle\'] = \'Hidden\' }',
+        '    if ($IsWindows -or $null -eq $IsWindows) { $spArgs[\'NoNewWindow\'] = $true }',
         '    $p = Start-Process @spArgs',
         '    if ($timeoutMs -gt 0 -and -not $p.WaitForExit($timeoutMs)) {',
         // Kill the whole process TREE, not just the direct child: Start-Process
@@ -1039,8 +1041,8 @@ function startBackgroundPowerShellJob({ command, timeoutMs, workDir, mergeStderr
     // No `-WindowStyle Hidden` CLI switch: windowsHide:true on the spawn below
     // already gives CREATE_NO_WINDOW, and the visible command-line token trips
     // Defender's hidden-PowerShell dropper signature (PowhidSubExec). The
-    // in-wrapper Start-Process WindowStyle=Hidden (above) stays — it lives in
-    // the staged .ps1, not on the command line, and is still needed there.
+    // in-wrapper Start-Process uses Windows-only NoNewWindow to reuse this
+    // hidden console rather than creating a transient conhost window.
     // `-ExecutionPolicy` only applies to Windows PowerShell; build per-platform.
     const isWin = process.platform === 'win32';
     const wrapperArgs = ['-NoLogo', '-NoProfile', '-NonInteractive'];

package/src/runtime/memory/data/runtime-manifest.json

@@ -1,6 +1,6 @@
 {
   "schema_version": 1,
-  "generated_at": "2026-06-30T06:23:20.385Z",
+  "generated_at": "2026-07-13T06:08:53.718Z",
   "release_tag": "runtime-v0.4.0",
   "pg": {
     "major": 16,
@@ -12,28 +12,28 @@
   "assets": {
     "darwin-arm64": {
       "url": "https://github.com/tribgames/mixdog/releases/download/runtime-v0.4.0/mixdog-runtime-darwin-arm64-pg16.4-pgvector0.8.2.tar.gz",
-      "sha256": "7a642006ef60ccf8c385ba89c761c2b6f4927f6f01a1c4fb152604e6b41fe3d2",
-      "size": 23397361
+      "sha256": "c11f4b3046f0eeecf88790d2fff88cee1834231f96c11ec315a7a97180ea1413",
+      "size": 23397436
     },
     "darwin-x64": {
       "url": "https://github.com/tribgames/mixdog/releases/download/runtime-v0.4.0/mixdog-runtime-darwin-x64-pg16.4-pgvector0.8.2.tar.gz",
-      "sha256": "8e39bfc3f06d88e9854946d5d83f7d77d9530f99284d7c1c51872c12f389f7e7",
-      "size": 23687666
+      "sha256": "ef93b837b1e3ea0b30591f2d31de10f9a628db88ad00183d271d539fe3cb0adb",
+      "size": 23687427
     },
     "linux-arm64": {
       "url": "https://github.com/tribgames/mixdog/releases/download/runtime-v0.4.0/mixdog-runtime-linux-arm64-pg16.4-pgvector0.8.2.tar.gz",
-      "sha256": "64ff170013b9543ad8843c98cbfe14019e6be6ea3d142ec189b2bea0dd1dc797",
-      "size": 22885036
+      "sha256": "288d566fd38dd80ce2dcfa68083a76b6a9400fbd8020453cf72197d3cc161315",
+      "size": 22884871
     },
     "linux-x64": {
       "url": "https://github.com/tribgames/mixdog/releases/download/runtime-v0.4.0/mixdog-runtime-linux-x64-pg16.4-pgvector0.8.2.tar.gz",
-      "sha256": "28ee64125a0125ff36c47560c08ce8f38e49aef034c010c7e4867e8cdd783385",
-      "size": 23276106
+      "sha256": "31b40d32d51afb85963e33557c3140e378b21c7cc54cec794049276a2160afd3",
+      "size": 23282291
     },
     "win32-x64": {
       "url": "https://github.com/tribgames/mixdog/releases/download/runtime-v0.4.0/mixdog-runtime-win32-x64-pg16.4-pgvector0.8.2.tar.gz",
-      "sha256": "6faed8a49b3303b0adb1c5715b2b19c5cc47df2e738d586d0d0bd432f1ca035d",
-      "size": 44036958
+      "sha256": "5d3d9d6e3ae4a93bb0bde615365bdda3ab5ff7206c0d1a066ed51b316932a8f8",
+      "size": 44037023
     }
   }
 }

package/src/runtime/memory/lib/runtime-fetcher.mjs

@@ -37,7 +37,6 @@ const BUNDLED_MANIFEST_PATH = fileURLToPath(new URL('../data/runtime-manifest.js
 
 // GitHub raw URL fallback — used only when no cached or bundled manifest exists.
 const MANIFEST_URL = 'https://raw.githubusercontent.com/tribgames/mixdog/main/src/runtime/memory/data/runtime-manifest.json'
-const LEGACY_RUNTIME_RELEASE_REPOSITORY = 'trib-plugin/mixdog'
 
 // ---------------------------------------------------------------------------
 // Platform key
@@ -183,7 +182,7 @@ function runtimeAssetUrlCandidates(url) {
     .split(/[\s,;]+/u)
     .map((repo) => repo.trim())
     .filter(Boolean)
-  for (const repo of [...overrides, LEGACY_RUNTIME_RELEASE_REPOSITORY]) {
+  for (const repo of overrides) {
     if (repo && repo !== releaseRepo) add(value.replace(`/github.com/${releaseRepo}/`, `/github.com/${repo}/`))
   }
   return out

package/src/runtime/memory/tool-defs.mjs

@@ -8,21 +8,22 @@ export const TOOL_DEFS = [
     name: 'memory',
     title: 'Memory Cycle',
     annotations: { title: 'Memory Cycle', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
-    description: 'Core-memory mutation and status. Use recall for retrieval. Persist with action:"core" op:"add" when: user corrects/confirms your approach, states a durable preference, or says "remember". Only what code/git/docs cannot derive; include the why. Never transient task state. No prior recall dedup needed — the cycle dedups.',
+    description: 'Core-memory mutation and status. Use recall for retrieval. Persist with action:"core" op:"add" when: user corrects/confirms your approach, states a durable preference, or says "remember". Core add/edit requires project_id + category + element + summary. Only what code/git/docs cannot derive; include the why. Never transient task state. No prior recall dedup needed — the cycle dedups.',
     inputSchema: {
       type: 'object',
       properties: {
         action: { type: 'string', enum: ['core','status'], description: 'Operation.' },
         op: { type: 'string', enum: ['add','edit','delete','list','candidates','promote','dismiss'], description: 'Mutation op. candidates/promote/dismiss drive core-memory proposal approval.' },
         id: { type: 'number', description: 'Exact memory id.' },
-        element: { type: 'string', description: 'Memory key/title. Max 40 chars.' },
-        summary: { type: 'string', description: 'Memory content: 1 fact, 1-2 sentences, max 100 chars.' },
+        element: { type: 'string', maxLength: 40, description: 'Memory key/title. Max 40 chars.' },
+        summary: { type: 'string', maxLength: 100, description: 'Memory content: 1 fact, 1-2 sentences, max 100 chars.' },
         category: { type: 'string', enum: ['rule','constraint','decision','fact','goal','preference','task','issue'], description: 'Category.' },
         status: { type: 'string', enum: ['pending','active','archived'], description: 'Lifecycle status.' },
         limit: { type: 'number', description: 'Max rows/items.' },
         confirm: { type: 'string', description: 'Exact confirmation phrase for destructive actions.' },
         project_id: { type: 'string', description: 'Core pool: common, slug, or *. Required for core add/edit; there is no default pool.' },
       },
+      additionalProperties: false,
       required: ['action'],
     },
   },

package/src/runtime/shared/tool-surface.mjs

@@ -514,8 +514,7 @@ export function toolWorkUnit(name, args = {}, category = '') {
     case 'memory': {
       const action = String(a.action || '').toLowerCase();
       const op = String(a.op || '').toLowerCase();
-      const isMutation = op === 'add' || op === 'edit' || op === 'delete' || op === 'promote' || op === 'dismiss'
-        || (action === 'core' && !op);
+      const isMutation = op === 'add' || op === 'edit' || op === 'delete' || op === 'promote' || op === 'dismiss';
       if (isMutation) return unitDescriptor('Memory', { count: queryCount(a, 'entries', 'items', 'memories', 'query', 'text', 'value') || 1, active: 'Writing', done: 'Wrote', noun: 'memory item' });
       return unitDescriptor('Memory', { count: queryCount(a, 'entries', 'items', 'memories', 'query', 'text', 'value') || 1, active: 'Checking', done: 'Checked', noun: 'memory item' });
     }

package/src/session-runtime/context-status.mjs

@@ -2,8 +2,10 @@ import {
   estimateRequestReserveTokens,
   estimateToolSchemaTokens,
   estimateTranscriptContextUsage,
+  contextMessagesRevision,
   resolveSessionCompactPolicy,
   summarizeContextMessages,
+  toolSchemaSignature,
 } from '../runtime/agent/orchestrator/session/context-utils.mjs';
 import { estimateToolSchemaBreakdown } from './tool-catalog.mjs';
 
@@ -16,7 +18,7 @@ export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMo
   let contextStatusCacheKey = null;
   let contextStatusCacheValue = null;
 
-  function contextStatusCacheKeyFor({ messages, tools }) {
+  function contextStatusCacheKeyFor({ messages, tools, messagesRevision, toolsSignature }) {
     const session = getSession();
     const route = getRoute();
     const compaction = session?.compaction || {};
@@ -30,11 +32,13 @@ export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMo
       mode: getMode(),
       messages,
       messageCount: messages.length,
+      messagesRevision,
       lastMessage,
       lastMessageRole: lastMessage?.role || null,
       lastMessageContent: lastMessage?.content || null,
       tools,
       toolCount: tools.length,
+      toolsSignature,
       contextWindow: session?.contextWindow || null,
       rawContextWindow: session?.rawContextWindow || null,
       effectiveContextWindowPercent: session?.effectiveContextWindowPercent || null,
@@ -85,7 +89,9 @@ export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMo
     const liveTurnMessages = Array.isArray(session?.liveTurnMessages) ? session.liveTurnMessages : null;
     const messages = liveTurnMessages || (Array.isArray(session?.messages) ? session.messages : []);
     const tools = Array.isArray(session?.tools) ? session.tools : [];
-    const cacheKey = contextStatusCacheKeyFor({ messages, tools });
+    const messagesRevision = contextMessagesRevision(messages);
+    const toolsSignature = toolSchemaSignature(tools);
+    const cacheKey = contextStatusCacheKeyFor({ messages, tools, messagesRevision, toolsSignature });
     if (contextStatusCacheValue && sameContextStatusCacheKey(cacheKey, contextStatusCacheKey)) {
       return contextStatusCacheValue;
     }

package/src/standalone/agent-tool/render.mjs

@@ -37,6 +37,8 @@ export function abnormalEmptyFinishError(result, agent) {
       // Only tagged for PUBLIC agents (hidden agents legitimately emit empty
       // terminal turns and are left untagged by the loop).
       return `agent '${agent}' finished without a final answer (stopReason=${stopReason ?? 'none'}, ${iterations} iterations, ${toolCallsTotal} tool calls)`;
+    case 'refusal':
+      return `agent '${agent}' response was refused by the safety classifier (${iterations} iterations, ${toolCallsTotal} tool calls)`;
     default:
       return null;
   }

package/src/standalone/agent-tool.mjs

@@ -90,6 +90,72 @@ const DEFAULT_SPAWN_PREP_TIMEOUT_MS = envTimeoutMs('MIXDOG_AGENT_SPAWN_PREP_TIME
 // startDeferredSpawnJob) so the agent tool call itself still returns task_id
 // immediately.
 const SPAWN_STAGGER_MS = envTimeoutMs('MIXDOG_SPAWN_STAGGER_MS', 0);
+const TAG_TOMBSTONE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+const MAX_TAG_TOMBSTONES = 500;
+
+/**
+ * Resolve the route for a public agent spawn. Explore and Maintainer inherit
+ * Main only after their explicit agent, workflow, and maintenance routes.
+ */
+export function resolveAgentSpawnPreset(config, args = {}) {
+  if (args.provider && args.model) {
+    return {
+      presetName: args.preset || '__direct__',
+      preset: {
+        id: '__direct__',
+        name: '__DIRECT__',
+        type: 'agent',
+        provider: clean(args.provider),
+        model: clean(args.model),
+        effort: clean(args.effort) || undefined,
+        fast: args.fast === true,
+        tools: 'full',
+      },
+    };
+  }
+
+  const agentName = normalizeAgentName(args.agent);
+  const configuredDefault = clean(config?.defaultProvider);
+  const fallbackProvider = configuredDefault && isKnownProvider(configuredDefault)
+    ? configuredDefault
+    : DEFAULT_PROVIDER;
+  const workflowSlot = agentName === 'explore' ? 'explorer'
+    : (agentName === 'maintainer' ? 'memory' : '');
+  const maintenanceSlot = agentName === 'explore' ? 'explore'
+    : (agentName === 'maintainer' ? 'memory' : '');
+  const agentRoute = !clean(args.preset)
+    ? (normalizeAgentRoute(config?.agents?.[agentName], fallbackProvider)
+      || (agentName === 'maintainer' ? normalizeAgentRoute(config?.agents?.maintenance, fallbackProvider) : null)
+      || normalizeAgentRoute(config?.workflowRoutes?.[workflowSlot], fallbackProvider)
+      || normalizeAgentRoute(config?.maintenance?.[maintenanceSlot], fallbackProvider))
+    : null;
+  if (agentRoute) {
+    return {
+      presetName: agentPresetName(agentName),
+      preset: {
+        id: `agent-${agentName}`,
+        name: agentPresetName(agentName),
+        type: 'agent',
+        provider: agentRoute.provider,
+        model: agentRoute.model,
+        effort: agentRoute.effort,
+        fast: agentRoute.fast === true,
+        tools: 'full',
+      },
+    };
+  }
+
+  const mainPreset = !clean(args.preset) && (agentName === 'explore' || agentName === 'maintainer')
+    ? findPreset(config, config?.default)
+    : null;
+  if (mainPreset) return { presetName: mainPreset.id || mainPreset.name, preset: mainPreset };
+
+  const presetName = clean(args.preset) || DEFAULT_AGENT_PRESETS[agentName];
+  if (!presetName) throw new Error(`agent: agent "${agentName}" has no model assignment`);
+  const preset = findPreset(config, presetName) || synthesizePreset(config, presetName);
+  if (!preset) throw new Error(`agent: preset "${presetName}" not found`);
+  return { presetName, preset };
+}
 let lastSpawnStartAt = 0;
 async function waitForSpawnStagger() {
   if (SPAWN_STAGGER_MS <= 0) return;
@@ -177,13 +243,48 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
       .filter(keepWorkerRow);
   }
 
+  function normalizeTagTombstones(value, { cap = true, priorityKeys = null } = {}) {
+    const source = Array.isArray(value?.tombstones)
+      ? value.tombstones
+      : (value?.tombstones && typeof value.tombstones === 'object'
+        ? Object.values(value.tombstones)
+        : []);
+    const now = Date.now();
+    const cutoff = now - TAG_TOMBSTONE_TTL_MS;
+    const rows = source
+      .filter((row) => row && typeof row === 'object')
+      .map((row) => {
+        const parsedReapedAt = Date.parse(clean(row.reapedAt)) || 0;
+        return {
+          tag: clean(row.tag),
+          agent: clean(row.agent) || null,
+          cwd: clean(row.cwd) || null,
+          clientHostPid: positiveInt(row.clientHostPid),
+          // A future clock must not outrank tombstones created by this process.
+          reapedAt: parsedReapedAt ? new Date(Math.min(parsedReapedAt, now)).toISOString() : null,
+        };
+      })
+      .filter((row) => row.tag && row.reapedAt && (Date.parse(row.reapedAt) || 0) >= cutoff)
+      .sort((a, b) => {
+        const aPriority = priorityKeys?.has(tagTombstoneKey(a)) ? 1 : 0;
+        const bPriority = priorityKeys?.has(tagTombstoneKey(b)) ? 1 : 0;
+        return bPriority - aPriority
+          || (Date.parse(b.reapedAt) || 0) - (Date.parse(a.reapedAt) || 0);
+      });
+    return cap ? rows.slice(0, MAX_TAG_TOMBSTONES) : rows;
+  }
+
+  function tagTombstoneKey(row = {}) {
+    return `${positiveInt(row.clientHostPid) || 0}\0${clean(row.tag)}`;
+  }
+
   // Mtime-keyed parse cache for the worker index. A single spawn calls
   // refreshTagsFromSessions()/resolveTag()/nextTag() which each re-read and
   // re-JSON.parse this file; across a parallel fanout that is O(spawns^2)
   // synchronous reads of the same bytes on the event loop. Cache the parsed,
   // normalized rows and reuse them while the file mtime+size is unchanged.
   // Writes bump _workerRowsCacheDirty so the very next read re-parses.
-  let _workerRowsCache = null; // { mtimeMs, size, rows }
+  let _workerRowsCache = null; // { mtimeMs, size, rows, tombstones }
   let _workerRowsCacheDirty = true;
   function invalidateWorkerRowsCache() {
     _workerRowsCacheDirty = true;
@@ -200,15 +301,26 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
       return _workerRowsCache.rows;
     }
     let rows = [];
+    let tombstones = [];
     try {
-      rows = normalizeWorkerRows(JSON.parse(readFileSync(file, 'utf8')));
+      const parsed = JSON.parse(readFileSync(file, 'utf8'));
+      rows = normalizeWorkerRows(parsed);
+      tombstones = normalizeTagTombstones(parsed);
     } catch {
       rows = [];
+      tombstones = [];
     }
-    _workerRowsCache = { mtimeMs: st.mtimeMs, size: st.size, rows };
+    _workerRowsCache = { mtimeMs: st.mtimeMs, size: st.size, rows, tombstones };
     _workerRowsCacheDirty = false;
     return rows;
   }
+  function readAllTagTombstones() {
+    readAllWorkerRows();
+    return _workerRowsCache?.tombstones || [];
+  }
+  function readTagTombstones(context = {}) {
+    return readAllTagTombstones().filter((row) => rowMatchesContext(row, context));
+  }
   function readWorkerRows(context = {}) {
     const rows = readAllWorkerRows();
     if (rows.length === 0) return rows;
@@ -229,13 +341,25 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
           const key = workerRowKey(row);
           if (key) byKey.set(key, row);
         }
-        mutator(byKey);
+        const tombstonesByKey = new Map();
+        for (const row of normalizeTagTombstones(cur, { cap: false })) {
+          tombstonesByKey.set(tagTombstoneKey(row), row);
+        }
+        const priorityTombstoneKeys = new Set();
+        mutator(byKey, tombstonesByKey, priorityTombstoneKeys);
         const workers = {};
         for (const row of [...byKey.values()].filter(keepWorkerRow)) {
           const key = workerRowKey(row);
           if (key) workers[key] = row;
         }
-        return { version: 1, updatedAt: new Date().toISOString(), workers };
+        const tombstones = {};
+        for (const row of normalizeTagTombstones(
+          { tombstones: [...tombstonesByKey.values()] },
+          { priorityKeys: priorityTombstoneKeys },
+        )) {
+          tombstones[tagTombstoneKey(row)] = row;
+        }
+        return { version: 2, updatedAt: new Date().toISOString(), workers, tombstones };
       }, { lock: true });
       // This process just rewrote the index; force the next read to re-parse
       // even if the new mtime/size happen to collide with the cached stat.
@@ -504,6 +628,7 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
   }
 
   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()]) {
@@ -555,6 +680,50 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
     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);
+    });
+  }
+
+  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;
@@ -571,9 +740,10 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
     if (reapMs == null) return;
     const handle = setTimeout(() => {
       reapTimers.delete(sessionId);
+      const session = getLiveSession(sessionId);
       try { mgr.hideSessionFromList?.(sessionId); } catch {}
       const tag = tagForSession(sessionId);
-      forgetTerminalSession(tag, sessionId);
+      tombstoneTerminalSession(tag, sessionId, session);
       clearAgentStatuslineRoute(sessionId);
       try { mgr.closeSession(sessionId, 'terminal-reap'); } catch {}
     }, reapMs);
@@ -581,6 +751,47 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
     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);
+    });
+    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;
@@ -594,55 +805,6 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
   // chain-gate defaults to the spawn-prep cap (see provider-init.mjs comments).
   const { ensureProvider } = createProviderInit(reg, DEFAULT_SPAWN_PREP_TIMEOUT_MS);
 
-  function resolvePreset(config, args) {
-    if (args.provider && args.model) {
-      return {
-        presetName: args.preset || '__direct__',
-        preset: {
-          id: '__direct__',
-          name: '__DIRECT__',
-          type: 'agent',
-          provider: clean(args.provider),
-          model: clean(args.model),
-          effort: clean(args.effort) || undefined,
-          fast: args.fast === true,
-          tools: 'full',
-        },
-      };
-    }
-
-    const agentName = normalizeAgentName(args.agent);
-    const configuredDefault = clean(config?.defaultProvider);
-    const fallbackProvider = configuredDefault && isKnownProvider(configuredDefault)
-      ? configuredDefault
-      : DEFAULT_PROVIDER;
-    const agentRoute = !clean(args.preset)
-      ? (normalizeAgentRoute(config?.agents?.[agentName], fallbackProvider)
-        || (agentName === 'maintainer' ? normalizeAgentRoute(config?.agents?.maintenance, fallbackProvider) : null))
-      : null;
-    if (agentRoute) {
-      return {
-        presetName: agentPresetName(agentName),
-        preset: {
-          id: `agent-${agentName}`,
-          name: agentPresetName(agentName),
-          type: 'agent',
-          provider: agentRoute.provider,
-          model: agentRoute.model,
-          effort: agentRoute.effort,
-          fast: agentRoute.fast === true,
-          tools: 'full',
-        },
-      };
-    }
-
-    const presetName = clean(args.preset) || DEFAULT_AGENT_PRESETS[agentName];
-    if (!presetName) throw new Error(`agent: agent "${agentName}" has no model assignment`);
-    const preset = findPreset(config, presetName) || synthesizePreset(config, presetName);
-    if (!preset) throw new Error(`agent: preset "${presetName}" not found`);
-    return { presetName, preset };
-  }
-
   function list({ scanSessions = false, context = {} } = {}) {
     refreshTagsFromSessions({ scanSessions, context });
     const now = Date.now();
@@ -1028,7 +1190,7 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
     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 } = resolvePreset(config, args);
+    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');
@@ -1522,7 +1684,10 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
     tagAgents.clear();
     tagCwds.clear();
     flushWorkerIndexMutations();
-    writeWorkerRows((byKey) => byKey.clear());
+    writeWorkerRows((byKey, tombstonesByKey) => {
+      byKey.clear();
+      tombstonesByKey.clear();
+    });
     return { closed, failed };
   }
 
@@ -1589,25 +1754,26 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
           if (!fallbackTag || fallbackTag.startsWith('sess_') || !isDeadTarget) throw err;
           const prompt = clean(args.message || args.prompt);
           if (!prompt) throw err;
-          // A retained row is proof that this terminal owned the tag. Once the
-          // reaper removes that row, an explicit agent plus usable cwd is enough
-          // to cold-spawn a replacement without retaining closed sessions.
+          // A retained row or reap tombstone proves that this terminal owned
+          // the tag. Unknown tags stay errors even when the caller supplies an
+          // agent/cwd: typo absorption requires persisted same-tag evidence.
+          // Absorption identity is always terminal-local, even when live
+          // resolution was explicitly requested across all terminals.
+          const ownershipContext = context;
           let inheritedRow = null;
           try {
-            inheritedRow = readWorkerRows(scopedContext).find((row) => clean(row.tag) === fallbackTag) || null;
+            inheritedRow = readWorkerRows(ownershipContext).find((row) => clean(row.tag) === fallbackTag) || null;
           } catch { inheritedRow = null; }
-          // Never use explicit cold-spawn identity to take over a tag retained
-          // by another terminal. In-memory maps can contain peer entries, so
-          // inspect the persisted index directly.
-          const peerRow = readAllWorkerRows().find((row) => (
-            clean(row.tag) === fallbackTag && !rowMatchesContext(row, scopedContext)
-          ));
+          const inheritedTombstone = tagTombstoneForTag(fallbackTag, ownershipContext);
           const explicitAgent = clean(args.agent);
-          const explicitCwd = clean(args.cwd) || clean(callerCwd);
-          if (peerRow || (!inheritedRow && (!explicitAgent || !explicitCwd))) throw err;
+          // A local proof wins even if another terminal also owns this tag.
+          // With no local proof, foreign rows/tombstones and unknown tags are
+          // both non-absorbable and retain the original not-found error.
+          if (!inheritedRow && !inheritedTombstone) throw err;
           const inheritedSessionId = clean(inheritedRow?.sessionId);
-          const inheritedAgent = explicitAgent || clean(inheritedRow?.agent) || 'worker';
-          const inheritedCwd = clean(args.cwd) || clean(inheritedRow?.cwd) || clean(callerCwd);
+          const inheritedAgent = explicitAgent || clean(inheritedRow?.agent) || clean(inheritedTombstone?.agent);
+          const inheritedCwd = clean(args.cwd) || clean(inheritedRow?.cwd) || clean(inheritedTombstone?.cwd) || clean(callerCwd);
+          if (!inheritedAgent || !inheritedCwd) throw err;
           // Drop this terminal's in-memory trace and remove ONLY the persisted
           // row matching inheritedRow.sessionId. Do NOT call forgetTag here: it
           // does a tag-wide removeWorkerRow({tag,sessionId}) (L556) whose OR
@@ -1618,6 +1784,7 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
             try { tags.delete(fallbackTag); tagAgents.delete(fallbackTag); tagCwds.delete(fallbackTag); } catch {}
           }
           if (inheritedSessionId) { try { removeWorkerRow({ sessionId: inheritedSessionId }); } catch {} }
+          if (inheritedTombstone) consumeTagTombstone(inheritedTombstone);
           const spawnArgs = {
             ...args,
             type: 'spawn',
@@ -1638,6 +1805,8 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
         //   3) lingering terminal trace -> reap trace and fresh spawn under same tag
         //   4) genuinely new tag -> fresh deferred spawn
         const explicitTag = clean(args.tag);
+        let respawned = false;
+        let spawnArgs = args;
         if (explicitTag) {
           // Resolve a LIVE same-tag session in this terminal (busy or idle).
           let liveSessionId = null;
@@ -1658,9 +1827,35 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
           }
           if (hasTerminalTrace(explicitTag, scopedContext)) {
             reapTerminalTraceForTag(explicitTag, scopedContext);
+            respawned = true;
+          } else {
+            // Tombstone inheritance never honors allTerminals/global scope.
+            const tombstone = tagTombstoneForTag(explicitTag, context);
+            if (tombstone) {
+              consumeTagTombstone(tombstone);
+              spawnArgs = {
+                ...args,
+                agent: clean(args.agent) || clean(tombstone.agent),
+                ...(clean(args.cwd) || !clean(tombstone.cwd) ? {} : { cwd: tombstone.cwd }),
+              };
+              respawned = true;
+            } else {
+              const foreignTombstone = readAllTagTombstones().find((row) => (
+                clean(row.tag) === explicitTag && !rowMatchesContext(row, context)
+              ));
+              if (foreignTombstone) {
+                throw new Error(`agent spawn: tag "${explicitTag}" belongs to another terminal`);
+              }
+            }
           }
         }
-        const job = startDeferredSpawnJob(args, callerCwd, context, notifyContext);
+        const job = startDeferredSpawnJob(
+          spawnArgs,
+          callerCwd,
+          context,
+          notifyContext,
+          respawned ? { respawned: true } : {},
+        );
         return renderResult(renderJob(job, false));
       }
       throw new Error(`agent: unknown type "${type}"`);