mixdog 0.9.41 → 0.9.44

package/src/tui/engine/session-api.mjs

@@ -516,6 +516,9 @@ export function createEngineApiA(bag) {
         syncContextStats({ allowEstimated: true });
         set({ ...routeState(), stats: { ...getState().stats } });
         if (result) {
+          if (!result.error && result.changed !== false) {
+            set({ items: replaceItems([]) });
+          }
           pushItem({
             kind: 'statusdone',
             id: nextId(),

package/src/tui/engine/session-flow.mjs

@@ -2,13 +2,14 @@
  * src/tui/engine/session-flow.mjs - prompt queue drain + session clear/reset. Extracted from engine.mjs.
  */
 import { presentErrorText } from '../../runtime/shared/err-text.mjs';
+import { resetAllStreamingMarkdownStablePrefixes } from '../markdown/streaming-markdown.mjs';
 import { createSessionStats } from './session-stats.mjs';
 import { queuePriorityValue, defaultQueuePriority, isQueuedEntryEditable, isQueuedEntryVisible, isSlashQueuedEntry, notificationDisplayText, sessionActivityTimestamp, promptDisplayText, mergePromptContents, mergePastedImages, mergePastedTexts, callCommitCallbacks, STEERING_SUPPRESSED_DISPLAY } from './queue-helpers.mjs';
 import { appendTuiSteeringPersist, dropTuiSteeringPersist, drainTuiSteeringPersist } from './tui-steering-persist.mjs';
 
 export function createSessionFlow(bag) {
   const {
-    runtime, nextId, tuiDebug, flags, pending, pendingNotificationKeys, displayedExecutionNotificationKeys, clearExecutionDedupState, getState, set, pushItem, replaceItems, pushNotice, pushUserOrSyntheticItem, autoClearState, agentStatusState, routeState, syncContextStats, flushDeferredExecutionPendingResumeKick,
+    runtime, nextId, tuiDebug, flags, pending, pendingNotificationKeys, displayedExecutionNotificationKeys, clearExecutionDedupState, clearToastTimers, getState, set, pushItem, replaceItems, pushNotice, pushUserOrSyntheticItem, autoClearState, agentStatusState, routeState, syncContextStats, flushDeferredExecutionPendingResumeKick,
   } = bag;
 
   // Upper bound on the awaited compacting clear. requireCompactSuccess makes
@@ -382,7 +383,10 @@ export function createSessionFlow(bag) {
   // Shared clear body for idle auto-clear and the session_manage tool.
   // useCompaction=true mirrors auto-clear (summarize via configured
   // compactType, context carries forward); false is a plain /clear wipe.
-  async function performSessionClear({ verb, doneLabel, skipLabel, surface, useCompaction }) {
+  async function performSessionClear({
+    verb, doneLabel, skipLabel, surface, useCompaction,
+    compactTimeoutMs = AUTO_CLEAR_COMPACT_TIMEOUT_MS,
+  }) {
     flags.autoClearRunning = true;
     const startedAt = Date.now();
     // commandBusy blocks concurrent session commands (resume/newSession/
@@ -401,6 +405,7 @@ export function createSessionFlow(bag) {
         const compaction = runtime.getCompactionSettings();
         compactType = compaction.compactType || compaction.type || null;
       }
+      let clearResult;
       if (compactType) {
         // Bounded watchdog around the compacting clear. On timeout we throw so
         // the catch below keeps the conversation, surfaces a user-visible
@@ -410,21 +415,22 @@ export function createSessionFlow(bag) {
         // new auto-clear attempts until the abandoned promise settles, and on
         // late fulfillment we run the same post-success UI sync as the normal
         // path so the UI cannot diverge from a runtime session that actually
-        // got cleared. Late rejection is a no-op.
+        // got cleared. Late rejection or a false result is a no-op.
         const clearPromise = runtime.clear({ compactType, requireCompactSuccess: true });
         let timer = null;
         const timeout = new Promise((_, reject) => {
           timer = setTimeout(
-            () => reject(new Error(`compaction timed out after ${AUTO_CLEAR_COMPACT_TIMEOUT_MS}ms; auto-clear deferred to next idle`)),
-            AUTO_CLEAR_COMPACT_TIMEOUT_MS,
+            () => reject(new Error(`compaction timed out after ${compactTimeoutMs}ms; auto-clear deferred to next idle`)),
+            compactTimeoutMs,
           );
         });
         try {
-          await Promise.race([clearPromise, timeout]);
+          clearResult = await Promise.race([clearPromise, timeout]);
         } catch (raceError) {
           flags.autoClearInFlight = true;
           clearPromise.then(
-            () => {
+            (lateResult) => {
+              if (lateResult === false) return;
               if (getState().busy) {
                 // A turn started after commandBusy released; applying the
                 // cleared-session UI now would wipe items/queued and force
@@ -446,7 +452,10 @@ export function createSessionFlow(bag) {
           if (timer) clearTimeout(timer);
         }
       } else {
-        await runtime.clear({});
+        clearResult = await runtime.clear({});
+      }
+      if (clearResult === false) {
+        throw new Error('runtime clear returned false');
       }
       applyClearedSessionUi(doneLabel);
       return true;
@@ -490,6 +499,8 @@ export function createSessionFlow(bag) {
     return getState().stats;
   };
   const clearUiActivityBeforeContextSync = () => {
+    clearToastTimers();
+    resetAllStreamingMarkdownStablePrefixes();
     getState().items = replaceItems([]);
     getState().toasts = [];
     getState().queued = [];

package/src/tui/engine/turn.mjs

@@ -12,7 +12,7 @@ import { aggregateRawResult, aggregateBucketForCategory, aggregateSummaries, ass
 
 export function createRunTurn(bag) {
   const {
-    runtime, nextId, tuiDebug, LEAD_TURN_TIMEOUT_MS, flags, pending, itemIndexById, getState, set, pushItem, patchItem, updateStreamingTail: updateStreamingTailFromStore, settleStreamingTail: settleStreamingTailFromStore, clearStreamingTail: clearStreamingTailFromStore, pushNotice, pushUserOrSyntheticItem, markToolCallActive, markToolCallDone, clearActiveToolSummary, agentStatusState, routeState, syncContextStats, denyAllToolApprovals, requestToolApproval, patchToolCardResult, flushToolResults, flushDeferredExecutionPendingResumeKick, drain, drainPendingSteering,
+    runtime, nextId, tuiDebug, LEAD_TURN_TIMEOUT_MS, flags, pending, itemIndexById, getState, set, pushItem, patchItem, replaceItems, updateStreamingTail: updateStreamingTailFromStore, settleStreamingTail: settleStreamingTailFromStore, clearStreamingTail: clearStreamingTailFromStore, pushNotice, pushUserOrSyntheticItem, markToolCallActive, markToolCallDone, clearActiveToolSummary, agentStatusState, routeState, syncContextStats, denyAllToolApprovals, requestToolApproval, patchToolCardResult, flushToolResults, flushDeferredExecutionPendingResumeKick, drain, drainPendingSteering,
   } = bag;
   // Small fallbacks keep isolated createRunTurn harnesses source-compatible;
   // the real engine supplies atomic implementations that also maintain revision.
@@ -209,7 +209,14 @@ export function createRunTurn(bag) {
     let cancelled = false;
     let askResult = null;
     let turnFinishedNormally = false;
+    let transcriptCompactedThisTurn = false;
     const itemsAtTurnStart = getState().items.length;
+    const submittedIdSet = new Set(submittedIds.filter((id) => id != null));
+    const firstSubmittedIndex = getState().items.findIndex((item) => submittedIdSet.has(item?.id));
+    // The submitted user row is pushed immediately before runTurn. Keep it and
+    // everything produced after it if compaction succeeds mid-turn; dropping all
+    // items would invalidate live tool-card ids and the streaming assistant tail.
+    let currentTurnItemsStart = firstSubmittedIndex >= 0 ? firstSubmittedIndex : itemsAtTurnStart;
     const cardByCallId = new Map();
     const toolCards = [];
     const toolGroups = new Map();
@@ -987,6 +994,13 @@ export function createRunTurn(bag) {
           // later same-category tool call doesn't reuse a card whose count
           // would then change above this statusdone item.
           clearAggregateContinuation();
+          const compactStatus = String(event?.status || '').toLowerCase();
+          if (!['failed', 'skipped', 'no_change'].includes(compactStatus)) {
+            const currentTurnItems = getState().items.slice(currentTurnItemsStart);
+            set({ items: replaceItems(currentTurnItems, { preserveStreamingTail: true }) });
+            currentTurnItemsStart = 0;
+            transcriptCompactedThisTurn = true;
+          }
           pushItem({
             kind: 'statusdone',
             id: nextId(),
@@ -1103,6 +1117,13 @@ export function createRunTurn(bag) {
       } else {
         askResult = result;
         markPromptCommitted();
+        if (result?.terminationReason === 'refusal') {
+          pushNotice(
+            'The model refused to respond (safety refusal) — retry or rephrase your prompt.',
+            'warn',
+            { transcript: true },
+          );
+        }
 
         flushToolResults(session?.messages || [], toolCards, cardByCallId, toolGroups, resultsDone, { finalize: true });
         finalizeToolHeaders();
@@ -1208,7 +1229,8 @@ export function createRunTurn(bag) {
           }
         }
         const producedTranscriptItem =
-          getState().items.length + closingItems.length > itemsAtTurnStart;
+          transcriptCompactedThisTurn
+          || getState().items.length + closingItems.length > itemsAtTurnStart;
         const reclaimed = cancelled && flags.activePromptRestore?.reclaimed === true;
         flags.activePromptRestore = null;
         const elapsedMs = Date.now() - startedAt;

package/src/tui/engine.mjs

@@ -738,7 +738,6 @@ export async function createEngineSession({
     autoClearState, agentStatusState, baseRouteState, routeState, syncContextStats,
     presentNextToolApproval, finishToolApproval, denyAllToolApprovals, requestToolApproval,
     patchToolCardResult, flushToolResults,
-    clearExecutionDedupState,
     kickExecutionPendingResume, flushDeferredExecutionPendingResumeKick, scheduleExecutionPendingResumeKick, discardExecutionPendingResume, updateAgentJobCard, subscribeRuntimeNotifications,
   });
   Object.assign(bag, createSessionFlow(bag));

package/src/tui/index.jsx

@@ -15,6 +15,7 @@ import { App } from './App.jsx';
 import { createEngineSession } from './engine.mjs';
 import { scheduleRenderFrameAck } from './engine/render-timing.mjs';
 import { installProcessSignalCleanup } from '../runtime/shared/process-shutdown.mjs';
+import { rgbSgr } from '../ui/ansi.mjs';
 import { emitTerminalBackground, loadThemeSettingFromConfig, theme } from './theme.mjs';
 import { POP_KITTY, DISABLE_MODIFY_OTHER_KEYS } from './keyboard-protocol.mjs';
 import { displayWidth } from './display-width.mjs';
@@ -259,10 +260,10 @@ function resolveTuiStderrLogPath() {
     || join(process.env.MIXDOG_RUNTIME_ROOT || join(tmpdir(), 'mixdog'), 'mixdog-tui.stderr.log');
 }
 
-/** `rgb(r,g,b)` → truecolor SGR prefix ('' when unparsable). */
+/** `rgb(r,g,b)` → supported RGB SGR prefix ('' when unparsable). */
 function ansiFg(rgb) {
   const m = /rgb\((\d+),\s*(\d+),\s*(\d+)\)/.exec(String(rgb || ''));
-  return m ? `\x1b[38;2;${m[1]};${m[2]};${m[3]}m` : '';
+  return m ? rgbSgr(m[1], m[2], m[3]) : '';
 }
 
 /**

package/src/tui/markdown/streaming-markdown.mjs

@@ -7,6 +7,8 @@ import { configureMarked, hasMarkdownSyntax } from './render-ansi.mjs';
 import { trimPartialClosingFences, findOpenFenceStart } from './stream-fence.mjs';
 
 const stablePrefixByStreamKey = new Map();
+// Reuse the current normalized-text split across measure → render → harvest.
+const resolvedPartsByStreamKey = new Map();
 const STABLE_PREFIX_LRU_MAX = 32;
 
 /** Lockstep with App streaming row estimate (leading/trailing newline trim). */
@@ -37,6 +39,25 @@ function getStablePrefixKey(key) {
   return value;
 }
 
+function getResolvedPartsKey(key, text) {
+  if (!key) return null;
+  const entry = resolvedPartsByStreamKey.get(key);
+  if (!entry || entry.text !== text) return null;
+  return entry.parts;
+}
+
+function cacheResolvedPartsKey(key, text, parts) {
+  if (!key) return parts;
+  if (resolvedPartsByStreamKey.has(key)) resolvedPartsByStreamKey.delete(key);
+  resolvedPartsByStreamKey.set(key, { text, parts });
+  while (resolvedPartsByStreamKey.size > STABLE_PREFIX_LRU_MAX) {
+    const oldest = resolvedPartsByStreamKey.keys().next().value;
+    if (oldest === undefined) break;
+    resolvedPartsByStreamKey.delete(oldest);
+  }
+  return parts;
+}
+
 function hasOpenFence(text) {
   let ticks = 0;
   let tildes = 0;
@@ -93,35 +114,40 @@ export function balanceStreamingMarkdown(text) {
 
 export function resetStreamingMarkdownStablePrefix(streamKey) {
   if (streamKey == null || streamKey === '') return;
-  stablePrefixByStreamKey.delete(String(streamKey));
+  const key = String(streamKey);
+  stablePrefixByStreamKey.delete(key);
+  resolvedPartsByStreamKey.delete(key);
 }
 
 export function resetAllStreamingMarkdownStablePrefixes() {
   stablePrefixByStreamKey.clear();
+  resolvedPartsByStreamKey.clear();
 }
 
 export function resolveStreamingMarkdownParts(text, streamKey) {
   const t = streamingLayoutText(text);
   const key = streamKey == null || streamKey === '' ? null : String(streamKey);
+  const cachedParts = getResolvedPartsKey(key, t);
+  if (cachedParts) return cachedParts;
 
   if (!t) {
     if (key) stablePrefixByStreamKey.delete(key);
-    return {
+    return cacheResolvedPartsKey(key, t, {
       plain: true,
       stablePrefix: '',
       unstableSuffix: '',
       unstableForRender: '',
-    };
+    });
   }
 
   if (!hasMarkdownSyntax(t)) {
     if (key) stablePrefixByStreamKey.delete(key);
-    return {
+    return cacheResolvedPartsKey(key, t, {
       plain: true,
       stablePrefix: '',
       unstableSuffix: t,
       unstableForRender: t,
-    };
+    });
   }
 
   let stablePrefix = key ? getStablePrefixKey(key) : '';
@@ -141,13 +167,13 @@ export function resolveStreamingMarkdownParts(text, streamKey) {
     if (key && openPrefix) touchStablePrefixKey(key, openPrefix);
     else if (key) stablePrefixByStreamKey.delete(key);
     const unstableSuffix = t.substring(openPrefix.length);
-    return {
+    return cacheResolvedPartsKey(key, t, {
       plain: false,
       openFence: true,
       stablePrefix: openPrefix,
       unstableSuffix,
       unstableForRender: unstableSuffix,
-    };
+    });
   }
 
   try {
@@ -179,10 +205,10 @@ export function resolveStreamingMarkdownParts(text, streamKey) {
   if (isWhitespaceOnlyText(stablePrefix)) stablePrefix = '';
 
   const unstableSuffix = t.substring(stablePrefix.length);
-  return {
+  return cacheResolvedPartsKey(key, t, {
     plain: false,
     stablePrefix,
     unstableSuffix,
     unstableForRender: balanceStreamingMarkdown(unstableSuffix),
-  };
+  });
 }

package/src/tui/statusline-ansi-bridge.mjs

@@ -6,6 +6,8 @@
  * normalizes that at display time so `/theme` can re-tone without touching ui/.
  */
 
+import { rgbToAnsi256 } from '../ui/ansi.mjs';
+
 const RESET = '\x1b[0m';
 
 /** Truecolor SGR sequences emitted by the shared statusline stack (not theme). */
@@ -23,6 +25,14 @@ function truecolorSgr(r, g, b) {
   return `\x1b[38;2;${r};${g};${b}m`;
 }
 
+function ansi256Sgr(r, g, b) {
+  return `\x1b[38;5;${rgbToAnsi256(r, g, b)}m`;
+}
+
+function canonicalSgrVariants(rgb) {
+  return [truecolorSgr(...rgb), ansi256Sgr(...rgb)];
+}
+
 function footerLocalNum(value) {
   const n = Number(value);
   return Number.isFinite(n) ? n : 0;
@@ -139,13 +149,13 @@ export function applyDefaultStatusForegroundAfterReset(text, STATUS, reset = RES
 export function remapCanonicalStatuslineTruecolor(text, colors) {
   const c = STATUSLINE_CANONICAL_TRUECOLOR;
   const pairs = [
-    [truecolorSgr(...c.statusText), colors.STATUS],
-    [truecolorSgr(...c.subtle), colors.SUBTLE],
-    [truecolorSgr(...c.success), colors.SUCCESS],
-    [truecolorSgr(...c.successBright), colors.SUCCESS],
-    [truecolorSgr(...c.warning), colors.WARNING],
-    [truecolorSgr(...c.warningBright), colors.WARNING],
-    [truecolorSgr(...c.error), colors.ERROR],
+    ...canonicalSgrVariants(c.statusText).map((from) => [from, colors.STATUS]),
+    ...canonicalSgrVariants(c.subtle).map((from) => [from, colors.SUBTLE]),
+    ...canonicalSgrVariants(c.success).map((from) => [from, colors.SUCCESS]),
+    ...canonicalSgrVariants(c.successBright).map((from) => [from, colors.SUCCESS]),
+    ...canonicalSgrVariants(c.warning).map((from) => [from, colors.WARNING]),
+    ...canonicalSgrVariants(c.warningBright).map((from) => [from, colors.WARNING]),
+    ...canonicalSgrVariants(c.error).map((from) => [from, colors.ERROR]),
   ];
   let out = String(text || '');
   for (const [from, to] of pairs) {

package/src/ui/ansi.mjs

@@ -12,7 +12,7 @@
  * The decision is computed once at import time but can be recomputed via
  * `refreshColorSupport()` (used by tests / when output is rebound).
  */
-import { stdout, env } from 'node:process';
+import { stdout, env, platform } from 'node:process';
 
 let COLOR_ENABLED = computeColorEnabled();
 
@@ -39,12 +39,92 @@ export function colorEnabled() {
 const ESC = '\x1b[';
 const RESET = `${ESC}0m`;
 
+/**
+ * Whether the terminal can render 24-bit SGR colors.
+ *
+ * Apple Terminal is the one explicit negative because it advertises a normal
+ * xterm TERM while not implementing truecolor. Unknown terminals retain the
+ * historical truecolor default.
+ */
+export function supportsTruecolor(environment = env, platformName = platform) {
+  const termProgram = String(environment?.TERM_PROGRAM || '').trim().toLowerCase();
+  if (termProgram === 'apple_terminal') return false;
+
+  const colorTerm = String(environment?.COLORTERM || '').trim().toLowerCase();
+  if (colorTerm === 'truecolor' || colorTerm === '24bit') return true;
+  if (environment?.WT_SESSION !== undefined && environment.WT_SESSION !== '') return true;
+  if (['iterm.app', 'wezterm', 'ghostty', 'vscode'].includes(termProgram)) return true;
+  if (/(?:direct|truecolor)/i.test(String(environment?.TERM || ''))) return true;
+  if (platformName === 'win32') return true;
+  return true;
+}
+
+const ANSI_256_CUBE_LEVELS = Object.freeze([0, 95, 135, 175, 215, 255]);
+
+function colorByte(value) {
+  const n = Number(value);
+  return Number.isFinite(n) ? Math.max(0, Math.min(255, Math.round(n))) : 0;
+}
+
+function nearestCubeLevel(value) {
+  let best = 0;
+  let bestDistance = Infinity;
+  for (let i = 0; i < ANSI_256_CUBE_LEVELS.length; i++) {
+    const distance = Math.abs(value - ANSI_256_CUBE_LEVELS[i]);
+    if (distance < bestDistance) {
+      best = i;
+      bestDistance = distance;
+    }
+  }
+  return best;
+}
+
+/** Convert an RGB triplet to the nearest stable xterm 256-color palette index. */
+export function rgbToAnsi256(r, g, b) {
+  const red = colorByte(r);
+  const green = colorByte(g);
+  const blue = colorByte(b);
+
+  const redLevel = nearestCubeLevel(red);
+  const greenLevel = nearestCubeLevel(green);
+  const blueLevel = nearestCubeLevel(blue);
+  const cubeRed = ANSI_256_CUBE_LEVELS[redLevel];
+  const cubeGreen = ANSI_256_CUBE_LEVELS[greenLevel];
+  const cubeBlue = ANSI_256_CUBE_LEVELS[blueLevel];
+  const cubeDistance = ((red - cubeRed) ** 2)
+    + ((green - cubeGreen) ** 2)
+    + ((blue - cubeBlue) ** 2);
+
+  const average = (red + green + blue) / 3;
+  const grayLevel = Math.max(0, Math.min(23, Math.round((average - 8) / 10)));
+  const grayValue = 8 + (grayLevel * 10);
+  const grayDistance = ((red - grayValue) ** 2)
+    + ((green - grayValue) ** 2)
+    + ((blue - grayValue) ** 2);
+
+  if (grayDistance < cubeDistance) return 232 + grayLevel;
+  return 16 + (36 * redLevel) + (6 * greenLevel) + blueLevel;
+}
+
+/** Raw RGB SGR prefix, downsampled to 256 colors when truecolor is unavailable. */
+export function rgbSgr(r, g, b, background = false) {
+  const channel = background ? 48 : 38;
+  if (supportsTruecolor()) return `${ESC}${channel};2;${r};${g};${b}m`;
+  return `${ESC}${channel};5;${rgbToAnsi256(r, g, b)}m`;
+}
+
+function supportedSgrOpen(open) {
+  const match = /^(38|48);2;([^;]+);([^;]+);([^;]+)$/.exec(String(open));
+  if (!match || supportsTruecolor()) return open;
+  return `${match[1]};5;${rgbToAnsi256(match[2], match[3], match[4])}`;
+}
+
 /** Build a `(text) => string` wrapper for the given SGR open code(s). */
 function sgr(open) {
-  const openSeq = `${ESC}${open}m`;
   return (text) => {
     if (!COLOR_ENABLED) return String(text ?? '');
     const s = String(text ?? '');
+    const openSeq = `${ESC}${supportedSgrOpen(open)}m`;
     // Re-open after any nested reset so composed styles survive concatenation.
     return openSeq + s.replace(/\x1b\[0m/g, RESET + openSeq) + RESET;
   };
@@ -84,9 +164,9 @@ export const bgGray = sgr('100');
 export const bgBlack = sgr('40');
 export const bgBlue = sgr('44');
 
-// --- Truecolor (24-bit) -----------------------------------------------------
-// The TUI palette uses explicit rgb() values. 16-color SGR can't reproduce them, so we emit
-// 24-bit SGR. Honors NO_COLOR / TTY exactly like the named helpers above.
+// --- RGB colors --------------------------------------------------------------
+// Emit 24-bit SGR where supported, otherwise use the nearest 256-color entry.
+// Honors NO_COLOR / TTY exactly like the named helpers above.
 
 /** Foreground truecolor wrapper: `rgb(215,119,87)('x')`. */
 export function rgb(r, g, b) {

package/src/ui/statusline-agents.mjs

@@ -14,14 +14,6 @@ import { num, GRN, R, B } from './statusline-format.mjs';
 const DEFAULT_HIDDEN_STATUSLINE_AGENTS = Object.freeze(['explorer', 'cycle1-agent', 'cycle2-agent', 'cycle3-agent', 'scheduler-task', 'webhook-handler']);
 let _hiddenStatuslineAgents = null;
 
-export function summarizeWorkerTags(workers, limit = 3) {
-  const cleanLabels = [...new Set((Array.isArray(workers) ? workers : [])
-    .map((worker) => String(worker?.tag || '').trim())
-    .filter(Boolean))];
-  if (cleanLabels.length <= limit) return cleanLabels.join(', ');
-  return `${cleanLabels.slice(0, limit).join(', ')}, +${cleanLabels.length - limit}`;
-}
-
 function normalizeAgentWorkerForStatusline(worker = {}) {
   const tag = String(worker.tag || worker.agent || worker.name || '').trim();
   if (!tag) return null;

package/src/ui/statusline-format.mjs

@@ -5,7 +5,7 @@
  * bar/segment formatters, small numeric helpers, and the TUI-independent
  * formatElapsed() replica. No behavior change — statusline.mjs re-imports these.
  */
-import { colorEnabled, rgb } from './ansi.mjs';
+import { colorEnabled, rgb, rgbSgr } from './ansi.mjs';
 import { displayModelName, shortenModelName } from './model-display.mjs';
 import { getModelMetadataSync } from '../runtime/agent/orchestrator/providers/model-catalog.mjs';
 
@@ -23,12 +23,12 @@ function sgr(code) {
 
 export const R = sgr('0');
 export const B = sgr('1');
-export const D = sgr('38;2;136;136;136');
-export const GRN = sgr('38;2;0;170;75');
-export const YLW = sgr('38;2;255;193;7');
-export const RED = sgr('38;2;220;70;88');
-export const CYN = sgr('38;2;136;136;136');
-export const GREY = sgr('38;2;136;136;136');
+export const D = colorEnabled() ? rgbSgr(136, 136, 136) : '';
+export const GRN = colorEnabled() ? rgbSgr(0, 170, 75) : '';
+export const YLW = colorEnabled() ? rgbSgr(255, 193, 7) : '';
+export const RED = colorEnabled() ? rgbSgr(220, 70, 88) : '';
+export const CYN = colorEnabled() ? rgbSgr(136, 136, 136) : '';
+export const GREY = colorEnabled() ? rgbSgr(136, 136, 136) : '';
 
 export function terminalColumns() {
   const cols = Number(process.stdout?.columns);

package/src/ui/statusline.mjs

@@ -23,7 +23,7 @@ import {
 } from './statusline-format.mjs';
 import { shellJobsStatus, memoryCycleStatus } from './statusline-segments.mjs';
 import {
-  summarizeWorkerTags, agentStatuslinePayload, classifyAgentWorkers, activeHiddenAgentWorkers, agentWebSearchStatus,
+  agentStatuslinePayload, classifyAgentWorkers, activeHiddenAgentWorkers, agentWebSearchStatus,
 } from './statusline-agents.mjs';
 export { createSessionStats, applyUsageDelta } from './session-stats.mjs';
 // Facade re-exports: keep these public symbols resolving from statusline.mjs.
@@ -362,14 +362,12 @@ function renderNativeStatusline({
   if (runningWorkers.length) {
     const n = runningWorkers.length;
     const label = `Running ${n} Agent${n === 1 ? '' : 's'}`;
-    const tagSummary = summarizeWorkerTags(runningWorkers);
-    const tags = tagSummary ? ` ${D}(${R}${B}${tagSummary}${R}${D})${R}` : '';
     const oldestStart = runningWorkers.reduce((min, w) => {
       const t = num(w?.startedAtMs);
       return t > 0 && t < min ? t : min;
     }, Infinity);
     const elapsed = Number.isFinite(oldestStart) ? formatElapsed(Date.now() - oldestStart) : '';
-    addL2(`${spin} ${B}${label}${R}${tags}${elapsedSuffix(elapsed)}`);
+    addL2(`${spin} ${B}${label}${R}${elapsedSuffix(elapsed)}`);
   }
   const tools = activeTools && typeof activeTools === 'object' ? activeTools : {};
   const exploreInfo = tools.explore || null;

package/src/workflows/default/WORKFLOW.md

@@ -13,15 +13,20 @@ Approval is a later explicit user message after the latest plan ("do it",
 approval with a scope change needs a revised plan and fresh approval. Before
 approval: no edits, state mutation, or delegation.
 
-Lead orchestrates and verifies. Lead-direct work is allowed only for pure
-read/analysis, git/configuration, or when the user explicitly supplies both the
-exact target and exact replacement/output. Never infer an exemption from a task
-name, file count, or perceived difficulty. Every other implementation, reverse
-engineering, debugging application, or artifact generation delegates to the
-matching agent. Debugger owns diagnosis and reverse engineering; Worker applies
-an established bounded change or fully specified artifact; Heavy Worker owns
-implementation that must establish the change through investigation or staged
-delivery. Applying a Debugger result is implementation, not diagnosis.
+Lead owns three duties, in order: plan — set the direction of the work from its own
+understanding of the task; delegate — hand execution to the matching agent; verify —
+judge what comes back. Understanding is never delegated: without its own plan a Lead
+can neither brief nor judge. Lead-direct work is allowed only for pure read/analysis,
+git/configuration, or when the user explicitly supplies both the exact target and exact
+replacement/output. Never infer an exemption from a task name, file count, or
+perceived difficulty. Every other implementation, reverse engineering, debugging
+application, or artifact generation delegates to the matching agent. Debugger is an
+escalation role reserved for explicitly requested debugging or a bug surviving 2+ fix
+cycles — not a default owner of analysis or reverse engineering, which route to
+Worker/Heavy Worker like any implementation. Worker applies an established bounded
+change or fully specified artifact; Heavy Worker owns implementation that must establish
+the change through investigation or staged delivery. Applying a Debugger result is
+implementation, not diagnosis.
 
 1. Plan: draft before any implementation; settle scope/plan, ask if ambiguous,
    then await the gate.
@@ -29,22 +34,26 @@ delivery. Applying a Debugger result is implementation, not diagnosis.
    one turn, with no count cap. Serialize only a real dependency, overlapping
    write, or inseparable coupling. Briefs follow the Lead brief contract.
    After async spawn, end the turn.
-3. Review: review is exempt only for pure read/analysis with no edit, artifact,
-   or state mutation; git/configuration; or a request where the user explicitly
-   supplies both the exact target and exact replacement/output. Every
-   non-exempt mutation or artifact, whether produced or applied by Worker,
-   Heavy Worker, Debugger, or Lead, gets one Reviewer (all ready reviewers in
-   one turn) and Lead
-   integration/cross-scope verification in parallel. Debugger analysis cannot
-   substitute for implementation review: applying a Debugger result triggers
+3. Review: triage by the work performed, never by the size, form, or destination
+   of its result — a one-line answer can carry non-trivial work, and a
+   conversational reply is not automatically exempt. Trivial work — a routine
+   lookup answered directly, routine git/configuration confirmed by its own
+   mechanical check, a change whose correctness is test/build/diff-obvious, or
+   applying an exact target and replacement the user supplied — ships on shell
+   self-verification alone, and only after that check actually ran and passed.
+   Non-trivial work — multi-step reasoning, interpretation, investigation, or
+   anything whose correctness is not verifiable at a glance — gets a Reviewer
+   cross-check (one reviewer per scope, kept across the fix loop; all ready
+   reviewers spawn in one turn) and Lead integration/cross-scope verification
+   in parallel, whoever performed it, Lead solo included. Debugger analysis
+   cannot substitute for implementation review: applying a Debugger result triggers
    the same Reviewer + Lead verification. Reviewer independently judges risk,
    intent, boundaries; Lead checks acceptance/interactions, not duplicate
    same-scope work. High-risk scopes add distinct lenses. Synthesize one
    verdict; send merged fixes to the original live session; loop fix ->
    re-verify (same Reviewer + Lead re-check) until clean. Debugger first for
-   requested debugging or a bug surviving 2+ fix cycles. Exempt mutations still
-   require shell self-verification before report. Agent reports relay scope,
-   verdict, next work as in-progress, never conclusions.
+   requested debugging or a bug surviving 2+ fix cycles. Agent reports relay
+   scope, verdict, next work as in-progress, never conclusions.
 4. Report: final (not interim) report compares work to approved plan and gives
    verified result; never forward raw agent output. Ask about ship/deploy when
    relevant. Build/deploy/commit/push require an explicit user request after

package/src/workflows/solo-review/WORKFLOW.md

@@ -0,0 +1,47 @@
+---
+id: solo-review
+name: Solo Review
+description: "Lead implements directly; eligible low-risk single scopes receive one independent Reviewer."
+agents: reviewer
+---
+
+# Solo Review
+
+GATE: Before approval, only read-only investigation/planning while consulting.
+Approval is a later explicit user message after the latest plan ("do it",
+"proceed", "go ahead"). Initial/additional/changed requests reset planning;
+approval with a scope change needs a revised plan and fresh approval. Before
+approval: no edits, state mutation, or delegation.
+
+1. Plan: before implementation, Lead classifies the scope as eligible
+   low-risk/single-scope or ineligible high-risk/multi-scope, drafts the plan,
+   settles scope, asks if ambiguous, then awaits the gate. Ineligible work must
+   switch to Default workflow with a revised Default plan and fresh approval
+   before implementation. After that switch, Solo Review constraints are
+   suspended: Default reviewer-per-scope fan-out and high-risk lenses override
+   Solo Review's single-Reviewer and concurrency limits.
+2. Execute: after approval, Lead performs all implementation and verification
+   directly. Never delegate implementation, investigation, debugging, or
+   maintenance to implementation helper roles (Worker, Heavy Worker, Explorer,
+   Debugger, or Maintainer). Complete in-scope fixes without reapproval; interim
+   updates are in-progress, never conclusions.
+3. Review: only an eligible low-risk, single-scope final deliverable, once
+   implemented and Lead-verified, receives exactly one Reviewer to critically
+   and independently evaluate the approved intent, complete deliverable,
+   affected boundaries, and verification. Lead evaluates the findings, applies
+   every necessary fix directly, and re-verifies. Send the revised deliverable
+   back to that same live Reviewer for every re-check. If that session is
+   unavailable, one cold replacement Reviewer may re-review the original intent,
+   current deliverable, and verification evidence; never run replacement or
+   additional Reviewers concurrently. Repeat fix -> Lead verification -> Reviewer
+   re-check until issue-free or blocked.
+4. Report: only after the review loop is clean, the final (not interim) report
+   compares the result to the approved plan and gives verification and material
+   remaining risk/next step; never forward raw Reviewer output. Ask about
+   ship/deploy when relevant. Verification builds/tests needed to evaluate the
+   deliverable are permitted during execution and review. Release builds,
+   deploy/commit/push require an explicit user request after issue-free feedback;
+   implementation approval alone is insufficient.
+
+On outcome/direction change, pause and re-consult; otherwise continue approved
+work without reapproval.