mixdog 0.9.55 → 0.9.59

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, flushEmit, flushEmitImmediate, pushItem, appendItems, patchItem, replaceItems, 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, flushEmit, flushEmitImmediate, pushItem, appendItems, patchItem, replaceItems, updateStreamingTail: updateStreamingTailFromStore, settleStreamingTail: settleStreamingTailFromStore, clearStreamingTail: clearStreamingTailFromStore, pushNotice, pushUserOrSyntheticItem, markToolCallActive, markToolCallDone, clearActiveToolSummary, agentStatusState, routeState, transcriptRouteMetadata, 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.
@@ -35,6 +35,13 @@ export function createRunTurn(bag) {
     async function runTurn(userText, options = {}) {
     const turnIndex = getState().stats.turns || 0;
     const startedAt = Date.now();
+    const completionVerb = pickDoneVerb(turnIndex);
+    const baseTranscriptMeta = flags.pendingTranscriptMeta
+      || transcriptRouteMetadata?.(startedAt)
+      || { at: startedAt };
+    const turnTranscriptMeta = { ...baseTranscriptMeta, completionVerb };
+    flags.pendingTranscriptMeta = null;
+    const { at: _userItemAt, ...turnRouteMeta } = turnTranscriptMeta;
     // Per-turn epoch. Force-release (watchdog grace) bumps the shared counter so
     // this turn's own eventual `finally` — which may run LONG after force-release
     // already started a new turn that reuses the per-session mutex — can detect
@@ -223,6 +230,34 @@ export function createRunTurn(bag) {
     const toolCards = [];
     const toolGroups = new Map();
     const resultsDone = new Set();
+    // ── Live shell-output tail → running tool card ─────────────────────────
+    // 1 s poll of orchestrator liveness while this turn runs. When exactly one
+    // standalone (non-aggregate) card is unresolved and the runtime reports a
+    // fresh toolOutputTail for the running tool, patch it onto the card as
+    // `liveOutput` so transcript consumers (desktop) can render live command
+    // output. The result patch clears the field; timer dies with the turn.
+    let liveTailTimer = null;
+    let lastLiveTailPatched = '';
+    const clearLiveTailTimer = () => {
+      if (liveTailTimer) { clearInterval(liveTailTimer); liveTailTimer = null; }
+    };
+    liveTailTimer = setInterval(() => {
+      if (!isCurrentTurn()) { clearLiveTailTimer(); return; }
+      let liveness = null;
+      try { liveness = runtime.getTurnLiveness?.(); } catch { return; }
+      if (!liveness || liveness.stage !== 'tool_running') return;
+      const tail = typeof liveness.toolOutputTail === 'string' ? liveness.toolOutputTail : '';
+      if (!tail || tail === lastLiveTailPatched) return;
+      const running = toolCards.filter((c) => !c.done && !c.aggregate);
+      if (running.length !== 1) return;
+      const card = running[0];
+      // Real output proves the tool is genuinely running — surface the card
+      // even if its deferred-display timer has not fired yet.
+      card.ensureVisible?.();
+      lastLiveTailPatched = tail;
+      patchItem(card.itemId, { liveOutput: tail });
+    }, 1000);
+    liveTailTimer.unref?.();
     // Streaming providers can deliver eager onToolResult before onToolCall registers
     // cards (send() still in flight). Hold those by callId until the batch lands.
     const earlyResultBuffer = new Map();
@@ -518,6 +553,11 @@ export function createRunTurn(bag) {
     const ensureAssistant = (initialText = '') => {
       if (!currentAssistantId) {
         currentAssistantId = nextId();
+        const assistantAt = Number.isFinite(Number(turnTranscriptMeta.assistantAt))
+          && Number(turnTranscriptMeta.assistantAt) > 0
+          ? Number(turnTranscriptMeta.assistantAt)
+          : Date.now();
+        turnTranscriptMeta.assistantAt = assistantAt;
         // Do NOT reset currentAssistantText here. The first onTextDelta has
         // already accumulated the opening chunk before this batched flush runs;
         // wiping it dropped the leading characters and forced a later set() to
@@ -525,7 +565,7 @@ export function createRunTurn(bag) {
         // Seed the new row with the already-visible text so the ● gutter and the
         // first body line appear in the SAME set()/emit() — no empty "●-only"
         // row that scrolls once on its own and again when the body lands.
-        updateStreamingTail(currentAssistantId, { text: String(initialText || '') });
+        updateStreamingTail(currentAssistantId, { text: String(initialText || ''), at: assistantAt, ...turnRouteMeta });
       }
       return currentAssistantId;
     };
@@ -661,7 +701,15 @@ export function createRunTurn(bag) {
           const id = ensureAssistant(streamingVisibleText);
           const current = getState().streamingTail;
           if (!current || current.id !== id || !Object.is(current.text, streamingVisibleText)) {
-            patch.streamingTail = { kind: 'assistant', id, text: streamingVisibleText, streaming: true };
+            patch.streamingTail = {
+              ...(current || {}),
+              kind: 'assistant',
+              id,
+              text: streamingVisibleText,
+              streaming: true,
+              at: current?.at || Date.now(),
+              ...turnRouteMeta,
+            };
           }
         }
         // Only touch the spinner when there is a real reason: a visible-line
@@ -799,6 +847,7 @@ export function createRunTurn(bag) {
 
     try {
       const { result, session } = await runtime.ask(userText, {
+        transcriptMeta: turnTranscriptMeta,
         drainSteering: (_sessionId, drainOptions) => (isCurrentTurn() ? drainPendingSteering(drainOptions) : []),
         onStreamDelta: () => {
           markTurnProgress('stream-delta');
@@ -1096,10 +1145,13 @@ export function createRunTurn(bag) {
             if (currentAssistantText) {
               set({
                 streamingTail: {
+                  ...(getState().streamingTail || {}),
                   kind: 'assistant',
                   id: currentAssistantId,
                   text: currentAssistantText,
                   streaming: true,
+                  at: getState().streamingTail?.at || Date.now(),
+                  ...turnRouteMeta,
                 },
               });
             } else {
@@ -1249,6 +1301,7 @@ export function createRunTurn(bag) {
       // Turn is unwinding normally (or via abort) — cancel the idle watchdog and
       // its force-release grace so they never fire on a live turn.
       clearWatchdog();
+      clearLiveTailTimer();
       // If the watchdog force-release already fired, a NEWER turn now owns the
       // shared store (busy, flags.activePromptRestore, turndone, drain). This stale
       // unwind must NOT write shared getState() or it corrupts that turn.
@@ -1314,7 +1367,7 @@ export function createRunTurn(bag) {
         // in scrollback. (Previously TurnDone rendered only in the
         // bottom-fixed live-status slot and vanished on the next turn.)
         if (!reclaimed && !isNoOpTurn) {
-          closingItems.push({ kind: 'turndone', id: nextId(), elapsedMs, status: turnStatus, outputTokens: finalOutputTokens, thinkingElapsedMs, verb: pickDoneVerb(turnIndex) });
+          closingItems.push({ kind: 'turndone', id: nextId(), elapsedMs, status: turnStatus, outputTokens: finalOutputTokens, thinkingElapsedMs, verb: completionVerb, at: Date.now(), ...turnRouteMeta });
         }
         // Deferred cards + turndone + status all land in ONE set() (one commit).
         appendItemsBatch(closingItems, {

package/src/tui/engine.mjs

@@ -11,10 +11,10 @@
  * This file keeps the stateful createEngineSession store + notification plan.
  */
 import { performance } from 'node:perf_hooks';
-import { mkdtempSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { mkdtempSync, readFileSync, readdirSync, rmSync, statSync, watch, writeFileSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { basename, dirname, join } from 'node:path';
 import { Worker } from 'node:worker_threads';
 import {
   aggregateToolCategoryEntry,
@@ -28,6 +28,7 @@ import {
 } from '../runtime/shared/tool-execution-contract.mjs';
 import { isLateToolAnnouncement } from '../session-runtime/session-text.mjs';
 import { presentErrorText } from '../runtime/shared/err-text.mjs';
+import { sessionPath } from '../runtime/agent/orchestrator/session/store/paths-heartbeat.mjs';
 import { listThemes, getThemeSetting, setThemeSetting } from './theme.mjs';
 import { resetAllStreamingMarkdownStablePrefixes } from './markdown/streaming-markdown.mjs';
 import { bootProfile } from './engine/boot-profile.mjs';
@@ -104,6 +105,8 @@ import { createSessionFlow } from './engine/session-flow.mjs';
 import { createRunTurn } from './engine/turn.mjs';
 import { createEngineApi } from './engine/session-api.mjs';
 import { createFrameBatchedStorePublisher } from './engine/frame-batched-store.mjs';
+import { createLiveShare, liveSharePipePath } from './engine/live-share.mjs';
+import { displayModelName } from '../ui/model-display.mjs';
 
 // Source tests resolve from src/tui/engine.mjs; the built bundle resolves from
 // src/tui/dist/index.mjs.
@@ -189,7 +192,9 @@ export function cleanupStaleTranscriptSpillDirs({
 export function createTranscriptSpillBuffer({
   cap = TRANSCRIPT_LIVE_ITEM_CAP,
   chunkSize = TRANSCRIPT_SPILL_CHUNK_ITEMS,
-  workerFactory = (source) => new Worker(source, { eval: true }),
+  // stdout/stderr: worker threads otherwise copy straight into the REAL fds,
+  // bypassing the TUI stderr guard and printing over the terminal frame.
+  workerFactory = (source) => new Worker(source, { eval: true, stdout: true, stderr: true }),
   onWarning = (message) => tuiDebug(message),
   writeTimeoutMs = 5000,
 } = {}) {
@@ -269,6 +274,8 @@ export function createTranscriptSpillBuffer({
       const worker = workerFactory(workerSource);
       spillWorker = worker;
       workerSpawnCount += 1;
+      worker.stdout?.on?.('data', (chunk) => { try { process.stderr.write(chunk); } catch { /* best-effort */ } });
+      worker.stderr?.on?.('data', (chunk) => { try { process.stderr.write(chunk); } catch { /* best-effort */ } });
       worker.on('message', (result) => {
         if (spillWorker !== worker || result?.id !== activeWrite?.id) return;
         finishWrite(result?.ok === true, result?.error);
@@ -644,6 +651,7 @@ export async function createEngineSession({
     activePromptRestore: null,
     pushingFromDeferredEntry: false,
     flushDeferredBeforeImmediatePush: null,
+    pendingTranscriptMeta: null,
   };
   const lifecycle = { runtimePulseTimer: null, unsubscribeRuntimeNotifications: null, unsubscribeRemoteState: null };
   const pending = [];
@@ -912,6 +920,17 @@ export async function createEngineSession({
     activeToolCalls.clear();
     if (state.activeToolSummary) set({ activeToolSummary: null });
   };
+  const transcriptRouteMetadata = (at = Date.now()) => {
+    const route = routeState();
+    const modelName = displayModelName(route.model, route.provider);
+    const workflowLabel = String(route.workflow?.name || route.workflow?.id || '').trim();
+    return {
+      at,
+      ...(modelName ? { model: modelName } : {}),
+      ...(route.provider ? { provider: String(route.provider) } : {}),
+      ...(workflowLabel ? { agent: workflowLabel } : {}),
+    };
+  };
   const pushItem = (item) => {
     if (!flags.pushingFromDeferredEntry && flags.flushDeferredBeforeImmediatePush) {
       flags.flushDeferredBeforeImmediatePush();
@@ -1000,7 +1019,7 @@ export async function createEngineSession({
     });
     return true;
   };
-  const pushUserOrSyntheticItem = (text, id = nextId(), origin = 'user') => {
+  const pushUserOrSyntheticItem = (text, id = nextId(), origin = 'user', extra = null) => {
     // The lenient shape-only wrapper check is display-suppression only and
     // must never hide a real, directly-typed/pasted user prompt just because
     // it happens to resemble "instruction + Result: + quoted body". Only
@@ -1021,7 +1040,15 @@ export async function createEngineSession({
     // up-arrow history survives across sessions. Runs before pushItem so the
     // merge in pushItem's user branch (loadPromptHistory) already sees it.
     if (origin === 'user') appendPromptHistory(state.cwd, text);
-    pushItem({ kind: 'user', id, text });
+    const transcriptMeta = transcriptRouteMetadata();
+    if (origin === 'user') flags.pendingTranscriptMeta = transcriptMeta;
+    pushItem({
+      kind: 'user', id, text, ...transcriptMeta,
+      // Byte-free attachment metadata (name/mime/size) from the queue entry —
+      // lets the desktop transcript render image chips without ever carrying
+      // base64 payloads through snapshots.
+      ...(extra && Array.isArray(extra.images) && extra.images.length ? { images: extra.images } : {}),
+    });
   };
   const pushAsyncAgentResponse = (text, id = nextId(), origin = 'injected', metadata = {}) => {
     const synthetic = parseSyntheticAgentMessage(text);
@@ -1219,7 +1246,7 @@ export async function createEngineSession({
     pushToast, pushNotice, removeNotice, setProgressHint,
     pushUserOrSyntheticItem, pushAsyncAgentResponse, upsertSyntheticToolItem,
     markToolCallActive, markToolCallDone, clearActiveToolSummary, clearToastTimers,
-    autoClearState, agentStatusState, baseRouteState, routeState, syncContextStats,
+    autoClearState, agentStatusState, baseRouteState, routeState, transcriptRouteMetadata, syncContextStats,
     disposeTranscriptSpill: () => transcriptSpill.dispose(),
     snapshotTranscriptSpill: () => transcriptSpill.snapshot(),
     restoreTranscriptSpill: (snapshot) => transcriptSpill.restoreSnapshot(snapshot),
@@ -1230,6 +1257,183 @@ export async function createEngineSession({
   });
   Object.assign(bag, createSessionFlow(bag));
   bag.runTurn = createRunTurn(bag);
+  const api = createEngineApi(bag);
+  // Cross-surface share: presence + the durable pending spool remain the
+  // ownership/base layer; a local pipe layer (live-share) streams frame
+  // deltas so co-open surfaces mirror each other in real time.
+  //  - presence: mark OUR current session as held open (idle included) so a
+  //    cross-open elsewhere attaches as a viewer instead of splitting
+  //    ownership; cleared on session switch here and on dispose
+  //    (session-api-ext), with sidecar staleness covering crashes.
+  //  - owner leg: host the live pipe, push transcript/tail/spinner deltas,
+  //    and run foreign submits through the normal queue — full user bubble +
+  //    streaming on every surface. The spool drain stays as the fallback
+  //    intake (instant via fs.watch, 3s tick as safety net).
+  //  - viewer leg: connect to the owner's pipe and mirror its live state.
+  //    While the pipe is up the disk-mtime re-resume is skipped (no turn-end
+  //    flicker); when the owner disappears the quiet re-resume promotes this
+  //    surface to real ownership.
+  let heldPresenceId = '';
+  let viewerStoreMtime = 0;
+  const drainRemoteInjections = () => {
+    const injected = runtime.takeRemoteInjections?.() || [];
+    if (injected.length === 0) return;
+    for (const text of injected) bag.enqueue(text);
+    void bag.drain();
+  };
+  const liveShare = createLiveShare({
+    ownerSessionId: () => (flags.disposed || flags.pendingSessionReset || state.sessionRemoteAttached
+      ? '' : String(state.sessionId || '')),
+    viewerSessionId: () => (flags.disposed || !state.sessionRemoteAttached
+      ? '' : String(state.sessionId || '')),
+    socketPathFor: (id) => liveSharePipePath(id, sessionPath(id)),
+    getPublishedState: () => publishedState,
+    listeners,
+    onRemoteSubmit: (text) => {
+      if (flags.disposed || state.sessionRemoteAttached) return;
+      bag.enqueue(text);
+      void bag.drain();
+    },
+    onOwnerClosed: (id) => {
+      // Owner left (clean close or crash): promote via the normal quiet
+      // re-resume once its final save/presence-clear has landed.
+      const timer = setTimeout(() => {
+        if (flags.disposed || !state.sessionRemoteAttached) return;
+        if (String(state.sessionId || '') !== id) return;
+        void Promise.resolve(api.resume(id, { quiet: true })).catch(() => { /* tick retries */ });
+      }, 1500);
+      timer.unref?.();
+    },
+    viewerApply: {
+      getState: () => state,
+      set,
+      replaceItems: (...args) => bag.replaceItems(...args),
+      patchItem: (...args) => bag.patchItem(...args),
+      appendItems: (...args) => bag.appendItems(...args),
+      updateStreamingTail: (...args) => bag.updateStreamingTail(...args),
+      clearStreamingTail: (...args) => bag.clearStreamingTail(...args),
+    },
+  });
+  // Immediate live-share reconcile for session entry/promotion. Waiting for
+  // the 3s share tick left a just-resumed live-owned session showing the
+  // stale disk snapshot, then full-swapped the transcript mid-view once the
+  // pipe finally connected (visible up/down lurch until heights resettled).
+  // resume() calls this right after installing the restored items so the
+  // owner's full frame lands at the entry boundary instead of seconds later.
+  bag.ensureLiveShare = () => { try { liveShare.ensure(); } catch { /* share tick retries */ } };
+  // Live viewer submits ride the owner's pipe (instant user bubble + shared
+  // streaming); the durable spool path below remains the fallback.
+  if (typeof api.submit === 'function') {
+    const baseSubmit = api.submit;
+    api.submit = (prompt, options = {}) => {
+      if (state.sessionRemoteAttached && liveShare.viewerConnected()) {
+        const text = String(promptDisplayText(prompt, options) || '').trim();
+        if (text && liveShare.sendSubmit(text)) return true;
+      }
+      return baseSubmit(prompt, options);
+    };
+  }
+  // Attach-time pipe fast-path: session entry (resume) reconciles the live
+  // pipe IMMEDIATELY instead of waiting for the 3s share tick. The attach
+  // render comes from the last disk save WITHOUT the in-flight turn, so that
+  // tick-wide window is exactly when a running tool call / mid-turn
+  // conversation looks missing and then pops in late (user report). The
+  // owner leg benefits equally: its pipe server starts the moment the
+  // session opens, so cross-surface viewers can connect at once.
+  const reconcileLiveShareNow = () => { try { liveShare.ensure(); } catch { /* tick retries */ } };
+  for (const method of ['resume', 'newSession', 'switchContext']) {
+    if (typeof api[method] !== 'function') continue;
+    const base = api[method].bind(api);
+    api[method] = async (...args) => {
+      const result = await base(...args);
+      reconcileLiveShareNow();
+      if (method === 'resume' && result === true && state.sessionRemoteAttached) {
+        const id = String(state.sessionId || '');
+        // EngineHost holds renderer publications across resume. Keep that hold
+        // until the owner's first FULL frame replaces the persisted transcript,
+        // then synchronously publish the complete draft before getState().
+        // Old owners without live-share fall back to the disk restore after the
+        // short bounded wait rather than blocking session entry indefinitely.
+        if (id && await liveShare.waitForViewerSync(id)) bag.flushEmit();
+      }
+      return result;
+    };
+  }
+  // Instant input pickup: watch the shared pending spool so an attached
+  // surface's fallback submit reaches this owner immediately instead of on
+  // the 3s tick. Best-effort — the tick below remains the safety net.
+  let spoolWatcher = null;
+  let spoolDebounce = null;
+  try {
+    const spoolPath = String(runtime.pendingSpoolPath?.() || '');
+    if (spoolPath) {
+      const spoolFile = basename(spoolPath);
+      spoolWatcher = watch(dirname(spoolPath), { persistent: false }, (_event, filename) => {
+        if (filename && String(filename) !== spoolFile) return;
+        if (flags.disposed || spoolDebounce) return;
+        spoolDebounce = setTimeout(() => {
+          spoolDebounce = null;
+          if (flags.disposed || flags.pendingSessionReset) return;
+          if (state.busy || state.commandBusy || state.sessionRemoteAttached) return;
+          try { drainRemoteInjections(); } catch { /* tick fallback */ }
+        }, 120);
+        spoolDebounce.unref?.();
+      });
+      spoolWatcher.on?.('error', () => {
+        try { spoolWatcher.close(); } catch { /* already closed */ }
+        spoolWatcher = null;
+      });
+    }
+  } catch { /* spool watch is an optimization; the 3s tick remains */ }
+  const remoteAttachTimer = setInterval(() => {
+    if (flags.disposed) {
+      clearInterval(remoteAttachTimer);
+      try { liveShare.dispose(); } catch { /* best-effort */ }
+      try { spoolWatcher?.close(); } catch { /* already closed */ }
+      if (spoolDebounce) { clearTimeout(spoolDebounce); spoolDebounce = null; }
+      return;
+    }
+    if (flags.pendingSessionReset) return;
+    try {
+      const heldId = runtime.publishSessionPresence?.() || '';
+      if (heldPresenceId && heldPresenceId !== heldId) runtime.clearSessionPresence?.(heldPresenceId);
+      heldPresenceId = heldId;
+    } catch { /* best-effort */ }
+    try { liveShare.ensure(); } catch { /* next tick retries */ }
+    try {
+      if (state.busy || state.commandBusy) return;
+      if (state.sessionRemoteAttached) {
+        const id = String(state.sessionId || '');
+        if (!id) return;
+        // Pipe-connected viewers follow the owner live; the disk-mtime
+        // re-resume would only reload mid-stream state and flicker.
+        if (liveShare.viewerConnected()) { viewerStoreMtime = 0; return; }
+        // Self-heal: a force-killed owner never announces onOwnerClosed and
+        // its final save never bumps the store mtime, so without this probe
+        // the surface stays a viewer forever, spooling messages to nobody.
+        // When the resume guard says the owner is gone, promote via the same
+        // quiet re-resume (it drains the pending spool on the next tick).
+        if (runtime.sessionOwnerGone?.(id) === true) {
+          viewerStoreMtime = 0;
+          void Promise.resolve(api.resume(id, { quiet: true })).catch(() => { /* next tick retries */ });
+          return;
+        }
+        let mtime = 0;
+        try { mtime = statSync(sessionPath(id)).mtimeMs || 0; } catch { return; }
+        // First attached tick only baselines: the resume that attached this
+        // surface already loaded the current on-disk transcript.
+        if (!viewerStoreMtime) { viewerStoreMtime = mtime; return; }
+        if (mtime > viewerStoreMtime) {
+          viewerStoreMtime = mtime;
+          void Promise.resolve(api.resume(id, { quiet: true })).catch(() => { /* next tick retries */ });
+        }
+        return;
+      }
+      viewerStoreMtime = 0;
+      drainRemoteInjections();
+    } catch { /* best-effort */ }
+  }, 3000);
+  remoteAttachTimer.unref?.();
   void bag.restoreLeadSteeringFromDisk();
-  return createEngineApi(bag);
+  return api;
 }

package/src/tui/index.jsx

@@ -12,6 +12,7 @@ import { dirname, join } from 'node:path';
 import { performance } from 'node:perf_hooks';
 import { format } from 'node:util';
 import { App } from './App.jsx';
+import { cancelPendingMouseTrackingRestores } from './app/use-mouse-input.mjs';
 import { createEngineSession } from './engine.mjs';
 import { scheduleRenderFrameAck } from './engine/render-timing.mjs';
 import { installProcessSignalCleanup } from '../runtime/shared/process-shutdown.mjs';
@@ -451,6 +452,7 @@ export async function runTui({ provider, model, toolMode, remote, forceOnboardin
   const restoreTerminal = () => {
     if (restored) return;
     restored = true;
+    cancelPendingMouseTrackingRestores();
     restorePrimedInput();
     try {
       process.stdout.write(

package/src/tui/lib/voice-setup.mjs

@@ -50,11 +50,14 @@ export function isVoiceEnabled() {
 /** Read the managed runtime state without installing or mutating anything. */
 export async function getVoiceStatus({ dataDir = resolvePluginData() } = {}) {
   const fetcher = await loadVoiceRuntimeFetcher();
-  const runtime = fetcher.resolveVoiceRuntime(dataDir);
+  const runtime = fetcher.resolveVoiceRuntime(dataDir, {
+    modelId: fetcher.selectVoiceModelId(readSection('voice')),
+  });
   return {
     enabled: isVoiceEnabled(),
     busy: isVoiceInstallBusy(),
     installed: runtime.installed === true,
+    modelId: runtime.modelId,
     components: {
       whisper: Boolean(runtime.binary && runtime.serverCmd),
       model: Boolean(runtime.model),
@@ -112,7 +115,10 @@ function makeThrottledProgressNotice({ pushNotice, setProgressHint } = {}, inter
  */
 export async function ensureVoiceRuntimeReady({ dataDir = resolvePluginData(), pushNotice, setProgressHint } = {}) {
   const fetcher = await loadVoiceRuntimeFetcher();
-  let runtime = fetcher.resolveVoiceRuntime(dataDir);
+  // System-language default: Korean devices install the Korean fine-tune,
+  // everything else the standard multilingual Q8. voice.model overrides.
+  const modelId = fetcher.selectVoiceModelId(readSection('voice'));
+  let runtime = fetcher.resolveVoiceRuntime(dataDir, { modelId });
   if (runtime.installed) return runtime;
 
   const onProgress = makeThrottledProgressNotice({ pushNotice, setProgressHint });
@@ -120,13 +126,13 @@ export async function ensureVoiceRuntimeReady({ dataDir = resolvePluginData(), p
     await fetcher.ensureWhisperRuntime(dataDir, onProgress);
   }
   if (!runtime.model) {
-    await fetcher.ensureWhisperModel(dataDir, onProgress);
+    await fetcher.ensureWhisperModel(dataDir, onProgress, modelId);
   }
   if (!runtime.ffmpeg) {
     await fetcher.ensureFfmpegRuntime(dataDir, onProgress);
   }
 
-  runtime = fetcher.resolveVoiceRuntime(dataDir);
+  runtime = fetcher.resolveVoiceRuntime(dataDir, { modelId });
   if (!runtime.installed) {
     throw new Error('voice runtime install did not complete (still missing a required component)');
   }

package/src/tui/paste-attachments.mjs

@@ -145,7 +145,10 @@ export function splitPastedImagePathCandidates(text) {
   return out;
 }
 
-async function imageAttachmentFromBuffer(buffer, mimeType, { filename = 'Pasted image', sourcePath = '' } = {}) {
+// Exported for the desktop engine capability surface (resizeImage): the GUI
+// composer routes its attachments through this SAME pipeline so desktop and
+// TUI submit byte-identical image payloads.
+export async function imageAttachmentFromBuffer(buffer, mimeType, { filename = 'Pasted image', sourcePath = '' } = {}) {
   if (!Buffer.isBuffer(buffer) || buffer.length === 0) throw new Error('image is empty');
   const ext = (mimeType || 'image/png').split('/')[1] || 'png';
   const resized = await resizeImageBuffer(buffer, ext);

package/src/vendor/statusline/src/gateway/session-routes.mjs

@@ -6,6 +6,24 @@ import { CLAUDE_CURRENT_MODE } from './claude-current.mjs';
 
 const STORE_FILE = 'gateway-session-routes.json';
 const UUIDISH_SESSION_RE = /^[0-9a-z][0-9a-z._-]{7,}$/i;
+// Route entries were written forever and never pruned — a two-week desktop
+// installation reached a 1.1MB store that readStore() parsed synchronously on
+// every route lookup. Bound the store by age and count; a route older than the
+// TTL belongs to a session whose provider pin is long since irrelevant.
+const ROUTE_TTL_MS = 14 * 24 * 60 * 60 * 1000;
+const MAX_SESSION_ROUTES = 300;
+const MAX_HOST_ROUTES = 100;
+
+function pruneRouteMap(map, now, cap) {
+  const entries = Object.entries(map || {})
+    .filter(([, route]) => {
+      const at = Number(route?.updatedAt) || 0;
+      return at > 0 && (now - at) <= ROUTE_TTL_MS;
+    })
+    .sort((a, b) => (Number(b[1]?.updatedAt) || 0) - (Number(a[1]?.updatedAt) || 0))
+    .slice(0, cap);
+  return Object.fromEntries(entries);
+}
 
 function cleanString(value) {
   const s = typeof value === 'string' ? value.trim() : '';
@@ -163,7 +181,12 @@ export function writeGatewaySessionRoutes(entries = []) {
           sessions[sid] = { ...route, sessionId: sid, updatedAt };
         }
       }
-      return { version: 2, updatedAt, sessions, sessionHosts };
+      return {
+        version: 2,
+        updatedAt,
+        sessions: pruneRouteMap(sessions, updatedAt, MAX_SESSION_ROUTES),
+        sessionHosts: pruneRouteMap(sessionHosts, updatedAt, MAX_HOST_ROUTES),
+      };
     }, { compact: true, fsync: false, fsyncDir: false });
     return true;
   } catch {

package/src/workflows/default/WORKFLOW.md

@@ -15,6 +15,9 @@ approval.
 
 On approval, fan out at maximum width: one agent per independent scope, all
 spawned in one turn; only a scope that depends on another's output waits.
+Split the plan into as many scopes as possible: disjoint file/module sets
+are independent; merge only on a true output dependency. Prefer parallel
+scopes over sequential slices in one agent.
 
 Route by complexity: simple, well-understood implementation goes to Worker;
 complex or investigative implementation goes to Heavy Worker; Lead itself

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

@@ -72,6 +72,20 @@ export function displayStringWidth(str) {
     return displayWidthWith(str, AMBIGUOUS_WIDE);
 }
 
+/**
+ * Extra terminal cells that must be emitted as literal spaces after a glyph.
+ * Windows Terminal paints the policy glyphs across two cells but advances its
+ * text cursor by the plain string-width value (one), so Ink's zero-byte wide
+ * placeholder alone does not separate the following glyph. Native wide glyphs
+ * (CJK/emoji) return zero because the terminal already advances two cells.
+ */
+export function syntheticWideCellPadding(str) {
+    const s = String(str ?? '');
+    if (!AMBIGUOUS_WIDE || !PROBLEM_RE.test(s))
+        return 0;
+    return Math.max(0, displayStringWidth(s) - stringWidth(s));
+}
+
 /** widest-line equivalent under the policy. */
 export function displayWidestLine(text) {
     let lineWidth = 0;

package/vendor/ink/build/output.js

@@ -1,10 +1,10 @@
-import sliceAnsi from 'slice-ansi';
 import { styledCharsFromTokens, styledCharsToString, tokenize, } from '@alcalzone/ansi-tokenize';
+import { sliceTextByDisplayWidth } from './wrap-text.js';
 // [mixdog fork] use the shared display-width policy so ink's per-character
 // advance + width cache treat circled digits / arrows as 2 cells under Windows
 // Terminal, matching OUR wrap/row math. See display-width.js (kept in sync with
 // src/tui/display-width.mjs).
-import { displayStringWidth as stringWidth } from './display-width.js';
+import { displayStringWidth as stringWidth, syntheticWideCellPadding } from './display-width.js';
 const RGB_COLOR_RE = /^rgb\(\s*(\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3})\s*\)$/;
 const rgbStyle = (value, type, fallback) => {
     const match = RGB_COLOR_RE.exec(String(value || ''));
@@ -191,7 +191,12 @@ export default class Output {
                             const from = x < clip.x1 ? clip.x1 - x : 0;
                             const width = this.caches.getStringWidth(line);
                             const to = x + width > clip.x2 ? clip.x2 - x : width;
-                            return sliceAnsi(line, from, to);
+                            // [mixdog fork] `from`/`to` are display-cell offsets.
+                            // Plain slice-ansi treats enclosed alphanumerics as
+                            // one cell and lets clipped transcript body text
+                            // overwrite cells to its right. Slice with the same
+                            // wide-glyph policy used by wrap/measure/output.
+                            return sliceTextByDisplayWidth(line, from, to);
                         });
                         if (x < clip.x1) {
                             x = clip.x1;
@@ -253,6 +258,14 @@ export default class Output {
                         currentLine[offsetX] = character;
                         // Determine printed width using string-width to align with measurement
                         const characterWidth = Math.max(1, this.caches.getStringWidth(character.value));
+                        // Policy-widened ambiguous glyphs need a REAL spacer in the
+                        // terminal byte stream: unlike native CJK/emoji, WT paints
+                        // their ink wide but advances only one cell. Keep the grid
+                        // placeholder empty for layout/selection; serialization
+                        // materializes only the synthetic tail cells as spaces.
+                        const syntheticPadding = characterWidth > 1
+                            ? syntheticWideCellPadding(character.value)
+                            : 0;
                         // For multi-column characters, clear following cells to avoid stray spaces/artifacts
                         if (characterWidth > 1) {
                             for (let index = 1; index < characterWidth; index++) {
@@ -261,6 +274,7 @@ export default class Output {
                                     value: '',
                                     fullWidth: false,
                                     styles: character.styles,
+                                    syntheticPad: syntheticPadding > 0 && index >= characterWidth - syntheticPadding,
                                 };
                             }
                         }
@@ -508,6 +522,13 @@ export default class Output {
                 if (item === undefined) {
                     continue;
                 }
+                // A synthetic wide-cell placeholder is already included in
+                // the leading glyph's modeled width. Emit a literal blank so WT's
+                // cursor advances, but do not count that blank a second time.
+                if (item.syntheticPad) {
+                    lineWithinWidth.push({ ...item, value: ' ' });
+                    continue;
+                }
                 const value = item.value ?? '';
                 if (value === '') {
                     lineWithinWidth.push(item);

package/vendor/ink/build/wrap-text.d.ts

@@ -1,3 +1,5 @@
 import { type Styles } from './styles.js';
+export declare const sliceTextByDisplayWidthWithPolicy: (line: string, from: number, to: number, wide: boolean) => string;
+export declare const sliceTextByDisplayWidth: (line: string, from: number, to: number) => string;
 declare const wrapText: (text: string, maxWidth: number, wrapType: Styles["textWrap"]) => string;
 export default wrapText;