mixdog 0.8.0 → 0.8.1

package/src/runtime/memory/index.mjs

@@ -87,7 +87,7 @@ import { configureEmbedding, embedText, embedTexts, getEmbeddingDims, getEmbeddi
 import { startLlmWorker, stopLlmWorker } from './lib/llm-worker-host.mjs'
 import { runCycle1, runCycle2, runCycle3, runUnifiedGate, parseInterval, syncRootEmbedding, applySimpleStatus, applyUpdate, applyMerge, CYCLE2_ACTIVE_TARGET_CAP } from './lib/memory-cycle.mjs'
 import { getInFlightCycle1 } from './lib/memory-cycle1.mjs'
-import { claimAndMarkScheduledCycle, makeCycleRequestSignature, scheduleCoalescedCycleRetry } from './lib/memory-cycle-requests.mjs'
+import { claimAndMarkScheduledCycle, makeCycleRequestSignature, resolveCoalesceMaxRetries, scheduleCoalescedCycleRetry } from './lib/memory-cycle-requests.mjs'
 import { searchRelevantHybrid } from './lib/memory-recall-store.mjs'
 import { fetchEntriesByIdsScoped } from './lib/memory-recall-id-patch.mjs'
 import { retrieveEntries } from './lib/memory-retrievers.mjs'
@@ -1110,24 +1110,34 @@ async function enqueueScheduledCycle3(intervalMs, _reason = 'scheduled') {
   }
 }
 
-function scheduleScheduledCycle1(config, signature) {
+function scheduleScheduledCycle1(config, signature, attempt = 0) {
+  const maxRetries = resolveCoalesceMaxRetries(config, 3)
+  if (attempt > maxRetries) {
+    __mixdogMemoryLog('[cycle1] scheduled queue retry cap reached\n')
+    return
+  }
   scheduleCoalescedCycleRetry(db, 'cycle1', async () => {
     if (_cycle1InFlight) {
-      scheduleScheduledCycle1(config, signature)
+      scheduleScheduledCycle1(config, signature, attempt + 1)
       return
     }
     const result = await _awaitCycle1Run(config, {
       coalescedRetry: true,
       onCoalescedSuccess: recordCycle1Result,
     })
-    if (result?.skippedInFlight) scheduleScheduledCycle1(config, signature)
+    if (result?.skippedInFlight) scheduleScheduledCycle1(config, signature, attempt + 1)
   }, config, signature)
 }
 
-function scheduleScheduledCycle2(config, signature) {
+function scheduleScheduledCycle2(config, signature, attempt = 0) {
+  const maxRetries = resolveCoalesceMaxRetries(config, 3)
+  if (attempt > maxRetries) {
+    __mixdogMemoryLog('[cycle2] scheduled queue retry cap reached\n')
+    return
+  }
   scheduleCoalescedCycleRetry(db, 'cycle2', async () => {
     if (_cycle2InFlight) {
-      scheduleScheduledCycle2(config, signature)
+      scheduleScheduledCycle2(config, signature, attempt + 1)
       return
     }
     _cycle2InFlight = true
@@ -1137,7 +1147,7 @@ function scheduleScheduledCycle2(config, signature) {
         onCoalescedSuccess: _finalizeCycle2Run,
       }, DATA_DIR)
       if (result?.skippedInFlight) {
-        scheduleScheduledCycle2(config, signature)
+        scheduleScheduledCycle2(config, signature, attempt + 1)
       } else if (result?.coalescedRetryNoop) {
         __mixdogMemoryLog('[cycle2] scheduled queue noop\n')
       } else if (result?.ok === false) {
@@ -1151,11 +1161,16 @@ function scheduleScheduledCycle2(config, signature) {
   }, config, signature)
 }
 
-function scheduleScheduledCycle3(config, signature) {
+function scheduleScheduledCycle3(config, signature, attempt = 0) {
   const retryConfig = config?.cycle3 || config
+  const maxRetries = resolveCoalesceMaxRetries(retryConfig, 3)
+  if (attempt > maxRetries) {
+    __mixdogMemoryLog('[cycle3] scheduled queue retry cap reached\n')
+    return
+  }
   scheduleCoalescedCycleRetry(db, 'cycle3', async () => {
     if (_cycle3InFlight) {
-      scheduleScheduledCycle3(config, signature)
+      scheduleScheduledCycle3(config, signature, attempt + 1)
       return
     }
     _cycle3InFlight = true
@@ -1165,7 +1180,7 @@ function scheduleScheduledCycle3(config, signature) {
         onCoalescedSuccess: () => setCycleLastRun('cycle3', Date.now()),
       })
       if (result?.skippedInFlight) {
-        scheduleScheduledCycle3(config, signature)
+        scheduleScheduledCycle3(config, signature, attempt + 1)
       } else if (result?.coalescedRetryNoop) {
         __mixdogMemoryLog('[cycle3] scheduled queue noop\n')
       }
@@ -1860,6 +1875,93 @@ function renderEntryLines(rows) {
   return lines.join('\n')
 }
 
+async function dumpSessionRootChunks(args = {}) {
+  const sessionId = String(args.sessionId || args.session_id || '').trim()
+  if (!sessionId) return { text: '(no current session)', rows: [], chunks: [], isError: true }
+  const includeRaw = args.includeRaw !== false
+  const limit = Math.max(1, Math.min(1000, Number(args.limit) || 1000))
+  const rootRows = (await db.query(`
+    SELECT id, ts, role, content, session_id, source_turn, chunk_root, is_root,
+           element, category, summary, status, score, last_seen_at, project_id
+    FROM entries
+    WHERE session_id = $1 AND is_root = 1
+    ORDER BY COALESCE(source_turn, 2147483647) ASC, ts ASC, id ASC
+    LIMIT $2
+  `, [sessionId, limit])).rows
+  const roots = rootRows.map((r) => ({ ...r, members: [] }))
+  const rootIds = roots.map((r) => Number(r.id)).filter((id) => Number.isFinite(id))
+  const memberRows = rootIds.length > 0
+    ? (await db.query(`
+        SELECT id, ts, role, content, session_id, source_turn, chunk_root, is_root, project_id
+        FROM entries
+        WHERE chunk_root = ANY($1::bigint[]) AND is_root = 0
+        ORDER BY chunk_root ASC, COALESCE(source_turn, 2147483647) ASC, ts ASC, id ASC
+      `, [rootIds])).rows
+    : []
+  const byRoot = new Map(roots.map((r) => [Number(r.id), r]))
+  for (const m of memberRows) {
+    const root = byRoot.get(Number(m.chunk_root))
+    if (root) root.members.push(m)
+  }
+  let rawRows = []
+  if (includeRaw) {
+    rawRows = (await db.query(`
+      SELECT id, ts, role, content, session_id, source_turn, chunk_root, is_root, project_id
+      FROM entries
+      WHERE session_id = $1
+        AND is_root = 0
+        AND (chunk_root IS NULL OR chunk_root = id)
+      ORDER BY COALESCE(source_turn, 2147483647) ASC, ts ASC, id ASC
+      LIMIT $2
+    `, [sessionId, limit])).rows
+  }
+  const chunks = []
+  for (const root of roots) {
+    const memberText = root.members
+      .map((m) => `${m.role === 'assistant' ? 'assistant' : m.role === 'user' ? 'user' : m.role}: ${cleanMemoryText(String(m.content ?? ''))}`)
+      .filter(Boolean)
+      .join('\n')
+    const summary = [root.element, root.summary].map((v) => String(v || '').trim()).filter(Boolean).join(' — ')
+    chunks.push({
+      id: Number(root.id),
+      kind: 'root',
+      ts: Number(root.ts) || 0,
+      sourceTurn: root.source_turn ?? null,
+      category: root.category || null,
+      summary,
+      text: memberText || cleanMemoryText(String(root.content ?? '')),
+      members: root.members,
+    })
+  }
+  for (const raw of rawRows) {
+    chunks.push({
+      id: Number(raw.id),
+      kind: 'raw',
+      ts: Number(raw.ts) || 0,
+      sourceTurn: raw.source_turn ?? null,
+      category: null,
+      summary: '',
+      text: `${raw.role === 'assistant' ? 'assistant' : raw.role === 'user' ? 'user' : raw.role}: ${cleanMemoryText(String(raw.content ?? ''))}`,
+      members: [],
+    })
+  }
+  chunks.sort((a, b) => {
+    const at = Number.isFinite(Number(a.sourceTurn)) ? Number(a.sourceTurn) : 2147483647
+    const bt = Number.isFinite(Number(b.sourceTurn)) ? Number(b.sourceTurn) : 2147483647
+    return (at - bt) || ((a.ts || 0) - (b.ts || 0)) || ((a.id || 0) - (b.id || 0))
+  })
+  const text = chunks.length
+    ? chunks.map((chunk, idx) => {
+        const label = chunk.kind === 'root'
+          ? `# chunk ${idx + 1} root=${chunk.id}${chunk.category ? ` category=${chunk.category}` : ''}`
+          : `# raw ${idx + 1} id=${chunk.id}`
+        const summary = chunk.summary ? `summary: ${chunk.summary}\n` : ''
+        return `${label}\n${summary}${chunk.text}`.trim()
+      }).join('\n\n')
+    : '(no results)'
+  return { text, rows: [...roots, ...rawRows], chunks }
+}
+
 async function entryStats() {
   return await db.transaction(async (tx) => {
     const total               = (await tx.query(`SELECT COUNT(*) c FROM entries`)).rows[0].c
@@ -2224,6 +2326,10 @@ async function handleMemoryAction(args, signal) {
     return ingestSessionMessages(args)
   }
 
+  if (action === 'dump_session_roots') {
+    return dumpSessionRootChunks(args)
+  }
+
   if (action === 'manage') {
     const op = String(args.op ?? '').trim().toLowerCase()
     if (!['add', 'edit', 'delete'].includes(op)) {

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

@@ -277,7 +277,7 @@ export async function runCycle1(db, config = {}, options = {}, dataDir = null) {
   )
   if (_runCycle1InFlight.has(db)) {
     if (!coalescedRetry) await markCycleRequest(db, 'cycle1', 'in-flight', requestSignature)
-    scheduleRetry()
+    if (!coalescedRetry || retryAttempt < maxRetries) scheduleRetry()
     logCycle1Throttled('in-flight', '[cycle1] skipped: already in flight for this db\n')
     return {
       processed: 0, chunks: 0, skipped: 0, sessions: 0,
@@ -301,7 +301,7 @@ export async function runCycle1(db, config = {}, options = {}, dataDir = null) {
   if (!gotLock) {
     client.release()
     if (!coalescedRetry) await markCycleRequest(db, 'cycle1', 'advisory-lock', requestSignature)
-    scheduleRetry()
+    if (!coalescedRetry || retryAttempt < maxRetries) scheduleRetry()
     logCycle1Throttled('advisory-lock', '[cycle1] skipped: advisory lock held by another worker\n')
     return { processed: 0, chunks: 0, skipped: 0, sessions: 0, skippedInFlight: true, pendingRows: await countPendingRows(db) }
   }
@@ -390,23 +390,23 @@ async function _runCycle1Impl(db, config = {}, options = {}, _dataDir = null) {
   const timeout = callerDeadlineMs > 0
     ? Math.min(baseTimeout, Math.max(5000, callerDeadlineMs - 1000))
     : baseTimeout
-  // Select oldest-pending sessions first, then fetch oldest rows per selected
-  // session. This keeps classifier windows session-isolated and prevents hot
-  // sessions/new rows from starving older pending work.
+  // Select closest/recent sessions first, then fetch closest/recent rows per
+  // selected session. Memory fill is recency-first; session isolation below
+  // keeps unrelated episodes out of the same classifier prompt.
   const fetchResult = await db.query(
     `WITH selected_sessions AS (
-       SELECT session_id, MIN(ts) AS oldest_ts, MIN(id) AS oldest_id
+       SELECT session_id, MAX(ts) AS latest_ts, MAX(id) AS latest_id
        FROM entries
        WHERE chunk_root IS NULL
          AND NULLIF(btrim(session_id), '') IS NOT NULL
          AND (reviewed_at IS NULL OR reviewed_at < $2)
        GROUP BY session_id
-       ORDER BY oldest_ts ASC, oldest_id ASC
+       ORDER BY latest_ts DESC, latest_id DESC
        LIMIT $1
      ), ranked AS (
        SELECT e.id, e.ts, e.role, e.content, e.session_id, e.source_ref, e.project_id,
-              s.oldest_ts, s.oldest_id,
-              ROW_NUMBER() OVER (PARTITION BY e.session_id ORDER BY e.ts ASC, e.id ASC) AS rn
+              s.latest_ts, s.latest_id,
+              ROW_NUMBER() OVER (PARTITION BY e.session_id ORDER BY e.ts DESC, e.id DESC) AS rn
        FROM entries e
        JOIN selected_sessions s ON s.session_id = e.session_id
        WHERE e.chunk_root IS NULL
@@ -415,7 +415,7 @@ async function _runCycle1Impl(db, config = {}, options = {}, _dataDir = null) {
      SELECT id, ts, role, content, session_id, source_ref, project_id
      FROM ranked
      WHERE rn <= $3
-     ORDER BY oldest_ts ASC, oldest_id ASC, session_id, ts DESC, id DESC`,
+     ORDER BY latest_ts DESC, latest_id DESC, session_id, ts DESC, id DESC`,
     [sessionCap, Date.now() - CYCLE1_OMITTED_COOLDOWN_MS, batchSize],
   )
   throwIfAborted(signal)

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

@@ -901,7 +901,7 @@ export async function runCycle2(db, config = {}, options = {}, dataDir = null) {
   }
   if (_runCycle2InFlight.has(db)) {
     if (!coalescedRetry) await markCycleRequest(db, 'cycle2', 'in-flight', requestSignature)
-    scheduleRetry()
+    if (!coalescedRetry || retryAttempt < maxRetries) scheduleRetry()
     __mixdogMemoryLog('[cycle2] skipped: already in flight for this db\n')
     return { ok: true, ...partial, skippedInFlight: true }
   }
@@ -921,7 +921,7 @@ export async function runCycle2(db, config = {}, options = {}, dataDir = null) {
   if (!gotLock) {
     client.release()
     if (!coalescedRetry) await markCycleRequest(db, 'cycle2', 'advisory-lock', requestSignature)
-    scheduleRetry()
+    if (!coalescedRetry || retryAttempt < maxRetries) scheduleRetry()
     __mixdogMemoryLog('[cycle2] skipped: advisory lock held by another worker\n')
     return { ok: true, ...partial, skippedInFlight: true }
   }

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

@@ -272,7 +272,7 @@ export async function runCycle3(db, config, dataDir, options = {}) {
   }
   if (_runCycle3InFlight.has(db)) {
     if (!coalescedRetry) await markCycleRequest(db, 'cycle3', 'in-flight', requestSignature)
-    scheduleRetry()
+    if (!coalescedRetry || retryAttempt < maxRetries) scheduleRetry()
     __mixdogMemoryLog('[cycle3] skipped: already in flight for this db\n')
     return { ...partial, skippedInFlight: true }
   }
@@ -291,7 +291,7 @@ export async function runCycle3(db, config, dataDir, options = {}) {
   if (!gotLock) {
     client.release()
     if (!coalescedRetry) await markCycleRequest(db, 'cycle3', 'advisory-lock', requestSignature)
-    scheduleRetry()
+    if (!coalescedRetry || retryAttempt < maxRetries) scheduleRetry()
     __mixdogMemoryLog('[cycle3] skipped: advisory lock held by another worker\n')
     return { ...partial, skippedInFlight: true }
   }

package/src/runtime/memory/lib/pg/adapter.mjs

@@ -4,6 +4,18 @@ function __mixdogMemoryLog(...args) {
   return __mixdogMemoryStderrWrite(...args);
 }
 
+function installPoolErrorHandler(pool, label) {
+  if (!pool || typeof pool.on !== 'function') return pool
+  pool.on('error', (err, client) => {
+    const code = err?.code || err?.errno || ''
+    const msg = err?.message || String(err || 'unknown error')
+    const pid = client?.processID ? ` pid=${client.processID}` : ''
+    const suffix = code ? ` ${code}` : ''
+    __mixdogMemoryLog(`[pg-adapter] ${label} idle client error${suffix}${pid}: ${msg}\n`)
+  })
+  return pool
+}
+
 // pg-adapter.mjs — PG connection manager for mixdog 0.4.0
 // Single owner: supervisor-pg.ensurePgInstance(dataDir) starts PG.
 // pg-adapter calls supervisor-pg — never pg-process directly.
@@ -235,6 +247,7 @@ export async function ensurePgInstance(dataDir, opts = {}) {
       host, port, user: PG_USER, database: 'postgres',
       password: '', max: 1, idleTimeoutMillis: 5_000,
     })
+    installPoolErrorHandler(adminPool, 'admin-pool')
     try {
       // CREATE DATABASE cannot run inside a transaction, so guard the
       // check-then-create with a session-level advisory lock held on a single
@@ -280,6 +293,7 @@ export async function ensurePgInstance(dataDir, opts = {}) {
       password: '', max: 5, idleTimeoutMillis: 30_000,
       connectionTimeoutMillis: 10_000,
     })
+    installPoolErrorHandler(pgPool, `pool:${schema}`)
 
     // 4. Bootstrap extensions + schemas once (idempotent).
     await bootstrapInstance(pgPool, resolve(dataDir))

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

@@ -721,7 +721,7 @@ export function isMemorySurface(label) {
 
 export const CATEGORY_ORDER = [
   'Read', 'Search', 'Web Research', 'Memory', 'Explore',
-  'Patch', 'Edit', 'Shell', 'Agent', 'Channel', 'Setup', 'Other',
+  'Patch', 'Shell', 'Agent', 'Channel', 'Setup', 'Other',
 ];
 
 const TOOL_CATEGORY = new Map([
@@ -751,8 +751,6 @@ const TOOL_CATEGORY = new Map([
   ['memory', 'Memory'],
   ['explore', 'Explore'],
   ['apply_patch', 'Patch'],
-  ['write', 'Edit'],
-  ['edit', 'Edit'],
   ['bash', 'Shell'],
   ['shell', 'Shell'],
   ['shell_command', 'Shell'],
@@ -804,7 +802,6 @@ const CATEGORY_COPY = new Map([
   ['Memory', { active: 'Checking', done: 'Checked', noun: 'memory item' }],
   ['Explore', { active: 'Exploring', done: 'Explored', noun: 'item' }],
   ['Patch', { active: 'Editing', done: 'Edited', noun: 'item' }],
-  ['Edit', { active: 'Editing', done: 'Edited', noun: 'item' }],
   ['Shell', { active: 'Running', done: 'Ran', noun: 'command' }],
   ['Agent', { active: 'Calling', done: 'Called', noun: 'agent' }],
   ['Channel', { active: 'Sending', done: 'Sent', noun: 'message' }],

package/src/tui/App.jsx

@@ -2420,6 +2420,7 @@ export function App({ store, initialStatusLine = '' }) {
 
   const openContextPicker = () => {
     const tools = store.toolsStatus?.() || { activeCount: 0, count: 0, activeTools: [] };
+    const mcp = store.mcpStatus?.() || { connectedCount: 0, configuredCount: 0, failedCount: 0 };
     const skills = store.skillsStatus?.() || { count: 0 };
     const plugins = store.pluginsStatus?.() || { count: 0 };
     const context = store.contextStatus?.() || {};
@@ -2553,6 +2554,7 @@ export function App({ store, initialStatusLine = '' }) {
         messages: {
           tokens: messages.estimatedTokens,
           count: messages.count,
+          semantic: messages.semantic,
         },
         tools: {
           schemaTokens: request.toolSchemaTokens,
@@ -2564,6 +2566,7 @@ export function App({ store, initialStatusLine = '' }) {
           results: messages.toolResultCount,
         },
         request: {
+          toolSchemaBreakdown: request.toolSchemaBreakdown,
           overheadTokens: request.requestOverheadTokens,
           reserveTokens: request.reserveTokens,
         },
@@ -2580,6 +2583,11 @@ export function App({ store, initialStatusLine = '' }) {
           skills: skills.count,
           plugins: plugins.count,
         },
+        mcp: {
+          connected: mcp.connectedCount,
+          configured: mcp.configuredCount,
+          failed: mcp.failedCount,
+        },
       },
       rows: contextRows,
     });
@@ -4538,7 +4546,7 @@ export function App({ store, initialStatusLine = '' }) {
               return;
             }
             if (r.changed === false) {
-              store.pushNotice('No changes.', 'warn');
+              store.pushNotice('nothing to compact', 'warn');
               return;
             }
             store.pushNotice('Compact done.', 'info');
@@ -5001,7 +5009,7 @@ export function App({ store, initialStatusLine = '' }) {
   const desiredFloatingPanelRows = picker
     ? (picker.fillAvailable ? maxFloatingPanelRows : PANEL_BASE_ROWS + OPTION_PANEL_EXTRA_ROWS)
     : contextPanel
-      ? PANEL_BASE_ROWS + OPTION_PANEL_EXTRA_ROWS
+      ? PANEL_BASE_ROWS + OPTION_PANEL_EXTRA_ROWS + 3
       : usagePanel
         ? PANEL_BASE_ROWS + OPTION_PANEL_EXTRA_ROWS
     : slashPaletteOpen

package/src/tui/components/ContextPanel.jsx

@@ -75,25 +75,57 @@ function metricValue(parts) {
   return parts.filter(Boolean).join(' · ');
 }
 
-function MetricCell({ label, value, width, tone }) {
-  const labelWidth = Math.min(12, Math.max(8, Math.floor(width * 0.34)));
-  const valueWidth = Math.max(0, width - labelWidth - 1);
+function DetailLine({ label, value, columns }) {
+  const innerWidth = Math.max(24, Math.floor(columns || 80) - 4);
+  const labelWidth = 10;
+  const valueWidth = Math.max(0, innerWidth - labelWidth - 2);
+  return (
+    <Box flexDirection="row" width="100%">
+      <Text color={theme.subtle}>{padCells(truncateText(label, labelWidth), labelWidth)}</Text>
+      <Text color={theme.inactive}>  </Text>
+      <Text color={theme.text}>{truncateText(value, valueWidth)}</Text>
+    </Box>
+  );
+}
+
+function bucketTokens(map, names) {
+  return names.reduce((sum, name) => sum + finiteNumber(map?.[name]?.tokens), 0);
+}
+
+function bucketCount(map, names) {
+  return names.reduce((sum, name) => sum + finiteNumber(map?.[name]?.count), 0);
+}
+
+function semanticTokens(semantic, names) {
+  return names.reduce((sum, name) => sum + finiteNumber(semantic?.[name]?.tokens), 0);
+}
+
+function CategoryItem({ label, tokens, total, width }) {
+  const labelWidth = Math.min(11, Math.max(7, Math.floor(width * 0.22)));
+  const pctWidth = 6;
+  const tokenWidth = 7;
+  const barWidth = Math.max(6, Math.min(20, width - labelWidth - pctWidth - tokenWidth - 4));
+  const pct = percent(tokens, total);
   return (
     <Box flexDirection="row" width={width}>
-      <Text color={theme.subtle}>{padCells(truncateText(label, labelWidth), labelWidth)} </Text>
-      <Text color={tone || theme.text}>{truncateText(value, valueWidth)}</Text>
+      <Text color={theme.subtle}>{padCells(truncateText(label, labelWidth), labelWidth)}</Text>
+      <Text color={theme.inactive}> </Text>
+      <Text color={usageColor(pct)}>{padCells(percentLabel(tokens, total), pctWidth)}</Text>
+      <ProgressBar value={tokens} total={total} width={barWidth} />
+      <Text color={theme.inactive}> </Text>
+      <Text color={theme.text}>{padCells(formatTokens(tokens), tokenWidth)}</Text>
     </Box>
   );
 }
 
-function MetricGrid({ cells, columns }) {
+function CategoryGrid({ categories, columns, total }) {
   const innerWidth = Math.max(24, Math.floor(columns || 80) - 4);
-  const twoColumns = innerWidth >= 76;
+  const twoColumns = innerWidth >= 84;
   if (!twoColumns) {
     return (
       <Box flexDirection="column" width="100%">
-        {cells.map((cell) => (
-          <MetricCell key={cell.label} {...cell} width={innerWidth} />
+        {categories.map((category) => (
+          <CategoryItem key={category.label} {...category} total={total} width={innerWidth} />
         ))}
       </Box>
     );
@@ -102,14 +134,14 @@ function MetricGrid({ cells, columns }) {
   const leftWidth = Math.floor((innerWidth - gap) / 2);
   const rightWidth = innerWidth - gap - leftWidth;
   const pairs = [];
-  for (let i = 0; i < cells.length; i += 2) pairs.push(cells.slice(i, i + 2));
+  for (let i = 0; i < categories.length; i += 2) pairs.push(categories.slice(i, i + 2));
   return (
     <Box flexDirection="column" width="100%">
       {pairs.map((pair, index) => (
         <Box key={index} flexDirection="row" width="100%">
-          <MetricCell {...pair[0]} width={leftWidth} />
+          <CategoryItem {...pair[0]} total={total} width={leftWidth} />
           <Text>{' '.repeat(gap)}</Text>
-          {pair[1] ? <MetricCell {...pair[1]} width={rightWidth} /> : null}
+          {pair[1] ? <CategoryItem {...pair[1]} total={total} width={rightWidth} /> : null}
         </Box>
       ))}
     </Box>
@@ -127,6 +159,9 @@ function ContextUsageView({ detail, columns }) {
   const lastApi = detail?.lastApi || {};
   const cache = detail?.cache || {};
   const extensions = detail?.extensions || {};
+  const mcp = detail?.mcp || {};
+  const semantic = messages.semantic || {};
+  const schema = request.toolSchemaBreakdown || {};
   const usedTokens = finiteNumber(usage.usedTokens);
   const windowTokens = finiteNumber(usage.windowTokens);
   const freeTokens = windowTokens ? Math.max(0, windowTokens - usedTokens) : finiteNumber(usage.freeTokens);
@@ -134,25 +169,34 @@ function ContextUsageView({ detail, columns }) {
   const summaryText = `${formatTokens(usedTokens)} / ${formatTokens(windowTokens)} · ${formatTokens(freeTokens)} free`;
   const pctText = `${percentLabel(usedTokens, windowTokens)} used`;
   const barWidth = Math.max(12, Math.min(34, innerWidth - stringWidth(summaryText) - stringWidth(pctText) - 5));
+  const builtInToolTokens = bucketTokens(schema, ['code', 'web', 'mutation', 'channels', 'setup', 'other']);
+  const builtInToolCount = bucketCount(schema, ['code', 'web', 'mutation', 'channels', 'setup', 'other']);
+  const projectTokens = semanticTokens(semantic, ['project', 'workspace', 'environment', 'other']);
   const compactionLine = metricValue([
-    compaction.stage || 'pending',
+    compaction.stage && compaction.stage !== 'pending' ? compaction.stage : '',
     compaction.state,
     compaction.triggerTokens ? `trigger ${formatTokens(compaction.triggerTokens)}` : '',
-    compaction.boundaryTokens ? `boundary ${formatTokens(compaction.boundaryTokens)}` : '',
   ]);
-  const metaLine = metricValue([
-    usage.source || 'estimated',
-    usage.effective ? 'effective window' : '',
+  const sourceLine = metricValue([
+    usage.effective ? `effective ${formatTokens(windowTokens)}` : `window ${formatTokens(windowTokens)}`,
     usage.rawWindowTokens && usage.rawWindowTokens !== usage.windowTokens ? `raw ${formatTokens(usage.rawWindowTokens)}` : '',
   ]);
-  const cells = [
-    { label: 'Messages', value: metricValue([`${formatTokens(messages.tokens)} tokens`, `${messages.count || 0} msgs`]) },
-    { label: 'Tools', value: metricValue([`${formatTokens(tools.schemaTokens)} schema`, `${tools.active || 0}/${tools.count || 0} active`]) },
-    { label: 'Tool I/O', value: metricValue([`${toolIo.calls || 0} calls`, `${toolIo.results || 0} results`]) },
-    { label: 'Overhead', value: metricValue([`${formatTokens(request.overheadTokens)} frame`, `${formatTokens(request.reserveTokens)} reserve`]) },
-    { label: 'Last API', value: metricValue([`${formatTokens(lastApi.contextTokens)} ctx`, `${formatTokens(lastApi.inputTokens)} in`, `${formatTokens(lastApi.outputTokens)} out`]) },
-    { label: 'Cache', value: metricValue([`${cache.hitRate || 'n/a'} hit`, `${formatTokens(cache.readTokens)} read`]) },
-    { label: 'Extensions', value: metricValue([`${extensions.skills || 0} skills`, `${extensions.plugins || 0} plugins`]) },
+  const apiLine = metricValue([
+    `last ctx ${formatTokens(lastApi.contextTokens)}`,
+    `in/out ${formatTokens(lastApi.inputTokens)}/${formatTokens(lastApi.outputTokens)}`,
+    `cache ${cache.hitRate || 'n/a'}`,
+  ]);
+  const categories = [
+    { label: 'Messages', tokens: semanticTokens(semantic, ['chat', 'assistant']), meta: '' },
+    { label: 'Tools', tokens: builtInToolTokens, meta: `${tools.active || 0}/${tools.count || 0} active${builtInToolCount ? ` · ${builtInToolCount} defs` : ''}` },
+    { label: 'MCP', tokens: bucketTokens(schema, ['mcp']), meta: `${mcp.connected || 0}/${mcp.configured || 0} servers` },
+    { label: 'Skills', tokens: bucketTokens(schema, ['skills']), meta: `${extensions.skills || 0} skills` },
+    { label: 'Memory', tokens: semanticTokens(semantic, ['memory']) + bucketTokens(schema, ['memory']), meta: 'core + recall tools' },
+    { label: 'Project', tokens: projectTokens, meta: 'mixdog.md · workspace' },
+    { label: 'Workflow', tokens: semanticTokens(semantic, ['workflow']) + bucketTokens(schema, ['agents']), meta: 'workflow · agents' },
+    { label: 'System', tokens: semanticTokens(semantic, ['system']), meta: 'rules · role catalog' },
+    { label: 'Overhead', tokens: finiteNumber(request.overheadTokens), meta: 'request frame' },
+    { label: 'Tool I/O', tokens: semanticTokens(semantic, ['toolResults']), meta: `${toolIo.calls || 0} calls · ${toolIo.results || 0} results` },
   ];
 
   return (
@@ -165,11 +209,15 @@ function ContextUsageView({ detail, columns }) {
         <Text color={theme.text}>{truncateText(summaryText, Math.max(0, innerWidth - Math.min(10, innerWidth) - barWidth - 3))}</Text>
       </Box>
       <Box marginTop={1} flexDirection="column" width="100%">
-        <Text color={theme.subtle}>{truncateText(metaLine, innerWidth)}</Text>
-        <Text color={theme.text}>{truncateText(`Compaction  ${compactionLine}`, innerWidth)}</Text>
+        <DetailLine label="Source" value={sourceLine} columns={columns} />
+        <DetailLine label="Compaction" value={compactionLine} columns={columns} />
+        <DetailLine label="API/cache" value={apiLine} columns={columns} />
       </Box>
       <Box marginTop={1} flexDirection="column" width="100%">
-        <MetricGrid cells={cells} columns={columns} />
+        <Text color={theme.subtle}>Context mix</Text>
+        <Box marginTop={1} flexDirection="column" width="100%">
+          <CategoryGrid categories={categories} columns={columns} total={windowTokens} />
+        </Box>
       </Box>
     </Box>
   );

package/src/tui/components/ToolExecution.jsx

@@ -38,6 +38,7 @@ export function summarizeArgs(name, args) {
 
 export const MAX_RESULT_LINES = 8;
 const TOOL_BLINK_MS = 500;
+const TOOL_BLINK_LIMIT_MS = 3000;
 const TOOL_PENDING_SHOW_DELAY_MS = 1000;
 const TOOL_HINT_DONE_COLOR = theme.subtle;
 const COUNT_TWEEN_MS = 700;
@@ -249,8 +250,6 @@ function statusCopy(normalizedName, label, count, doneCount, pending, isError) {
     case 'view_image':
     case 'read_mcp_resource':
       return copy('Reading', 'Read', 'file');
-    case 'write':
-    case 'edit':
     case 'apply_patch':
       return copy('Editing', 'Edited', 'file');
     case 'grep':
@@ -492,7 +491,7 @@ function progressDetail({ normalizedName, label, elapsed }) {
   if (n === 'explore' || l === 'explore') return `Exploring${suffix}`;
   if (n === 'grep' || n === 'glob' || n === 'list' || n === 'ls' || l === 'search') return `Searching${suffix}`;
   if (n === 'read' || n === 'view_image' || n === 'read_mcp_resource' || l === 'read') return `Reading${suffix}`;
-  if (n === 'write' || n === 'edit' || n === 'apply_patch' || l === 'update') return `Editing${suffix}`;
+  if (n === 'apply_patch' || l === 'update') return `Editing${suffix}`;
   if (n === 'recall' || n === 'recall_memory' || n === 'search_memories' || l === 'memory') return `Checking Memory${suffix}`;
   if (l === 'setup') return `Setting Up${suffix}`;
   return `Working${suffix}`;
@@ -538,6 +537,7 @@ function toolStatusColor({ pending, groupCount, failedCount }) {
 
 export function ToolExecution({ name, args, result, rawResult, isError, errorCount, expanded, globalExpanded = false, columns = 80, attached = false, count = 1, completedCount = 0, startedAt = 0, completedAt = 0, aggregate = false, categories = {}, headerFinalized = true }) {
   const [blinkOn, setBlinkOn] = useState(true);
+  const [blinkExpired, setBlinkExpired] = useState(false);
   const [pendingDelayElapsed, setPendingDelayElapsed] = useState(false);
   const groupCount = Math.max(1, Number(count || 1));
   const doneCount = Math.max(0, Math.min(groupCount, Number(completedCount || (result == null ? 0 : groupCount))));
@@ -581,10 +581,29 @@ export function ToolExecution({ name, args, result, rawResult, isError, errorCou
   }, [pending, startedAt]);
 
   useEffect(() => {
-    if (!pending || !pendingDisplayReady) return undefined;
+    if (!pending || !pendingDisplayReady || blinkExpired) {
+      setBlinkOn(true);
+      return undefined;
+    }
     const timer = setInterval(() => setBlinkOn((on) => !on), TOOL_BLINK_MS);
     return () => clearInterval(timer);
-  }, [pending, pendingDisplayReady]);
+  }, [pending, pendingDisplayReady, blinkExpired]);
+
+  useEffect(() => {
+    if (!pending || !pendingDisplayReady) {
+      setBlinkExpired(false);
+      return undefined;
+    }
+    const started = Number(startedAt || 0);
+    const remaining = TOOL_BLINK_LIMIT_MS - (started ? Math.max(0, Date.now() - started) : 0);
+    if (remaining <= 0) {
+      setBlinkExpired(true);
+      return undefined;
+    }
+    setBlinkExpired(false);
+    const timer = setTimeout(() => setBlinkExpired(true), remaining);
+    return () => clearTimeout(timer);
+  }, [pending, pendingDisplayReady, startedAt]);
 
   if (pending && !pendingDisplayReady) return null;
 
@@ -605,7 +624,7 @@ export function ToolExecution({ name, args, result, rawResult, isError, errorCou
     }
 
     const dotColor = statusColor;
-    const dotText = pending && !blinkOn ? ' ' : TURN_MARKER;
+    const dotText = pending && !blinkExpired && !blinkOn ? ' ' : TURN_MARKER;
     const gutter = 2;
     const showHeaderExpandHint = hasRawResult;
     const hintLabel = showHeaderExpandHint ? `ctrl+o ${expanded ? 'collapse' : 'expand'}` : '';
@@ -700,7 +719,7 @@ export function ToolExecution({ name, args, result, rawResult, isError, errorCou
   const isAgentResponse = isAgentResult && hasAgentResponseResult(rt);
   const isAgentMetadataResult = isAgentResult && !isAgentResponse;
   const dotColor = statusColor;
-  const dotText = pending && !blinkOn ? ' ' : TURN_MARKER;
+  const dotText = pending && !blinkExpired && !blinkOn ? ' ' : TURN_MARKER;
   let labelText;
   if (isAgentResponse) labelText = agentResponseTitle(parsedArgs);
   else if (isBackgroundResponse) labelText = backgroundTaskResultTitle(normalizedName, backgroundMeta || parsedArgs);