mixdog 0.9.26 → 0.9.28

package/src/tui/engine/notification-plan.mjs

@@ -64,7 +64,11 @@ export function resolveTuiRuntimeNotificationDelivery(event, text) {
   // UI-only notices (e.g. boot auto-update outcome): render as a transcript
   // notice, never enqueue anything model-visible.
   if (meta.kind === 'update-notice') {
-    return { action: 'notice', displayText: trimmed, tone: meta.tone === 'warn' ? 'warn' : 'info' };
+    // Wording lives here (the notice surface), not in the emitting runtime:
+    // the emitter only supplies meta.version; the sentence is composed here.
+    const ver = String(meta.version || '').trim();
+    const displayText = ver ? `mixdog v${ver} ready — restart to apply.` : trimmed;
+    return { action: 'notice', displayText, tone: meta.tone === 'warn' ? 'warn' : 'info' };
   }
   if (!isExecutionNotification(event, trimmed, parsed)) {
     return { action: 'enqueue', displayText: trimmed, modelContent: trimmed };

package/src/tui/hooks/useSharedTick.mjs

@@ -0,0 +1,103 @@
+/**
+ * hooks/useSharedTick.mjs — one process-wide animation timer for the TUI.
+ *
+ * The transcript used to fan out timers: Spinner's useAnimation, a 500ms blink
+ * + 1s elapsed setInterval PER pending ToolExecution card, and StatusLine's own
+ * refresh interval. With N pending cards that is 1 + 2N + 1 OS timers all waking
+ * the event loop independently, which showed up in the stutter bench as +369
+ * CPU-ms/s and 143ms frame gaps while idle-animated.
+ *
+ * This collapses every animated component onto a SINGLE shared setInterval.
+ * Subscribers register the cadence they want; the shared timer runs at the
+ * finest requested interval and only notifies each subscriber once its own
+ * interval has elapsed (derived from Date.now()), so a 500ms blink and a 130ms
+ * spinner still animate at their own rates off one timer. When the last
+ * subscriber unmounts the timer is cleared, so nothing ticks when nothing
+ * animated is on screen. Components derive blink phase / elapsed seconds /
+ * spinner frame from Date.now() at render — the tick only forces the re-render.
+ */
+import { useEffect, useRef, useState } from 'react';
+
+// Boundary tolerance: fire a subscriber a hair early rather than skip a whole
+// base-interval and drift its cadence by a full frame.
+const TICK_SLOP_MS = 16;
+
+const subscribers = new Set();
+let timer = null;
+
+// Delay until the soonest subscriber is due (clamped to >= 1ms). A single timer
+// is always aimed at the next real boundary, so a subscriber's cadence is tied
+// to ITS OWN lastFire + interval — never to a shared base that resets when the
+// finest-interval subscriber leaves. Returns null when nothing is subscribed.
+function nextDelayMs(now) {
+  let soonest = Infinity;
+  for (const sub of subscribers) {
+    const due = sub.lastFire + sub.interval - now;
+    if (due < soonest) soonest = due;
+  }
+  return Number.isFinite(soonest) ? Math.max(1, soonest) : null;
+}
+
+// Aim the single timer at the next due boundary. Called on every subscribe /
+// unsubscribe and after each tick, so adding a faster subscriber pulls the next
+// wake earlier and removing the finest one re-aims at the remaining subscribers'
+// own due times (no full fresh-interval stall). Clears the timer when empty.
+function reconcileTimer() {
+  if (timer) {
+    clearTimeout(timer);
+    timer = null;
+  }
+  const delay = nextDelayMs(Date.now());
+  if (delay == null) return;
+  timer = setTimeout(onTick, delay);
+  timer.unref?.();
+}
+
+function onTick() {
+  timer = null;
+  const now = Date.now();
+  // Snapshot so a subscriber unsubscribing during notify can't mutate the set
+  // mid-iteration.
+  for (const sub of Array.from(subscribers)) {
+    if (!subscribers.has(sub)) continue;
+    if (now - sub.lastFire >= sub.interval - TICK_SLOP_MS) {
+      sub.lastFire = now;
+      sub.notify(now);
+    }
+  }
+  reconcileTimer();
+}
+
+/**
+ * Subscribe the calling component to the shared tick.
+ *
+ * @param {number} intervalMs desired re-render cadence in ms.
+ * @param {boolean} [isActive=true] unsubscribe (and let the timer stop) when false.
+ * @param {(now:number)=>void} [onTick] optional callback fired on each tick
+ *   instead of the default internal re-render (e.g. to bump an existing state).
+ */
+export function useSharedTick(intervalMs, isActive = true, onTick = null) {
+  const [, setTick] = useState(0);
+  const cbRef = useRef(onTick);
+  cbRef.current = onTick;
+  useEffect(() => {
+    if (!isActive) return undefined;
+    const interval = Math.max(1, Number(intervalMs) || 0);
+    const sub = {
+      interval,
+      lastFire: Date.now(),
+      notify: (now) => {
+        if (cbRef.current) cbRef.current(now);
+        else setTick((t) => (t + 1) % 1_000_000);
+      },
+    };
+    subscribers.add(sub);
+    reconcileTimer();
+    return () => {
+      subscribers.delete(sub);
+      reconcileTimer();
+    };
+  }, [intervalMs, isActive]);
+}
+
+export default useSharedTick;

package/src/tui/index.jsx

@@ -18,6 +18,7 @@ import { emitTerminalBackground, loadThemeSettingFromConfig, theme } from './the
 import { POP_KITTY, DISABLE_MODIFY_OTHER_KEYS } from './keyboard-protocol.mjs';
 import { displayWidth } from './display-width.mjs';
 import { rotateBoundedLog, PLUGIN_LOG_MAX_BYTES, PLUGIN_LOG_KEEP_BYTES } from '../lib/mixdog-debug.cjs';
+import { localPackageVersion } from '../runtime/shared/update-checker.mjs';
 
 // Trailing `\x1b[>0s` restores XTSHIFTESCAPE (shift-to-select-extend) to its
 // terminal default; MOUSE_TRACKING_ON opts into `\x1b[>1s`, so every mouse/alt
@@ -290,7 +291,7 @@ function paintBootSplash() {
       out += `${bold}${fg}${center(logo[i])}${reset}\r\n`;
     }
     out += '\r\n';
-    out += `${subtleFg}${center(`mixdog coding agent · ${process.cwd()}`)}${reset}`;
+    out += `${subtleFg}${center(`mixdog coding agent · v${localPackageVersion()} · ${process.cwd()}`)}${reset}`;
 
     // Park the cursor at home so ink's first frame paints top-down over the
     // splash instead of starting at the bottom row and scrolling the screen.

package/src/tui/markdown/format-token.mjs

@@ -550,6 +550,36 @@ function collectFlatBodyLines(text, codeBlock, bandWidth) {
   return lines;
 }
 
+// Streaming open-fence (`token.plain`) fast normalize: strip raw TAB / C0
+// controls (so no stray byte survives to bypass the viewport clip) WITHOUT the
+// per-character displayWidth loop of normalizeCodeText — column-accurate tab
+// stops are cosmetic and are restored when the block settles and re-renders.
+function normalizeCodePlain(text) {
+  return String(text ?? '')
+    .replace(/\r\n?/g, '\n')
+    .replace(/\t/g, '  ')
+    // C0 controls + DEL except LF → single space.
+    .replace(/[\u0000-\u0009\u000b-\u001f\u007f]/g, ' ');
+}
+
+// Flat body for the streaming open block: color each line, wrapping only lines
+// that actually overflow (the common code line fits, so no wrapAnsi call). The
+// displayWidth guard is skipped for over-length lines (they always wrap) and for
+// blanks, keeping the per-frame pass close to O(n) with a small constant.
+function collectPlainBodyLines(text, codeBlock, bandWidth) {
+  const max = Math.max(1, bandWidth);
+  const lines = [];
+  for (const line of String(text ?? '').split(EOL)) {
+    if (!line) { lines.push(''); continue; }
+    if (line.length <= max && displayWidth(line) <= max) {
+      lines.push(codeBlock(line));
+    } else {
+      for (const seg of wrapCodeLine(codeBlock(line), max)) lines.push(seg);
+    }
+  }
+  return lines;
+}
+
 function collectHighlightedBodyLines(text, hljsLang, bandWidth) {
   const highlighted = highlightCodeText(text, hljsLang);
   const { codeBlock } = colorizers();
@@ -576,22 +606,30 @@ function renderCodeBlock(token, width = 0) {
   const { codeBlock } = colorizers();
   const c = extraColorizers();
   const lang = normalizeLang(token.lang);
-  const text = normalizeCodeText(decodeEntities(token.text ?? ''));
   const renderWidth = Math.max(8, Number(width) || 80);
   // Wrap content to the render width minus the left gutter so `gutter + content`
   // never overruns the available width.
   const contentWidth = Math.max(1, renderWidth - CODE_GUTTER.length);
 
   let bodyLines;
-  if (DIFF_LANGS.has(lang) || (!lang && looksLikeUnifiedDiff(text))) {
-    bodyLines = collectDiffBodyLines(text, c, contentWidth);
+  if (token.plain) {
+    // Streaming open fence: flat, un-highlighted body via the cheap normalize +
+    // conditional wrap. Avoids marked's lexer AND highlight.js AND the per-char
+    // width normalize every delta; the settled block re-renders fully below.
+    const text = normalizeCodePlain(decodeEntities(token.text ?? ''));
+    bodyLines = collectPlainBodyLines(text, codeBlock, contentWidth);
   } else {
-    const hljsLang = resolveHljsLanguage(lang);
-    const family = LANG_FAMILY[lang];
-    if (hljsLang && family !== 'md') {
-      bodyLines = collectHighlightedBodyLines(text, hljsLang, contentWidth);
+    const text = normalizeCodeText(decodeEntities(token.text ?? ''));
+    if (DIFF_LANGS.has(lang) || (!lang && looksLikeUnifiedDiff(text))) {
+      bodyLines = collectDiffBodyLines(text, c, contentWidth);
     } else {
-      bodyLines = collectFlatBodyLines(text, codeBlock, contentWidth);
+      const hljsLang = resolveHljsLanguage(lang);
+      const family = LANG_FAMILY[lang];
+      if (hljsLang && family !== 'md') {
+        bodyLines = collectHighlightedBodyLines(text, hljsLang, contentWidth);
+      } else {
+        bodyLines = collectFlatBodyLines(text, codeBlock, contentWidth);
+      }
     }
   }
   // Indent every body row by the gutter (no bg band).

package/src/tui/markdown/render-ansi.mjs

@@ -15,7 +15,7 @@
  */
 import { marked } from 'marked';
 import { formatToken } from './format-token.mjs';
-import { trimPartialClosingFences } from './stream-fence.mjs';
+import { trimPartialClosingFences, findOpenFenceStart } from './stream-fence.mjs';
 
 const TOKEN_CACHE_MAX = 500;
 const tokenCache = new Map();
@@ -50,6 +50,29 @@ export function lexMarkdown(content, { trimPartialFences = false } = {}) {
   // are transient per-delta and trimming mutates them in place, so they are NOT
   // cached — caching would corrupt the shared cache for stable text.
   if (trimPartialFences) {
+    // Open-fence fast path: an unclosed fenced code block would make marked
+    // re-scan the whole growing block every delta (its closing-fence regex
+    // never matches and backtracks over the entire body — ~O(n²) per frame).
+    // Build the `code` token directly from the raw fence text instead, and mark
+    // it `plain` so it renders flat (no per-frame highlight.js pass) until the
+    // closing fence arrives; the settled (closed) frame lexes normally.
+    const open = findOpenFenceStart(text);
+    if (open) {
+      const post = text.slice(open.index);
+      const nl = post.indexOf('\n');
+      const codeToken = {
+        type: 'code',
+        raw: post,
+        lang: open.lang,
+        text: nl === -1 ? '' : post.slice(nl + 1),
+        plain: true,
+      };
+      const pre = text.slice(0, open.index);
+      const tokens = pre ? marked.lexer(pre) : [];
+      tokens.push(codeToken);
+      trimPartialClosingFences(tokens);
+      return tokens;
+    }
     const tokens = marked.lexer(text);
     trimPartialClosingFences(tokens);
     return tokens;

package/src/tui/markdown/stream-fence.mjs

@@ -32,3 +32,63 @@ export function trimPartialClosingFences(tokens) {
   if (lastLine.length >= marker.length || lastLine !== marker[0].repeat(lastLine.length)) return;
   token.text = String(token.text ?? '').slice(0, -lastLine.length).replace(/\n$/, '');
 }
+
+/**
+ * Locate the currently-open (unclosed) fenced code block that is safe to split
+ * off cheaply, or null. Returns { index, lang } where `index` is the byte offset
+ * of the opening fence line's first char. Pure line scan (no marked.lexer), so a
+ * growing open code block avoids marked's catastrophic never-matched-closer
+ * backtracking every delta.
+ *
+ * Only a TOP-LEVEL fence (opening line at column 0) is reported: a col-0 fence
+ * is always a fresh top-level block in CommonMark (list/blockquote content is
+ * never at column 0), so everything before it is complete blocks and the split
+ * is render-invariant. An indented (possibly list/blockquote-nested) open fence
+ * returns null so the caller falls back to the correct full marked.lexer path.
+ *
+ * Fence rules are marked/CommonMark-aligned:
+ *   - opening: 0–3 spaces indent, run of ≥3 same fence char; a backtick fence's
+ *     info string may not contain a backtick;
+ *   - closing: 0–3 spaces indent, a run of fence chars that STARTS with the exact
+ *     opening marker (same char, ≥ opening length) and may continue with any mix
+ *     of backticks/tildes (marked's `\1[~`]*`), followed only by spaces/tabs.
+ */
+const OPEN_FENCE_RE = /^( {0,3})(`{3,}|~{3,})(.*)$/;
+const CLOSE_FENCE_RE = /^ {0,3}([`~]+)[ \t]*$/;
+
+function isClosingFence(line, char, openLen) {
+  const m = CLOSE_FENCE_RE.exec(line);
+  if (!m) return false;
+  const run = m[1];
+  // marked closes on ` {0,3}\1[~`]* *`: the run must begin with the exact opening
+  // marker (openLen × openChar); trailing chars may be the OPPOSITE fence char
+  // (e.g. ``` closed by ```~~), so only the prefix is constrained.
+  return run.startsWith(char.repeat(openLen));
+}
+
+export function findOpenFenceStart(text) {
+  const value = String(text ?? '');
+  let open = null;
+  let start = 0;
+  for (let i = 0; i <= value.length; i++) {
+    if (i !== value.length && value[i] !== '\n') continue;
+    const line = value.slice(start, i);
+    if (!open) {
+      const m = OPEN_FENCE_RE.exec(line);
+      if (m) {
+        const char = m[2][0];
+        const info = m[3];
+        // A backtick fence's info string may not contain a backtick.
+        if (!(char === '`' && info.indexOf('`') !== -1)) {
+          open = { index: start, indent: m[1].length, char, len: m[2].length, lang: info.trim() };
+        }
+      }
+    } else if (isClosingFence(line, open.char, open.len)) {
+      open = null;
+    }
+    start = i + 1;
+  }
+  // Only fast-path unambiguously top-level (column-0) fences.
+  if (!open || open.indent !== 0) return null;
+  return { index: open.index, lang: open.lang };
+}

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

@@ -4,7 +4,7 @@
  */
 import { marked } from 'marked';
 import { configureMarked, hasMarkdownSyntax } from './render-ansi.mjs';
-import { trimPartialClosingFences } from './stream-fence.mjs';
+import { trimPartialClosingFences, findOpenFenceStart } from './stream-fence.mjs';
 
 const stablePrefixByStreamKey = new Map();
 const STABLE_PREFIX_LRU_MAX = 32;
@@ -129,6 +129,27 @@ export function resolveStreamingMarkdownParts(text, streamKey) {
     stablePrefix = '';
   }
 
+  // Open-fence fast path: never run marked.lexer on a growing unclosed code
+  // block (its closing-fence regex never matches and backtracks over the whole
+  // body every delta — the ~56ms/frame cost). Split cheaply at the fence line:
+  // everything before it is settled markdown (lexed + cached once by the stable
+  // <Markdown>), the open block is rendered flat until the closing fence lands.
+  const open = findOpenFenceStart(t);
+  if (open) {
+    let openPrefix = t.substring(0, open.index);
+    if (isWhitespaceOnlyText(openPrefix)) openPrefix = '';
+    if (key && openPrefix) touchStablePrefixKey(key, openPrefix);
+    else if (key) stablePrefixByStreamKey.delete(key);
+    const unstableSuffix = t.substring(openPrefix.length);
+    return {
+      plain: false,
+      openFence: true,
+      stablePrefix: openPrefix,
+      unstableSuffix,
+      unstableForRender: unstableSuffix,
+    };
+  }
+
   try {
     configureMarked();
     const boundary = stablePrefix.length;

package/src/workflows/default/WORKFLOW.md

@@ -13,19 +13,23 @@ exploration only. Diagnosis agreement or problem-pointing is NOT approval.
 
 Lead supervises: delegates, coordinates, judges, decides. Route by complexity
 (after approval):
-- Lead directly: simple 1–2 step work, coordination, config, git deployment.
-- Worker: multi-step implementation. Heavy Worker: high-complexity scopes.
+- Lead directly: only one-step fixes doable in a single turn, plus
+  coordination, config, and git deployment. Everything else delegates.
+- Worker: any multi-step or multi-file implementation. Heavy Worker:
+  high-complexity scopes.
 - Reviewer: verify implementation scopes. Debugger: very high complexity, or
   root-causing already failed once.
 
 1. Plan — present a draft plan before ANY implementation; if not approved,
    revise and re-present (ping-pong) until an explicit go-ahead.
-2. Delegate — split into the maximum independent scopes; spawn all in the
-   SAME turn (parallel by default; sequential steps only inside one complex
-   scope, gated build/test-green). Shared/cross-cutting code does NOT justify
-   merging scopes — split per path, verify shared parts yourself; a genuinely
-   inseparable single scope must be stated. Briefs per the Lead brief
-   contract. After spawning async agents, END THE TURN.
+2. Delegate — maximize distribution: split the work into as many independent
+   scopes as possible and hand each to its own agent, all spawned in the SAME
+   turn (parallel by default; sequential steps only inside one complex scope,
+   gated build/test-green). This applies to every role alike — worker,
+   heavy-worker, reviewer, debugger: fan them out across agents, never one at
+   a time. Only a genuinely inseparable single scope stays whole, and say so.
+   Briefs per the Lead brief contract. After spawning async agents, END THE
+   TURN.
 3. Review — pair one reviewer 1:1 per implementation scope, same turn.
    Cross-check agent results yourself; send fixes back to the original scope
    and loop fix -> re-verify until clean. Skip only for simple low-risk work.

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

@@ -10,8 +10,9 @@
  * 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
+ * and U+2194–U+21FF (arrows) to 2 cells when ON. NEVER widen box-drawing
+ * (U+2500–U+257F), block elements, the four Basic Arrows U+2190–U+2193
+ * (← ↑ → ↓ — figures.mjs 1-cell markers), or other ambiguous glyphs. ON by default
  * on Windows (win32) or under Windows Terminal (WT_SESSION);
  * MIXDOG_TUI_AMBIGUOUS_WIDE='1'/'0' overrides and wins. OFF ⇒ identical to
  * plain string-width.
@@ -23,14 +24,14 @@ import stringWidth from 'string-width';
 const graphemeSegmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
 
 function isProblemCodePoint(cp) {
-    return (cp >= 0x2460 && cp <= 0x24ff) || (cp >= 0x2190 && cp <= 0x21ff);
+    return (cp >= 0x2460 && cp <= 0x24ff) || (cp >= 0x2194 && cp <= 0x21ff);
 }
 
 // [mixdog fork] Fast precheck for the problem ranges above. Lets the hot path
 // bail before the per-grapheme segmenter loop when a string (the common
 // ASCII/status-text case) contains no widenable glyph. Kept in sync with
 // src/tui/display-width.mjs.
-const PROBLEM_RE = /[\u2190-\u21ff\u2460-\u24ff]/;
+const PROBLEM_RE = /[\u2194-\u21ff\u2460-\u24ff]/;
 
 function resolveAmbiguousWidePolicy(env = process.env, platform = process.platform) {
     const override = env?.MIXDOG_TUI_AMBIGUOUS_WIDE;