mixdog 0.9.47 → 0.9.49

package/src/runtime/agent/orchestrator/tools/shell-command.mjs

@@ -406,6 +406,9 @@ export class ExecResult {
     this.signal = opts.signal || null;
     this.timedOut = opts.timedOut === true;
     this.killed = opts.killed === true;
+    // Why mixdog initiated a tree kill. Keep this separate from `signal`,
+    // which is the process-reported termination signal (SIGTERM/SIGKILL).
+    this.killCause = opts.killCause || null;
     this.stdoutPath = opts.stdoutPath || null;
     this.stdoutFileSize = opts.stdoutFileSize || 0;
     this.stderrPath = opts.stderrPath || null;
@@ -463,7 +466,40 @@ async function _spawnShellWithRetry({ shell, argv, spawnOptions, shellArg, cwd }
     let attempt = 0;
     for (;;) {
       try {
-        return spawn(shell, argv, spawnOptions);
+        const child = spawn(shell, argv, spawnOptions);
+        // spawn() reports ENOENT/EACCES on nextTick. Keep a guard listener
+        // attached from the same synchronous frame as spawn(), and do not
+        // resolve this helper until the child emits `spawn`. The caller adopts
+        // the guard atomically (new listener first, guard removal second), so
+        // there is never an unhandled-error window across either await.
+        let bufferedError = null;
+        const guardError = (err) => { bufferedError = bufferedError || err; };
+        child.on('error', guardError);
+        try {
+          await new Promise((resolveSpawn, rejectSpawn) => {
+            const onSpawn = () => {
+              child.removeListener('error', onError);
+              resolveSpawn();
+            };
+            const onError = (err) => {
+              child.removeListener('spawn', onSpawn);
+              rejectSpawn(err);
+            };
+            child.once('spawn', onSpawn);
+            child.once('error', onError);
+          });
+        } catch (err) {
+          child.removeListener('error', guardError);
+          throw err;
+        }
+        return {
+          child,
+          adoptErrorHandler(handler) {
+            child.on('error', handler);
+            child.removeListener('error', guardError);
+            if (bufferedError) handler(bufferedError);
+          },
+        };
       } catch (err) {
         try {
           console.error('[shell-spawn-retry] ' + JSON.stringify({
@@ -507,6 +543,12 @@ export function execShellCommand({
     const taskOutput = new TaskOutput(taskId);
     let timedOut = false;
     let killed = false;
+    let killCause = null;
+    let failurePhase = null;
+    let failureReason = null;
+    let spawnError = null;
+    let pendingChildError = null;
+    let settle = null;
     let settled = false;
     let timer = null;
     let abortHandler = null;
@@ -535,7 +577,9 @@ export function execShellCommand({
     // outside the timeout branch. Function declaration so callers placed
     // above settle()'s const definition still resolve via hoisting; the
     // 5 s deadline always fires after settle is constructed.
-    function _treeKillForceSettle() {
+    function _treeKillForceSettle(cause) {
+      killed = true;
+      killCause = killCause || cause || 'runtime-guard';
       treeKill(child);
       const _killDeadline = setTimeout(() => {
         if (settled) return;
@@ -574,7 +618,7 @@ export function execShellCommand({
       const argv = Array.isArray(shellArgs) && shellArgs.length > 0
         ? [...shellArgs, _spawnCommand]
         : [shellArg, _spawnCommand];
-      child = await _spawnShellWithRetry({
+      const spawned = await _spawnShellWithRetry({
         shell,
         argv,
         shellArg,
@@ -598,6 +642,14 @@ export function execShellCommand({
         detached: process.platform !== 'win32',
         },
       });
+      child = spawned.child;
+      spawned.adoptErrorHandler((err) => {
+        spawnError = spawnError || err;
+        failurePhase = 'tool';
+        failureReason = 'spawn failed';
+        if (settle) settle(1, null);
+        else pendingChildError = pendingChildError || err;
+      });
       startChildGuardian({
         childPid: child.pid,
         childGroupPid: child.pid,
@@ -624,8 +676,7 @@ export function execShellCommand({
     // before spawn returned (synchronous reentry from a parent abort), so
     // the child doesn't run for the full timeoutMs window.
     if (abortSignal && abortSignal.aborted) {
-      killed = true;
-      _treeKillForceSettle();
+      _treeKillForceSettle('cancellation');
     }
 
     child.stdout.setEncoding('utf-8');
@@ -640,13 +691,12 @@ export function execShellCommand({
     // by a successful exit code on a truncated capture.
     const _abortOnCaptureError = () => {
       if (taskOutput.writeError && !killed && !settled && !autoBackgrounded) {
-        killed = true;
-        _treeKillForceSettle();
+        _treeKillForceSettle('output-capture-error');
       }
     };
 
     let sizeWatchdog = null;
-    const settle = async (exitCode, signal) => {
+    settle = async (exitCode, signal) => {
       if (settled || autoBackgrounded) return;
       settled = true;
       if (timer) {
@@ -678,6 +728,7 @@ export function execShellCommand({
       catch (err) { taskOutput.writeError = taskOutput.writeError || err; }
       try { stderr = await taskOutput.getStderr(); }
       catch (err) { taskOutput.writeError = taskOutput.writeError || err; }
+      if (spawnError && !stderr) stderr = String(spawnError.message || spawnError);
       // Inline-only path: nothing spilled. Nothing to clean up.
       // Spilled but tiny: drop the files — outputFilePath would duplicate
       // the inline body. Spilled and large: keep the files, caller renders
@@ -698,6 +749,7 @@ export function execShellCommand({
           signal,
           timedOut,
           killed,
+          killCause,
           stdoutPath: taskOutput.spilled ? taskOutput.stdoutPath : null,
           stdoutFileSize: taskOutput.stdoutFileSize,
           stderrPath: taskOutput.spilled ? taskOutput.stderrPath : null,
@@ -705,6 +757,8 @@ export function execShellCommand({
           taskId,
           partialOutput,
           outputCaptureError: taskOutput.writeError,
+          failurePhase,
+          failureReason,
         }),
       );
     };
@@ -715,7 +769,7 @@ export function execShellCommand({
     // after stdio is fully drained, so getStdout()/getStderr() see the
     // complete capture.
     child.once('close', (code, signal) => settle(code, signal));
-    child.once('error', () => settle(1, null));
+    if (pendingChildError) settle(1, null);
     // 'close' only fires after stdio drains; a forked grandchild that
     // inherited stdout/stderr fds can hold them open past direct-child
     // exit and stall settle() until timeoutMs. 'exit' fires on direct
@@ -801,8 +855,12 @@ export function execShellCommand({
       // is honored by the kill path too.)
       if (!job) {
         autoBackgrounded = false;
-        if (reason === 'timeout') timedOut = true; else killed = true;
-        _treeKillForceSettle();
+        if (reason === 'timeout') {
+          timedOut = true;
+          _treeKillForceSettle('timeout');
+        } else {
+          _treeKillForceSettle('background-adoption-failed');
+        }
         return;
       }
       // Wire the lifecycle: on close, write the exit-code file FIRST then
@@ -815,14 +873,6 @@ export function execShellCommand({
           try { writeFileSync(job.donePath, ''); } catch {}
         });
       }
-      // Adoption committed. If a cancel already fired (before or during the
-      // adoption window), bring the now-adopted child down via its jobId so the
-      // promotion can't outlive a user abort. Idempotent with the still-attached
-      // abort handler's treeKill.
-      if (abortSignal && abortSignal.aborted) {
-        try { killShellJob(job.jobId); } catch {}
-        try { treeKill(child); } catch {}
-      }
       // Snapshot the partial output captured so far for the immediate result.
       let stdout = '';
       let stderr = '';
@@ -831,6 +881,33 @@ export function execShellCommand({
       try { stderr = await taskOutput.getStderr(); }
       catch (err) { taskOutput.writeError = taskOutput.writeError || err; }
       const jobId = job ? job.jobId : null;
+      // Re-check after the awaited capture reads: cancellation can race after
+      // adoption commits. Never report that cancelled process as a successful
+      // still-running background task.
+      if (abortSignal && abortSignal.aborted) {
+        killed = true;
+        killCause = 'cancellation';
+        try { killShellJob(jobId); } catch {}
+        try { treeKill(child); } catch {}
+        resolve(new ExecResult({
+          stdout,
+          stderr,
+          exitCode: null,
+          signal: child.signalCode || null,
+          timedOut: false,
+          killed: true,
+          killCause,
+          stdoutPath,
+          stdoutFileSize: taskOutput.stdoutFileSize,
+          stderrPath: taskOutput.spilled ? taskOutput.stderrPath : null,
+          stderrFileSize: taskOutput.stderrFileSize,
+          taskId,
+          partialOutput: true,
+          outputCaptureError: taskOutput.writeError,
+          backgrounded: false,
+        }));
+        return;
+      }
       const secs = Math.max(0, Math.round((Date.now() - _startMs) / 1000));
       const _verb = reason === 'timeout'
         ? `moved to background at timeout after ${secs}s`
@@ -880,7 +957,7 @@ export function execShellCommand({
           return;
         }
         timedOut = true;
-        _treeKillForceSettle();
+        _treeKillForceSettle('timeout');
       }, timeoutMs);
       if (timer.unref) timer.unref();
     }
@@ -921,16 +998,14 @@ export function execShellCommand({
       if (settled || autoBackgrounded) return;
       _abortOnCaptureError();
       if (taskOutput.totalDiskBytes() > SHELL_OUTPUT_DISK_CAP) {
-        killed = true;
-        _treeKillForceSettle();
+        _treeKillForceSettle('output-limit');
       }
     }, SIZE_WATCHDOG_INTERVAL_MS);
     if (sizeWatchdog.unref) sizeWatchdog.unref();
 
     if (abortSignal) {
       abortHandler = () => {
-        killed = true;
-        _treeKillForceSettle();
+        _treeKillForceSettle('cancellation');
       };
       try {
         abortSignal.addEventListener('abort', abortHandler, { once: true });

package/src/runtime/memory/lib/memory-action-handlers.mjs

@@ -622,7 +622,7 @@ export function createMemoryActionHandlers({
                 // project=<pool> lets the UI thread project_id into the follow-up
                 // promote/dismiss call — matters under project_id:'*' listing where
                 // rows span pools. Uses the same COMMON/slug convention as op:'list'.
-                `id=${c.id} project=${c.project_id == null ? 'COMMON' : c.project_id} [${c.category}] score=${c.score == null ? '-' : c.score.toFixed(2)} ${c.element} — ${String(c.summary || '').slice(0, 200)} (${c.reason})`,
+                `id=${c.id} project=${c.project_id == null ? 'COMMON' : c.project_id} score=${c.score == null ? '-' : c.score.toFixed(2)} ${c.element} — ${String(c.summary || '').slice(0, 200)} (${c.reason})`,
               ).join('\n'),
             }
           }
@@ -634,11 +634,11 @@ export function createMemoryActionHandlers({
           if (op === 'promote') {
             const entry = await promoteCoreCandidate(coreDataDir, args.id, { ...args, scope })
             const mergeNote = entry.merged_with ? ` (merged into core id=${entry.merged_with}, sim=${entry.sim})` : ''
-            return { text: `core promoted candidate id=${args.id} → core id=${entry.id}${mergeNote}: [${entry.category}] ${entry.element}` }
+            return { text: `core promoted candidate id=${args.id} → core id=${entry.id}${mergeNote}: ${entry.element}` }
           }
           // dismiss
           const removed = await dismissCoreCandidate(coreDataDir, args.id, { scope })
-          return { text: `core candidate dismissed (id=${removed.id}): [${removed.category}] ${removed.element}` }
+          return { text: `core candidate dismissed (id=${removed.id}): ${removed.element}` }
         } catch (e) {
           return { text: `core ${op} failed: ${e.message}`, isError: true }
         }
@@ -656,10 +656,15 @@ export function createMemoryActionHandlers({
       })()
       try {
         if (op === 'add' || op === 'edit') {
-          const normalized = normalizeCoreInput(args, {
+          // Category is intentionally absent from the public memory schema.
+          // New direct entries use normalizeCoreInput's internal compatibility
+          // default; edits omit the field so editCore preserves the stored value.
+          const categoryFreeArgs = { ...args }
+          delete categoryFreeArgs.category
+          const normalized = normalizeCoreInput(categoryFreeArgs, {
             requireElement: true,
             requireSummary: true,
-            requireCategory: true,
+            requireCategory: false,
           })
           const errors = [...normalized.errors]
           if (op === 'add') {
@@ -680,7 +685,12 @@ export function createMemoryActionHandlers({
           if (errors.length) {
             return { text: `core ${op}: ${errors.join('; ')}`, isError: true }
           }
-          args = { ...args, element: normalized.element, summary: normalized.summary, category: normalized.category }
+          args = {
+            ...categoryFreeArgs,
+            element: normalized.element,
+            summary: normalized.summary,
+            ...(op === 'add' ? { category: normalized.category } : {}),
+          }
         }
         if (projectId === '*' && op !== 'list') {
           return { text: `core ${op}: project_id "*" only valid for op="list"`, isError: true }
@@ -689,7 +699,7 @@ export function createMemoryActionHandlers({
           if (projectId !== '*') {
             const entries = await listCore(coreDataDir, projectId)
             if (entries.length === 0) return { text: 'core: empty' }
-            return { text: entries.map(e => `id=${e.id} [${e.category}] ${e.element} — ${String(e.summary || '').slice(0, 200)}`).join('\n') }
+            return { text: entries.map(e => `id=${e.id} ${e.element} — ${String(e.summary || '').slice(0, 200)}`).join('\n') }
           }
           // Cross-pool listing — group by project_id, COMMON first
           const entries = await listCore(coreDataDir, '*')
@@ -704,22 +714,22 @@ export function createMemoryActionHandlers({
           for (const [key, rows] of groups) {
             lines.push(`${key === null ? 'COMMON' : key}:`)
             for (const e of rows) {
-              lines.push(`  id=${e.id} [${e.category}] ${e.element} — ${String(e.summary || '').slice(0, 200)}`)
+              lines.push(`  id=${e.id} ${e.element} — ${String(e.summary || '').slice(0, 200)}`)
             }
           }
           return { text: lines.join('\n') }
         }
         if (op === 'add') {
           const entry = await addCore(coreDataDir, args, projectId)
-          return { text: `core added (id=${entry.id}): [${entry.category}] ${entry.element} — ${entry.summary.slice(0, 200)}` }
+          return { text: `core added (id=${entry.id}): ${entry.element} — ${entry.summary.slice(0, 200)}` }
         }
         if (op === 'edit') {
           const entry = await editCoreImpl(coreDataDir, args.id, args)
-          return { text: `core edited (id=${entry.id}): [${entry.category}] ${entry.element} — ${entry.summary.slice(0, 200)}` }
+          return { text: `core edited (id=${entry.id}): ${entry.element} — ${entry.summary.slice(0, 200)}` }
         }
         if (op === 'delete') {
           const removed = await deleteCore(coreDataDir, args.id)
-          return { text: `core deleted (id=${removed.id}): [${removed.category}] ${removed.element}` }
+          return { text: `core deleted (id=${removed.id}): ${removed.element}` }
         }
       } catch (e) {
         return { text: `core ${op} failed: ${e.message}`, isError: true }

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

@@ -8,7 +8,7 @@ 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. Store durable rules/preferences/facts, one compact ENGLISH clause each — never transient task state. add requires project_id+category+summary; edit works by id alone.',
+    description: 'Core-memory mutation and status; use recall for retrieval. Store durable rules/preferences/facts, one compact ENGLISH clause each — never transient task state. add requires project_id+summary; edit works by id alone.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -17,7 +17,6 @@ export const TOOL_DEFS = [
         id: { type: 'number', description: 'Exact memory id.' },
         element: { type: 'string', maxLength: 40, description: 'Memory key/title. Defaults to the first 40 chars of summary. Max 40 chars.' },
         summary: { type: 'string', maxLength: 100, description: 'Memory content: one short English clause, 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.' },

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

@@ -1,13 +1,15 @@
 import {
   estimateRequestReserveTokens,
   estimateToolSchemaTokens,
-  estimateTranscriptContextUsage,
   contextMessagesRevision,
   resolveSessionCompactPolicy,
   summarizeContextMessages,
   toolSchemaSignature,
 } from '../runtime/agent/orchestrator/session/context-utils.mjs';
-import { resolveWorkerCompactPolicy } from '../runtime/agent/orchestrator/session/loop/compact-policy.mjs';
+import {
+  resolveCompactionPressureTokens,
+  resolveWorkerCompactPolicy,
+} from '../runtime/agent/orchestrator/session/loop/compact-policy.mjs';
 import { estimateToolSchemaBreakdown } from './tool-catalog.mjs';
 
 const DEFERRED_CATALOG_TOOL_PROVIDERS = new Set(['anthropic', 'anthropic-oauth']);
@@ -84,6 +86,15 @@ export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMo
       lastOutputTokens: Number(session?.lastOutputTokens || 0),
       lastCachedReadTokens: Number(session?.lastCachedReadTokens || 0),
       lastCacheWriteTokens: Number(session?.lastCacheWriteTokens || 0),
+      contextPressureBaselineTokens: Number(session?.contextPressureBaselineTokens || 0),
+      contextPressureBaselineOutputTokens: Number(session?.contextPressureBaselineOutputTokens || 0),
+      contextPressureBaselineMessageCount: Number(session?.contextPressureBaselineMessageCount ?? -1),
+      contextPressureBaselineUpdatedAt: Number(session?.contextPressureBaselineUpdatedAt || 0),
+      contextPressureBaselineBoundary: session?.contextPressureBaselineBoundary || null,
+      contextPressureBaselineProvider: session?.contextPressureBaselineProvider || null,
+      contextPressureBaselineModel: session?.contextPressureBaselineModel || null,
+      contextPressureBaselineToolSignature: session?.contextPressureBaselineToolSignature || null,
+      contextPressureBaselinePrefixSignature: session?.contextPressureBaselinePrefixSignature || null,
       totalInputTokens: Number(session?.totalInputTokens || 0),
       totalUncachedInputTokens: Number(session?.totalUncachedInputTokens || 0),
       totalOutputTokens: Number(session?.totalOutputTokens || 0),
@@ -148,10 +159,6 @@ export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMo
     const rawWindow = Number(session?.rawContextWindow || session?.contextWindow || 0);
     const effectiveWindow = Number(session?.contextWindow || rawWindow || 0);
     const lastContextTokens = Number(session?.lastContextTokens || 0);
-    const estimatedContextTokens = estimateTranscriptContextUsage(messages, requestTools, {
-      messageCount: messageSummary.count,
-      estimatedMessageTokens: messageSummary.estimatedTokens,
-    });
     const compactAt = Number(session?.compaction?.lastChangedAt || session?.compaction?.lastCompactAt || 0);
     const usageAt = Number(session?.lastContextTokensUpdatedAt || 0);
     const lastUsageStale = !!lastContextTokens && (
@@ -161,14 +168,6 @@ export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMo
     );
     const compactBoundaryTokens = Number(session?.compactBoundaryTokens || session?.compaction?.boundaryTokens || 0);
     const displayWindow = compactBoundaryTokens || effectiveWindow;
-    // The transcript estimate is the single source of truth for the displayed
-    // context footprint. Provider-reported input_tokens (lastContextTokens)
-    // swing non-monotonically and are not window-bounded on some providers
-    // (e.g. OpenAI gpt-5.5 Responses API), so they are kept only as secondary
-    // metadata (lastApiRequestTokens / usage.lastContextTokens) and never feed
-    // the gauge numerator.
-    const usedTokens = estimatedContextTokens;
-    const freeTokens = displayWindow ? Math.max(0, displayWindow - usedTokens) : 0;
     // Use the worker policy when a boundary is available so target/reserve
     // headroom, trigger, buffer tokens, and buffer ratio stay identical to the
     // auto-compact decision. Fall back only for incomplete session metadata.
@@ -176,6 +175,16 @@ export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMo
     const compactPolicy = workerCompactPolicy?.boundaryTokens
       ? workerCompactPolicy
       : resolveSessionCompactPolicy(session || {}, compactBoundaryTokens);
+    // Match the pre-provider-send auto-compact check exactly: the gauge uses
+    // the same provider-baseline-or-estimate pressure, including request and
+    // configured reserves, rather than a separate transcript-only estimate.
+    const compactionPressureTokens = resolveCompactionPressureTokens(
+      messageSummary.estimatedTokens,
+      compactPolicy,
+      { messages, sessionRef: session },
+    );
+    const usedTokens = compactionPressureTokens;
+    const freeTokens = displayWindow ? Math.max(0, displayWindow - usedTokens) : 0;
     const compactTriggerTokens = compactPolicy.triggerTokens || 0;
     const compactBufferTokens = compactPolicy.bufferTokens || 0;
     const compactBufferRatio = Number.isFinite(compactPolicy.bufferRatio)
@@ -193,7 +202,7 @@ export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMo
       effectiveContextWindowPercent: session?.effectiveContextWindowPercent || null,
       usedTokens,
       usedSource: 'estimated',
-      currentEstimatedTokens: estimatedContextTokens,
+      currentEstimatedTokens: compactionPressureTokens,
       lastApiRequestTokens: lastContextTokens || 0,
       lastApiRequestStale: lastUsageStale,
       freeTokens,
@@ -203,7 +212,7 @@ export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMo
         triggerTokens: compactTriggerTokens || null,
         bufferTokens: compactBufferTokens || null,
         bufferRatio: compactBufferRatio,
-        currentEstimatedTokens: estimatedContextTokens,
+        currentEstimatedTokens: compactionPressureTokens,
         lastApiRequestTokens: lastContextTokens || 0,
         lastApiRequestStale: lastUsageStale,
       },

package/src/session-runtime/model-route-api.mjs

@@ -21,6 +21,7 @@ import { SUMMARY_PREFIX } from '../runtime/agent/orchestrator/session/compact.mj
 import {
   hasUserConversationMessage,
 } from '../runtime/agent/orchestrator/session/manager/prompt-utils.mjs';
+import { rebuildDeferredToolSurfaceForProvider } from './tool-catalog.mjs';
 
 function isSummaryAnchorMessage(message) {
   return message?.role === 'user'
@@ -179,6 +180,7 @@ export function createModelRouteApi(deps) {
       }
       if (session) {
         const route = getRoute();
+        rebuildDeferredToolSurfaceForProvider(session, route.provider);
         const updated = mgr.updateSessionRoute?.(session.id, {
           provider: route.provider,
           model: route.model,

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

@@ -303,8 +303,8 @@ const {
   agentRouteFromConfig,
 } = createWorkflowRouteHelpers({ resolveDefaultProvider, findPreset });
 
-export function __renderToolSearchForTest(args = {}, session = {}, mode = 'full') {
-  return renderToolSearch(args, session, mode);
+export function __renderToolSearchForTest(args = {}, session = {}, mode = 'full', options = {}) {
+  return renderToolSearch(args, session, mode, options);
 }
 
 export function __saveModelSettingsForTest(cfgMod, route, options = {}) {

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

@@ -320,7 +320,10 @@ export function createSessionTurnApi(deps) {
       const catalog = Array.isArray(surface?.deferredToolCatalog)
         ? surface.deferredToolCatalog
         : (Array.isArray(surface?.tools) ? surface.tools : []);
-      const activeNames = new Set((surface?.tools || []).map((tool) => tool?.name).filter(Boolean));
+      const activeNames = new Set([
+        ...(surface?.tools || []).map((tool) => tool?.name).filter(Boolean),
+        ...(surface?.deferredCallableTools || []),
+      ]);
       const needle = clean(query).toLowerCase();
       const rows = catalog.map((tool) => toolRow(tool, activeNames)).filter((row) => row.name);
       const counts = splitToolStatusCounts(rows);