mixdog 0.9.1 → 0.9.3

package/src/tui/transcript-tool-failures.mjs

@@ -5,8 +5,15 @@
 
 import { parseToolArgs } from '../runtime/shared/tool-surface.mjs';
 
-const HOOK_DENIAL_RE = /denied by hook/i;
-const APPROVAL_UNAVAILABLE_RE = /approval required but no approval UI is available/i;
+// Anchor to the orchestrator's actual denial envelope:
+//   `Error: tool "<name>" denied by hook[: ...]`
+//   `Error: tool "<name>" denied by hook: approval required but no approval UI is available`
+// Matching the bare phrase anywhere in the body produced FALSE POSITIVES when a
+// normal (successful) tool result merely CONTAINED the text — e.g. a read/grep
+// over this very file or the hook source. The denial is always an Error
+// envelope emitted at the START of the result, so anchor on that prefix.
+const HOOK_DENIAL_RE = /^Error:\s*tool\s*"[^"]*"\s*denied by hook\b/im;
+const APPROVAL_UNAVAILABLE_RE = /denied by hook:\s*approval required but no approval UI is available/i;
 
 export function toolItemResultText(item) {
   if (!item) return '';
@@ -26,6 +33,10 @@ export function isHookApprovalDenialToolResult(text) {
 
 export function isHookApprovalDenialToolItem(item) {
   if (!item || item.kind !== 'tool') return false;
+  // A genuine hook denial is always surfaced as an ERROR result. Gating on
+  // isError stops a successful result whose body happens to contain the denial
+  // phrase (e.g. reading the hook source) from rendering a phantom "Denied".
+  if (!item.isError) return false;
   return isHookApprovalDenialToolResult(toolItemResultText(item));
 }
 

package/src/ui/markdown.mjs

@@ -137,7 +137,7 @@ function renderLine(line, width) {
   // Blockquote (possibly nested).
   const q = /^(\s*>+)\s?(.*)$/.exec(line);
   if (q) {
-    return dim(PALETTE.quoteText('│ ')) + italic(PALETTE.quoteText(renderInline(q[2])));
+    return dim('│ ') + italic(renderInline(q[2]));
   }
 
   // Bullet list.

package/src/ui/model-display.mjs

@@ -74,13 +74,13 @@ export function canonicalModelDisplay(model, provider) {
     return `Grok ${grok[1].split('-').map(titleModelPart).filter(Boolean).join(' ')}`;
   }
 
-  const claudeLegacy = raw.match(/^claude-(\d+)(?:-(\d+))?-(opus|sonnet|haiku)(?:-|$)/i);
+  const claudeLegacy = raw.match(/^claude-(\d+)(?:-(\d+))?-(opus|sonnet|haiku|fable)(?:-|$)/i);
   if (claudeLegacy) {
     const version = `${claudeLegacy[1]}${claudeLegacy[2] ? `.${claudeLegacy[2]}` : ''}`;
     return `Claude ${titleModelPart(claudeLegacy[3])} ${version}`;
   }
 
-  const claude = raw.match(/^claude-(opus|sonnet|haiku)-(.+)$/i);
+  const claude = raw.match(/^claude-(opus|sonnet|haiku|fable)-(.+)$/i);
   if (claude) {
     return `Claude ${titleModelPart(claude[1])} ${claude[2].replace(/-/g, '.')}`;
   }

package/src/ui/statusline.mjs

@@ -16,7 +16,7 @@ import { bold, colorEnabled, rgb } from './ansi.mjs';
 import { displayModelName, shortenModelName } from './model-display.mjs';
 import { createSessionStats } from './session-stats.mjs';
 import { forEachSessionRuntime } from '../runtime/agent/orchestrator/session/manager.mjs';
-import { listHiddenRoleNames } from '../runtime/agent/orchestrator/internal-roles.mjs';
+import { listHiddenAgentNames } from '../runtime/agent/orchestrator/internal-agents.mjs';
 import { getModelMetadataSync } from '../runtime/agent/orchestrator/providers/model-catalog.mjs';
 import { readCachedOAuthUsageSnapshot } from '../runtime/agent/orchestrator/providers/oauth-usage.mjs';
 import { readCachedOpenCodeGoUsageSnapshot } from '../runtime/agent/orchestrator/providers/opencode-go-usage.mjs';
@@ -61,11 +61,11 @@ const L2_SPINNER_FRAME_MS = 120;
 // replaces them. Snapshots from a previous launch stay hidden during boot so the
 // statusline starts empty until the current session captures usage once.
 const STATUSLINE_PROCESS_STARTED_AT_MS = Date.now() - Math.floor((Number(process.uptime?.()) || 0) * 1000);
-const DEFAULT_HIDDEN_STATUSLINE_ROLES = Object.freeze(['explorer', 'cycle1-agent', 'cycle2-agent', 'cycle3-agent', 'scheduler-task', 'webhook-handler']);
+const DEFAULT_HIDDEN_STATUSLINE_AGENTS = Object.freeze(['explorer', 'cycle1-agent', 'cycle2-agent', 'cycle3-agent', 'scheduler-task', 'webhook-handler']);
 let _shellJobsSegmentCache = { ownerPid: 0, at: 0, value: { count: 0, elapsedLabel: '' } };
 let _gatewayQuotaStatusCache = { key: '', at: 0, value: null };
 let _fallbackQuotaStatusCache = { key: '', at: 0, value: null };
-let _hiddenStatuslineRoles = null;
+let _hiddenStatuslineAgents = null;
 // Option A boot gate: the L1 usage/quota segment stays fully empty until THIS
 // process has captured its FIRST confirmed (current-process) OAuth usage
 // snapshot for THAT provider. The latch is monotonic PER PROVIDER — once a
@@ -211,7 +211,7 @@ function resolveContextUsedPct({
 }
 
 function normalizeAgentWorkerForStatusline(worker = {}) {
-  const tag = String(worker.tag || worker.role || worker.name || '').trim();
+  const tag = String(worker.tag || worker.agent || worker.name || '').trim();
   if (!tag) return null;
   const statusText = String(worker.stage || worker.status || '').toLowerCase();
   const status = isTerminalBridgeStatus(statusText) ? 'idle' : 'running';
@@ -219,7 +219,7 @@ function normalizeAgentWorkerForStatusline(worker = {}) {
     tag,
     status,
     startedAtMs: timeMs(worker.startedAt || worker.startTime || worker.createdAt),
-    role: worker.role || null,
+    agent: worker.agent || null,
     stage: worker.stage || worker.status || null,
     sessionId: worker.sessionId || null,
     provider: worker.provider || null,
@@ -231,7 +231,7 @@ function normalizeAgentJobForStatusline(job = {}) {
   const statusText = String(job.status || job.stage || '').toLowerCase();
   if (!statusText) return null;
   const taskId = String(job.task_id || job.taskId || '').trim();
-  const tag = String(job.tag || job.role || job.type || taskId || '').trim();
+  const tag = String(job.tag || job.agent || job.type || taskId || '').trim();
   if (!tag && !taskId) return null;
   const startedAtMs = timeMs(job.startedAt);
   const finishedAtMs = timeMs(job.finishedAt);
@@ -243,7 +243,7 @@ function normalizeAgentJobForStatusline(job = {}) {
       finalStatus: statusText,
       startedAtMs,
       finishedAtMs,
-      role: job.role || null,
+      agent: job.agent || null,
       stage: job.stage || job.workerStatus || job.status || null,
       sessionId: job.sessionId || null,
       provider: job.provider || null,
@@ -256,7 +256,7 @@ function normalizeAgentJobForStatusline(job = {}) {
     taskId,
     status: 'running',
     startedAtMs,
-    role: job.role || null,
+    agent: job.agent || null,
     stage: job.stage || job.workerStatus || job.status || null,
     sessionId: job.sessionId || null,
     provider: job.provider || null,
@@ -387,10 +387,9 @@ function renderNativeStatusline({
 
   const agentPayload = agentStatuslinePayload([
     ...(Array.isArray(agentWorkers) ? agentWorkers : []),
-    ...activeHiddenRoleWorkers({ sessionId, clientHostPid }),
+    ...activeHiddenAgentWorkers({ sessionId, clientHostPid }),
   ], agentJobs);
-  const { maintenance, runningWorkers } = classifyAgentWorkers(agentPayload.workers);
-  if (maintenance.length) addL1(maintenance.join(' '));
+  const { runningWorkers } = classifyAgentWorkers(agentPayload.workers);
   const shellStatus = shellJobsStatus({ clientHostPid });
 
   const spinnerNow = Date.now();
@@ -426,6 +425,16 @@ function renderNativeStatusline({
     const label = `Running ${n} Shell${n === 1 ? '' : 's'}`;
     addL2(`${spin} ${B}${label}${R}${elapsedSuffix(shellStatus.elapsedLabel)}`);
   }
+  // Memory cycle segment — single unified "Memory" wording for all states:
+  // running -> "⠋ Memory · 12s"; backlog warning -> "⠋ Memory · backlog 512"
+  // (yellow). Nothing when idle (no L2 pollution).
+  const memStatus = memoryCycleStatus();
+  if (memStatus?.kind === 'running') {
+    const elapsed = formatElapsed(Date.now() - memStatus.startedAt);
+    addL2(`${spin} ${B}Memory${R}${elapsedSuffix(elapsed)}`);
+  } else if (memStatus?.kind === 'backlog') {
+    addL2(`${spin} ${B}Memory${R} ${D}·${R} ${YLW}backlog ${memStatus.pending}${R}`);
+  }
   const l1 = l1Parts.join(sep) || 'mixdog';
   const l2 = l2Parts.join(sep);
   return l2 ? `${l1}\n${l2}` : l1;
@@ -688,30 +697,30 @@ function classifyAgentWorkers(workers = []) {
 }
 
 function hiddenWorkerLabel(worker = {}) {
-  const role = String(worker?.role || '').trim();
+  const agent = String(worker?.agent || '').trim();
   const tag = String(worker?.tag || '').trim();
-  return maintenanceLabel(role) || (!role ? maintenanceLabel(tag) : '');
+  return maintenanceLabel(agent) || (!agent ? maintenanceLabel(tag) : '');
 }
 
-function hiddenStatuslineRoles() {
-  if (_hiddenStatuslineRoles) return _hiddenStatuslineRoles;
-  const roles = new Set(DEFAULT_HIDDEN_STATUSLINE_ROLES);
+function hiddenStatuslineAgents() {
+  if (_hiddenStatuslineAgents) return _hiddenStatuslineAgents;
+  const agents = new Set(DEFAULT_HIDDEN_STATUSLINE_AGENTS);
   try {
-    for (const role of listHiddenRoleNames()) {
-      const clean = String(role || '').trim();
-      if (clean) roles.add(clean);
+    for (const agent of listHiddenAgentNames()) {
+      const clean = String(agent || '').trim();
+      if (clean) agents.add(clean);
     }
   } catch {}
-  _hiddenStatuslineRoles = roles;
-  return roles;
+  _hiddenStatuslineAgents = agents;
+  return agents;
 }
 
 function isActiveHiddenStatus(statusText) {
   return /^(connecting|requesting|streaming|tool_running|running)$/i.test(String(statusText || '').trim());
 }
 
-function activeHiddenRoleWorkers({ sessionId = '', clientHostPid = 0 } = {}) {
-  const roles = hiddenStatuslineRoles();
+function activeHiddenAgentWorkers({ sessionId = '', clientHostPid = 0 } = {}) {
+  const agents = hiddenStatuslineAgents();
   const ownerPid = positiveInt(clientHostPid);
   const ownerSessionId = String(sessionId || '').trim();
   const rows = [];
@@ -720,8 +729,8 @@ function activeHiddenRoleWorkers({ sessionId = '', clientHostPid = 0 } = {}) {
       if (!entry || entry.closed === true) continue;
       const session = entry.session || null;
       if (!session || session.closed === true) continue;
-      const role = String(session?.role || '').trim();
-      if (!role || !roles.has(role)) continue;
+      const agent = String(session?.agent || '').trim();
+      if (!agent || !agents.has(agent)) continue;
       const id = session?.id || runtimeSessionId || null;
       if (ownerSessionId && id === ownerSessionId) continue;
       const sessionOwnerId = String(session?.ownerSessionId || '').trim();
@@ -732,8 +741,8 @@ function activeHiddenRoleWorkers({ sessionId = '', clientHostPid = 0 } = {}) {
       const status = String(session?.status || stage || '').trim().toLowerCase();
       if (!isActiveHiddenStatus(stage || status)) continue;
       rows.push({
-        tag: String(session?.agentTag || `${role}:${id || rows.length}`).trim(),
-        role,
+        tag: String(session?.agentTag || `${agent}:${id || rows.length}`).trim(),
+        agent,
         status: 'running',
         stage: stage || status || 'running',
         sessionId: id,
@@ -768,6 +777,45 @@ function maintenanceLabel(tag) {
 }
 
 function shellJobsStatus({ clientHostPid } = {}) {
+  return _shellJobsStatusImpl({ clientHostPid });
+}
+
+// Memory cycle L2 segment source. The memory daemon writes
+// data/memory-cycle-state.json on every cycle start/finish (index.mjs
+// _writeCycleStateFile) — no HTTP call from the statusline path. Cached at
+// the same 1s cadence as the shell segment. Shows a single unified "Memory"
+// segment: running (spinner + elapsed) or backlog warning (yellow count).
+let _memoryCycleSegmentCache = { at: 0, value: null };
+const MEMORY_CYCLE_SEGMENT_CACHE_MS = 1000;
+const MEMORY_CYCLE_BACKLOG_WARN = 500;
+function memoryCycleStatus() {
+  const now = Date.now();
+  if (now - _memoryCycleSegmentCache.at < MEMORY_CYCLE_SEGMENT_CACHE_MS) {
+    return _memoryCycleSegmentCache.value;
+  }
+  let value = null;
+  try {
+    const p = join(dataDir(), 'memory-cycle-state.json');
+    if (existsSync(p)) {
+      const state = JSON.parse(readFileSync(p, 'utf-8'));
+      const running = state?.running || null;
+      const backlog = state?.backlog || {};
+      // Stale-file guard: a daemon that died mid-run leaves running set —
+      // ignore anything not refreshed in the last 10 minutes.
+      const fresh = Number(state?.updatedAt) > now - 10 * 60_000;
+      if (fresh && running?.cycle && Number(running.started_at) > 0) {
+        value = { kind: 'running', startedAt: Number(running.started_at) };
+      } else if (fresh) {
+        const pending = Math.max(Number(backlog?.unchunked) || 0, Number(backlog?.cycle2_pending) || 0);
+        if (pending > MEMORY_CYCLE_BACKLOG_WARN) value = { kind: 'backlog', pending };
+      }
+    }
+  } catch { value = null; }
+  _memoryCycleSegmentCache = { at: now, value };
+  return value;
+}
+
+function _shellJobsStatusImpl({ clientHostPid } = {}) {
   const ownerPid = positiveInt(clientHostPid);
   const empty = { count: 0, elapsedLabel: '' };
   if (!ownerPid) return empty;

package/src/vendor/statusline/bin/statusline-route.mjs

@@ -11,6 +11,7 @@ import {
   readLatestGatewayHostRoute,
   readGatewaySessionRoute,
 } from '../src/gateway/session-routes.mjs';
+import { compactBoundaryDenominator } from '../src/gateway/route-meta.mjs';
 
 function positiveInt(value) {
   const n = parseInt(String(value || ''), 10);
@@ -278,16 +279,8 @@ function resolveStatusAutoCompactTokenLimit(configured, active = {}, lastCompact
 export const _resolveStatusAutoCompactTokenLimit = resolveStatusAutoCompactTokenLimit;
 
 export function compactBoundaryForStatus(routeInfo = {}, compact = null) {
-  const compactLimit = num(routeInfo?.autoCompactTokenLimit ?? compact?.compactLimitTokens, 0);
-  const contextWindow = num(routeInfo?.contextWindow ?? compact?.contextWindow, 0);
-  const budgetWindow = num(compact?.budgetWindow, 0);
-  const rawContextWindow = num(routeInfo?.rawContextWindow ?? compact?.rawContextWindow, 0);
-  if (compactLimit > 0 && contextWindow > 0) return Math.min(compactLimit, contextWindow);
-  if (compactLimit > 0) return compactLimit;
-  if (budgetWindow > 0 && contextWindow > 0) return Math.min(budgetWindow, contextWindow);
-  if (budgetWindow > 0) return budgetWindow;
-  if (contextWindow > 0) return contextWindow;
-  return rawContextWindow > 0 ? rawContextWindow : null;
+  const n = compactBoundaryDenominator(routeInfo, compact);
+  return n > 0 ? n : null;
 }
 
 function sessionIdFromTranscriptPath(transcriptPath) {
@@ -378,8 +371,8 @@ function displayForModel(provider, model, info) {
   const display = cleanString(info?.display) || cleanString(info?.displayName) || cleanString(info?.name);
   if (display) return display;
   if (provider === 'anthropic-oauth') {
-    const m = String(model || '').match(/^claude-(opus|sonnet|haiku)-(\d+)-(\d+)/i);
-    if (m) return `${m[1][0].toUpperCase()}${m[1].slice(1).toLowerCase()} ${m[2]}.${m[3]}`;
+    const m = String(model || '').match(/^claude-(opus|sonnet|haiku|fable)-(\d+)(?:-(\d+))?/i);
+    if (m) return `${m[1][0].toUpperCase()}${m[1].slice(1).toLowerCase()} ${m[2]}${m[3] ? `.${m[3]}` : ''}`;
   }
   const raw = cleanString(model);
   const gpt = raw.match(/^gpt[-_](.+)$/i);

package/src/vendor/statusline/src/gateway/claude-current.mjs

@@ -119,7 +119,7 @@ export function resolveClaudeModelAlias(model) {
   if (!raw) return null;
   const stripped = stripClaudeContextSuffix(raw);
   if (/^claude-/i.test(stripped)) return stripped;
-  const family = stripped.match(/^(opus|sonnet|haiku)(?:[-_].*)?$/i)?.[1]?.toLowerCase();
+  const family = stripped.match(/^(opus|sonnet|haiku|fable)(?:[-_].*)?$/i)?.[1]?.toLowerCase();
   if (family) return familyDefaultModel(family);
   return null;
 }
@@ -128,11 +128,11 @@ export function displayClaudeModel(model, raw = '', display = '') {
   const explicit = cleanString(display);
   if (explicit) return explicit;
   const id = cleanString(model) || resolveClaudeModelAlias(raw) || cleanString(raw);
-  const m = id.match(/^claude-(opus|sonnet|haiku)-(\d+)-(\d+)(?:-\d{8})?$/i);
+  const m = id.match(/^claude-(opus|sonnet|haiku|fable)-(\d+)(?:-(\d+))?(?:-\d{8})?$/i);
   if (m) {
     const family = `${m[1][0].toUpperCase()}${m[1].slice(1).toLowerCase()}`;
     const suffix = /\[1m\]/i.test(raw) || contextWindowFromRawModel(raw, id) === 1000000 ? ' (1M context)' : '';
-    return `${family} ${m[2]}.${m[3]}${suffix}`;
+    return `${family} ${m[2]}${m[3] ? `.${m[3]}` : ''}${suffix}`;
   }
   return id || raw || '';
 }

package/src/vendor/statusline/src/gateway/route-meta.mjs

@@ -254,8 +254,8 @@ function displayForModel(provider, model, info) {
   const display = cleanString(info?.display) || cleanString(info?.displayName) || cleanString(info?.name);
   if (display) return display;
   if (provider === 'anthropic-oauth') {
-    const m = String(model || '').match(/^claude-(opus|sonnet|haiku)-(\d+)-(\d+)/i);
-    if (m) return `${m[1][0].toUpperCase()}${m[1].slice(1).toLowerCase()} ${m[2]}.${m[3]}`;
+    const m = String(model || '').match(/^claude-(opus|sonnet|haiku|fable)-(\d+)(?:-(\d+))?/i);
+    if (m) return `${m[1][0].toUpperCase()}${m[1].slice(1).toLowerCase()} ${m[2]}${m[3] ? `.${m[3]}` : ''}`;
   }
   return model || '';
 }
@@ -343,25 +343,44 @@ export function readGatewayRouteInfo(seed = {}, providerObj = null) {
   };
 }
 
-function compactBoundaryForRoute(routeInfo = {}, compact = null) {
-  const compactLimit = num(routeInfo?.autoCompactTokenLimit ?? compact?.compactLimitTokens, 0);
+// Boundary denominator for status %, overflow checks, and gateway env window.
+// Order: explicit boundary (routeInfo or compact) → contextWindow → budgetWindow
+// → rawContextWindow. autoCompactTokenLimit / compactLimitTokens are triggers
+// only and are never read here.
+export function compactBoundaryDenominator(routeInfo = {}, compact = null) {
+  const fromRoute = num(
+    routeInfo?.compactBoundaryTokens
+      ?? routeInfo?.compact_boundary_tokens
+      ?? routeInfo?.boundaryTokens,
+    0,
+  );
+  const fromCompact = num(
+    compact?.boundaryTokens
+      ?? compact?.compactBoundaryTokens
+      ?? compact?.compact_boundary_tokens,
+    0,
+  );
+  const boundaryTokens = fromRoute > 0 ? fromRoute : fromCompact;
   const contextWindow = num(routeInfo?.contextWindow ?? compact?.contextWindow, 0);
   const budgetWindow = num(compact?.budgetWindow, 0);
   const rawContextWindow = num(routeInfo?.rawContextWindow ?? compact?.rawContextWindow, 0);
-  if (compactLimit > 0 && contextWindow > 0) return Math.min(compactLimit, contextWindow);
-  if (compactLimit > 0) return compactLimit;
-  if (budgetWindow > 0 && contextWindow > 0) return Math.min(budgetWindow, contextWindow);
-  if (budgetWindow > 0) return budgetWindow;
+  if (boundaryTokens > 0) return boundaryTokens;
   if (contextWindow > 0) return contextWindow;
+  if (budgetWindow > 0) return budgetWindow;
   return rawContextWindow > 0 ? rawContextWindow : 0;
 }
 
+function compactBoundaryForRoute(routeInfo = {}, compact = null) {
+  return compactBoundaryDenominator(routeInfo, compact);
+}
+
 // Single source of truth for the value synced to host env
 // CLAUDE_CODE_AUTO_COMPACT_WINDOW. BOTH the --enable-time write
 // (scripts/gateway-model.mjs) and the runtime sync (src/gateway/server.mjs)
 // must derive the window the SAME way, or they disagree on the value written to
-// settings.json. Prefer the explicit compact limit, bounded by the effective
-// context window, then fall back to context/raw metadata. Returns a positive
+// settings.json. Denominator order: compactBoundaryTokens / boundaryTokens (route
+// or compact) → contextWindow → budgetWindow → rawContextWindow. Never
+// autoCompactTokenLimit or compactLimitTokens (trigger-only). Returns a positive
 // integer, or null when unknown.
 export function autoCompactWindowForRoute(routeInfo) {
   const n = compactBoundaryForRoute(routeInfo);
@@ -428,12 +447,7 @@ function usageCostUsd(routeInfo, usage) {
 }
 
 function contextUsageBoundary(routeInfo, compact = null) {
-  const contextWindow = num(routeInfo?.contextWindow ?? compact?.contextWindow, 0);
-  const budgetWindow = num(compact?.budgetWindow, 0);
-  const rawContextWindow = num(routeInfo?.rawContextWindow ?? compact?.rawContextWindow, 0);
-  if (contextWindow > 0) return contextWindow;
-  if (budgetWindow > 0) return budgetWindow;
-  return rawContextWindow > 0 ? rawContextWindow : compactBoundaryForRoute(routeInfo, compact);
+  return compactBoundaryDenominator(routeInfo, compact);
 }
 
 export function summarizeGatewayUsage(routeInfo, providerOut, compact = null, durationMs = null) {

package/src/workflows/default/WORKFLOW.md

@@ -1,14 +1,48 @@
+---
+id: default
+name: Default
+description: "Default agent workflow — fan-out parallel delegation across independent scopes."
+agents: worker, heavy-worker, reviewer, debugger, maintainer
+---
+
 # Default Workflow
 
-1. Plan — Lead discusses the request with the user, forms a plan, and waits for
-   approval.
-2. Delegate — split the work into the maximum number of independent scopes.
-   Spawn every scope in the same turn. Never merge separable scopes into one
-   agent. Shared functions or cross-cutting concerns do not justify merging;
-   split per path and verify the shared parts yourself.
-3. Review — fan out one review scope per implementation scope, in the same turn.
-   Fact-check implementation and review results yourself. Send fixes back to the
-   original scope and repeat until clean. Skip delegated review only for simple,
-   low-risk tasks.
-4. Report — integrate the results, report the final state, and ask the user
-   whether to ship/deploy when relevant.
+Lead supervises: delegates, coordinates, judges, decides. Route by complexity:
+- Lead handles directly: simple 1–2 step work, plus coordination, pre-planning,
+  config changes, and final git deployment.
+- Worker: implementation that takes several steps.
+- Heavy Worker: high-complexity, multi-step implementation.
+- Reviewer: verify implementation scopes (diff, regressions, missing checks).
+- Debugger: deploy for very high complexity, or when root-causing has already
+  failed at least once.
+
+1. Plan — discuss the request with the user, form a plan, and wait for approval.
+2. Delegate — split into the maximum number of independent scopes.
+   - PARALLEL across independent scopes by default (implementation, analysis,
+     review, debugging split alike). Spawn every scope in the SAME turn. Shared
+     or cross-cutting code does NOT justify merging: split per path and verify
+     the shared parts yourself. The only single scope is a genuinely
+     inseparable dependency — then state it.
+   - SEQUENTIAL within a single complex scope — split it into ordered steps
+     rather than handing it off in one shot, with a build/test-green gate
+     between steps.
+   - Write briefs per the lead-tool brief contract (token-optimized labeled
+     fragments).
+   - After spawning async agent(s), END THE TURN — do not poll, guess, or start
+     dependent work until the completion notification resumes you. Then wait
+     and continue automatically.
+3. Review — pair one reviewer 1:1 with each implementation scope, spawned in the
+   same turn; never defer or batch the reviewer call — wait for its result.
+   Fact-check the agent response and cross-check implementation and review
+   results yourself before acting on them. Send fixes back to the original
+   scope and loop verify -> fix -> re-verify until clean. Skip review only for
+   simple, low-risk tasks. If the user asks for debugging, or a bug survives
+   2+ fix cycles, have the debugger investigate first instead of another fix
+   round.
+4. Report — deliver the final report: synthesize results (outcome + key
+   evidence; never forward raw agent output), state the final state, and ask the
+   user whether to ship/deploy when relevant. Only after user feedback with no
+   issues prepare deploy/build/commit.
+
+On any major change or direction shift mid-work, pause and re-consult the user
+before continuing.

package/src/workflows/sequential/WORKFLOW.md

@@ -0,0 +1,51 @@
+---
+id: sequential
+name: Sequential
+description: "Sequential workflow — delegates 1:1 with no fan-out; one agent at a time."
+agents: worker, heavy-worker, reviewer, debugger, maintainer
+---
+
+# Sequential Workflow
+
+Unlike Default, which fans out independent scopes in parallel, this mode runs
+with no fan-out: it delegates one scope at a time, 1:1, and only moves to the
+next after the current one completes.
+
+Lead supervises: delegates, coordinates, judges, decides. Route by complexity:
+- Lead handles directly: simple 1–2 step work, plus coordination, pre-planning,
+  config changes, and final git deployment.
+- Worker: implementation that takes several steps.
+- Heavy Worker: high-complexity, multi-step implementation.
+- Reviewer: verify implementation scopes (diff, regressions, missing checks).
+- Debugger: deploy for very high complexity, or when root-causing has already
+  failed at least once.
+
+1. Plan — discuss the request with the user, form a plan, and wait for approval.
+2. Delegate — split into ordered scopes and hand them off ONE AT A TIME.
+   - NO PARALLEL, NO FAN-OUT. Even when scopes are independent, spawn exactly
+     one agent per turn; never spawn multiple agents in the same turn. Wait for
+     the current scope's completion notification before spawning the next scope
+     (1:1 sequential).
+   - SEQUENTIAL within a single complex scope — split it into ordered steps
+     rather than handing it off in one shot, with a build/test-green gate
+     between steps.
+   - Write briefs per the lead-tool brief contract (token-optimized labeled
+     fragments).
+   - After spawning an async agent, END THE TURN — do not poll, guess, or start
+     dependent or subsequent work until the completion notification resumes
+     you. Then wait and continue automatically.
+3. Review — after each implementation scope completes, pair one reviewer 1:1
+   with that scope (spawned on its own turn, not batched); never defer the
+   reviewer call — wait for its result. Fact-check the agent response and
+   cross-check implementation and review results yourself before acting on
+   them. Send fixes back to the original scope and loop verify -> fix ->
+   re-verify until clean. Skip review only for simple, low-risk tasks. If the
+   user asks for debugging, or a bug survives 2+ fix cycles, have the debugger
+   investigate first instead of another fix round.
+4. Report — deliver the final report: synthesize results (outcome + key
+   evidence; never forward raw agent output), state the final state, and ask the
+   user whether to ship/deploy when relevant. Only after user feedback with no
+   issues prepare deploy/build/commit.
+
+On any major change or direction shift mid-work, pause and re-consult the user
+before continuing.

package/src/workflows/solo/WORKFLOW.md

@@ -1,3 +1,10 @@
+---
+id: solo
+name: Solo
+description: "Solo workflow — Lead handles everything directly; delegation forbidden."
+agents:
+---
+
 # Solo Workflow
 
 1. Plan — Lead discusses the request with the user, forms a plan, and waits for
@@ -7,7 +14,11 @@
 3. Verify — Lead checks the result directly, fixes issues directly, and repeats
    until the work is clean or a blocker must be reported.
 4. Report — Lead summarizes the final state, verification result, and any
-   remaining risk or requested next step.
+   remaining risk or requested next step. Only after user feedback with no
+   issues prepare deploy/build/commit.
+
+On any major change or direction shift mid-work, pause and re-consult the user
+before continuing.
 
 Delegation rule:
 - Do not delegate, spawn, send, or ask any agent to perform work.

package/vendor/ink/build/display-width.js

@@ -0,0 +1,62 @@
+/**
+ * display-width.js — [mixdog fork] vendored copy of the shared display-width
+ * policy from src/tui/display-width.mjs.
+ *
+ * MUST STAY IN SYNC with src/tui/display-width.mjs. ink is aliased as an
+ * external bundle (see scripts/build-tui.mjs), so it cannot cleanly import from
+ * src; the small policy is replicated here verbatim instead. If the problem
+ * ranges or the WT_SESSION/MIXDOG_TUI_AMBIGUOUS_WIDE gate change there, change
+ * them here too — ink's MEASUREMENT must agree with OUR wrap/row math or the
+ * overlap gets worse, not better.
+ *
+ * Policy: widen ONLY U+2460–U+24FF (enclosed alphanumerics / circled digits)
+ * and U+2190–U+21FF (arrows) to 2 cells when ON. NEVER widen box-drawing
+ * (U+2500–U+257F), block elements, or other ambiguous glyphs. ON by default
+ * only under Windows Terminal (WT_SESSION); MIXDOG_TUI_AMBIGUOUS_WIDE='1'/'0'
+ * overrides and wins. OFF ⇒ identical to plain string-width.
+ */
+import stringWidth from 'string-width';
+
+function isProblemCodePoint(cp) {
+    return (cp >= 0x2460 && cp <= 0x24ff) || (cp >= 0x2190 && cp <= 0x21ff);
+}
+
+function resolveAmbiguousWidePolicy(env = process.env) {
+    const override = env?.MIXDOG_TUI_AMBIGUOUS_WIDE;
+    if (override === '1')
+        return true;
+    if (override === '0')
+        return false;
+    return Boolean(env?.WT_SESSION);
+}
+
+// Resolved once at module load (matches src/tui/display-width.mjs).
+export const AMBIGUOUS_WIDE = resolveAmbiguousWidePolicy();
+
+export function displayWidthWith(str, wide) {
+    const s = String(str ?? '');
+    const base = stringWidth(s);
+    if (!wide)
+        return base;
+    let extra = 0;
+    for (const ch of s) {
+        const cp = ch.codePointAt(0);
+        if (isProblemCodePoint(cp) && stringWidth(ch) === 1)
+            extra += 1;
+    }
+    return base + extra;
+}
+
+/** Visible display width under the resolved policy (ink-side stringWidth). */
+export function displayStringWidth(str) {
+    return displayWidthWith(str, AMBIGUOUS_WIDE);
+}
+
+/** widest-line equivalent under the policy. */
+export function displayWidestLine(text) {
+    let lineWidth = 0;
+    for (const line of String(text ?? '').split('\n')) {
+        lineWidth = Math.max(lineWidth, displayStringWidth(line));
+    }
+    return lineWidth;
+}