mixdog 0.9.19 → 0.9.20

package/src/session-runtime/workflow-agents-api.mjs

@@ -0,0 +1,238 @@
+import { clean, hasOwn, sessionHasConversationMessages } from './session-text.mjs';
+import { isKnownProvider } from '../standalone/provider-admin.mjs';
+import {
+  normalizeWorkflowRoute,
+  upsertWorkflowPreset,
+  workflowPresetId,
+  WORKFLOW_ROUTE_SLOTS,
+  FIXED_AGENT_SLOTS,
+  agentPresetSlot,
+  normalizeAgentId,
+  normalizeWorkflowId,
+  DEFAULT_WORKFLOW_ID,
+  normalizeSearchRouteConfig,
+} from './workflow.mjs';
+import { ONBOARDING_VERSION } from './quick-search-models.mjs';
+import { findOutputStyle } from './output-styles.mjs';
+import { ensureProviderEnabled } from './config-helpers.mjs';
+import { fastCapableFor, saveModelSettings } from './model-capabilities.mjs';
+
+// Onboarding + agents/workflows/output-style selection surface. Extracted
+// verbatim from the runtime API object; stateless helpers are imported directly
+// and the runtime injects live getters/setters for the mutable config/route/
+// session locals plus the closure callbacks.
+export function createWorkflowAgentsApi(deps) {
+  const {
+    getConfig, getRoute, setRouteState, getSession, setSession, getConfigHasSecrets,
+    cfgMod, reg, mgr, STANDALONE_DATA_DIR,
+    resolveRoute, lookupModelMeta, adoptConfig, saveConfigAndAdopt, displayConfig,
+    agentRouteFromConfig, loadAgentDefinition, activeWorkflowId, listWorkflowPacks,
+    loadWorkflowPack, workflowSummary,
+    getOutputStyleStatusCached, seedOutputStyleStatusCache, scheduleOutputStyleSave,
+    recreateCurrentSessionIfReady, notifyFnForSession, invalidateContextStatusCache,
+  } = deps;
+  return {
+    async completeOnboarding(payload = {}) {
+      // Only fall back to the live runtime route when the caller actually sent a
+      // defaultRoute. The onboarding "partial save" path (Main left unset, only
+      // Search/agent picks) omits defaultRoute entirely and must NOT persist the
+      // current route as Main or recreate the session.
+      const config = getConfig();
+      const defaultRoute = hasOwn(payload, 'defaultRoute')
+        ? normalizeWorkflowRoute(payload.defaultRoute, getRoute())
+        : null;
+      const workflowInput = payload.workflowRoutes && typeof payload.workflowRoutes === 'object'
+        ? payload.workflowRoutes
+        : {};
+      const nextConfig = { ...config };
+      if (hasOwn(payload, 'defaultProvider')) {
+        const requested = clean(payload.defaultProvider);
+        if (requested) {
+          if (!isKnownProvider(requested)) throw new Error(`unknown provider "${payload.defaultProvider}"`);
+          nextConfig.defaultProvider = requested;
+        }
+      }
+      let presets = Array.isArray(nextConfig.presets) ? nextConfig.presets.slice() : [];
+      const workflowRoutes = { ...(nextConfig.workflowRoutes || {}) };
+      const touchedWorkflowSlots = new Set();
+
+      if (defaultRoute) {
+        presets = upsertWorkflowPreset(presets, 'lead', defaultRoute);
+        workflowRoutes.lead = defaultRoute;
+        nextConfig.default = workflowPresetId('lead');
+      }
+
+      for (const slot of WORKFLOW_ROUTE_SLOTS) {
+        const normalized = normalizeWorkflowRoute(workflowInput[slot]);
+        if (!normalized) continue;
+        workflowRoutes[slot] = normalized;
+        presets = upsertWorkflowPreset(presets, slot, normalized);
+        touchedWorkflowSlots.add(slot);
+      }
+
+      nextConfig.presets = presets;
+      nextConfig.workflowRoutes = workflowRoutes;
+      nextConfig.maintenance = {
+        ...(nextConfig.maintenance || {}),
+        ...(touchedWorkflowSlots.has('explorer') ? { explore: normalizeWorkflowRoute(workflowRoutes.explorer) } : {}),
+        ...(touchedWorkflowSlots.has('memory') ? { memory: normalizeWorkflowRoute(workflowRoutes.memory) } : {}),
+      };
+      const agentInput = payload.agentRoutes && typeof payload.agentRoutes === 'object'
+        ? payload.agentRoutes
+        : null;
+      if (agentInput) {
+        const nextAgents = { ...(nextConfig.agents || {}) };
+        const nextMaintenance = { ...(nextConfig.maintenance || {}) };
+        for (const agent of FIXED_AGENT_SLOTS) {
+          const routeToSave = normalizeWorkflowRoute(agentInput[agent.id]);
+          if (!routeToSave) continue;
+          nextAgents[agent.id] = routeToSave;
+          presets = upsertWorkflowPreset(presets, agentPresetSlot(agent.id), routeToSave);
+          if (agent.workflowSlot) {
+            workflowRoutes[agent.workflowSlot] = routeToSave;
+            presets = upsertWorkflowPreset(presets, agent.workflowSlot, routeToSave);
+            if (agent.id === 'explore') nextMaintenance.explore = routeToSave;
+            if (agent.id === 'maintainer') nextMaintenance.memory = routeToSave;
+          }
+        }
+        nextConfig.agents = nextAgents;
+        nextConfig.presets = presets;
+        nextConfig.workflowRoutes = workflowRoutes;
+        nextConfig.maintenance = nextMaintenance;
+      }
+      nextConfig.onboarding = {
+        ...(nextConfig.onboarding || {}),
+        completed: true,
+        version: ONBOARDING_VERSION,
+        completedAt: new Date().toISOString(),
+      };
+
+      if (payload.searchRoute) {
+        const searchToSave = normalizeSearchRouteConfig(payload.searchRoute);
+        if (searchToSave) nextConfig.searchRoute = searchToSave;
+      }
+
+      saveConfigAndAdopt(nextConfig);
+      if (defaultRoute) {
+        setRouteState(resolveRoute(getConfig(), { provider: defaultRoute.provider, model: defaultRoute.model, effort: defaultRoute.effort }));
+        const session = getSession();
+        if (session?.id) mgr.closeSession(session.id, 'cli-onboarding-complete');
+        await recreateCurrentSessionIfReady();
+      }
+      return this.getOnboardingStatus();
+    },
+    listAgents() {
+      const dataDir = cfgMod.getPluginData?.() || STANDALONE_DATA_DIR;
+      const config = getConfig();
+      return FIXED_AGENT_SLOTS.map((agent) => ({
+        ...agent,
+        locked: true,
+        route: agentRouteFromConfig(config, agent.id, dataDir),
+        definition: loadAgentDefinition(dataDir, agent.id),
+      }));
+    },
+    listWorkflows() {
+      const currentConfig = displayConfig();
+      const dataDir = cfgMod.getPluginData?.() || STANDALONE_DATA_DIR;
+      const active = activeWorkflowId(currentConfig);
+      return listWorkflowPacks(dataDir).map((workflow) => ({
+        id: workflow.id,
+        name: workflow.name,
+        description: workflow.description,
+        source: workflow.source,
+        active: workflow.id === active,
+        agents: workflow.agents,
+      }));
+    },
+    getOutputStyle() {
+      return getOutputStyleStatusCached();
+    },
+    listOutputStyles() {
+      return getOutputStyleStatusCached();
+    },
+    async setOutputStyle(value) {
+      const before = getOutputStyleStatusCached({ fresh: true });
+      const selected = findOutputStyle(value, before.styles);
+      if (!selected) {
+        const names = before.styles.map((style) => style.label || style.id).join(', ') || 'Default';
+        throw new Error(`output style must be one of ${names}`);
+      }
+      // Adopt in-memory immediately so same-tick readers see the new style;
+      // persist off the key-handler tick via the flushOutputStyleSave debounce.
+      const nextConfig = { ...getConfig(), outputStyle: selected.id };
+      if (nextConfig.agent && typeof nextConfig.agent === 'object' && !Array.isArray(nextConfig.agent)) {
+        const agent = { ...nextConfig.agent };
+        delete agent.outputStyle;
+        nextConfig.agent = agent;
+      }
+      adoptConfig(nextConfig);
+      scheduleOutputStyleSave(selected.id);
+      const freshStatus = { configured: selected.id, current: selected, styles: before.styles };
+      seedOutputStyleStatusCache(freshStatus);
+      const session = getSession();
+      const hasConversation = sessionHasConversationMessages(session);
+      let appliedToCurrentSession = !hasConversation;
+      if (session?.id && !hasConversation) {
+        const closedSessionId = session.id;
+        mgr.closeSession(closedSessionId, 'cli-output-style-switch');
+        setSession(null);
+        setTimeout(() => {
+          recreateCurrentSessionIfReady().catch((err) => {
+            try {
+              notifyFnForSession(closedSessionId)(
+                `Failed to start a new session after output style change: ${err?.message || err}`,
+                { level: 'error' },
+              );
+            } catch {}
+          });
+        }, 0);
+      }
+      invalidateContextStatusCache();
+      return { ...freshStatus, appliedToCurrentSession };
+    },
+    async setWorkflow(workflowId) {
+      const id = normalizeWorkflowId(workflowId, DEFAULT_WORKFLOW_ID);
+      const dataDir = cfgMod.getPluginData?.() || STANDALONE_DATA_DIR;
+      const pack = loadWorkflowPack(dataDir, id);
+      if (!pack || pack.id !== id) throw new Error(`workflow "${workflowId}" not found`);
+      const nextConfig = { ...getConfig() };
+      nextConfig.workflow = { ...(nextConfig.workflow || {}), active: id };
+      saveConfigAndAdopt(nextConfig);
+      return workflowSummary(pack);
+    },
+    async setAgentRoute(agentId, next) {
+      const id = normalizeAgentId(agentId);
+      if (!id) throw new Error(`unknown agent "${agentId}"`);
+      let selectedRoute = resolveRoute(getConfig(), { ...(next || {}) });
+      await reg.initProviders(ensureProviderEnabled(getConfig(), selectedRoute.provider));
+      const modelMeta = await lookupModelMeta(selectedRoute.provider, selectedRoute.model);
+      const fastCapable = fastCapableFor(selectedRoute.provider, modelMeta);
+      selectedRoute = { ...selectedRoute, fast: fastCapable ? selectedRoute.fast === true : false };
+      adoptConfig(saveModelSettings(cfgMod, selectedRoute, { fastCapable, baseConfig: getConfig() }), { hasSecrets: getConfigHasSecrets() });
+
+      const routeToSave = normalizeWorkflowRoute(selectedRoute);
+      if (!routeToSave) throw new Error('agent route requires provider and model');
+      const agent = FIXED_AGENT_SLOTS.find((item) => item.id === id);
+      const nextConfig = { ...getConfig() };
+      nextConfig.agents = {
+        ...(nextConfig.agents || {}),
+        [id]: routeToSave,
+      };
+      nextConfig.presets = upsertWorkflowPreset(nextConfig.presets, agentPresetSlot(id), routeToSave);
+      if (agent?.workflowSlot) {
+        nextConfig.workflowRoutes = {
+          ...(nextConfig.workflowRoutes || {}),
+          [agent.workflowSlot]: routeToSave,
+        };
+        nextConfig.presets = upsertWorkflowPreset(nextConfig.presets, agent.workflowSlot, routeToSave);
+        nextConfig.maintenance = {
+          ...(nextConfig.maintenance || {}),
+          ...(id === 'explore' ? { explore: routeToSave } : {}),
+          ...(id === 'maintainer' ? { memory: routeToSave } : {}),
+        };
+      }
+      saveConfigAndAdopt(nextConfig);
+      return routeToSave;
+    },
+  };
+}

package/src/standalone/agent-tool.mjs

@@ -99,14 +99,14 @@ const DEFAULT_SPAWN_PREP_TIMEOUT_MS = envTimeoutMs('MIXDOG_AGENT_SPAWN_PREP_TIME
 // Global spawn-start stagger: unlimited-N parallel fan-out otherwise fires all
 // first provider calls in the same instant, racing the server-side prompt-
 // cache write/propagation window. Bench (parallel-10, identical-ms starts):
-// 12.5% cache miss; 3000ms lane stagger: 4.3%; 166ms: 6.0%. 2000ms default
+// 12.5% cache miss; 3000ms lane stagger: 4.3%; 166ms: 6.0%. 1000ms default
 // picked as a low-cost middle ground. Chain (not a fixed lane count) so it
 // scales to any N: each new spawn's start is pushed to at least STAGGER_MS
 // after the previous spawn's start; sequential/non-overlapping spawns (now
 // already past the window) pay zero added latency. MIXDOG_SPAWN_STAGGER_MS=0
 // disables. Applied inside the deferred job body (see startDeferredSpawnJob)
 // so the agent tool call itself still returns task_id immediately.
-const SPAWN_STAGGER_MS = envTimeoutMs('MIXDOG_SPAWN_STAGGER_MS', 2000);
+const SPAWN_STAGGER_MS = envTimeoutMs('MIXDOG_SPAWN_STAGGER_MS', 1000);
 let lastSpawnStartAt = 0;
 async function waitForSpawnStagger() {
   if (SPAWN_STAGGER_MS <= 0) return;

package/src/standalone/channel-worker.mjs

@@ -6,6 +6,7 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import { startChildGuardian } from '../runtime/shared/child-guardian.mjs';
 import { appendBuffered } from '../runtime/shared/buffered-appender.mjs';
 import { scrubLoaderVars } from '../runtime/agent/orchestrator/tools/env-scrub.mjs';
+import { rotateBoundedLog, PLUGIN_LOG_MAX_BYTES, PLUGIN_LOG_KEEP_BYTES } from '../lib/mixdog-debug.cjs';
 
 const CHANNEL_TOOLS = new Set([
   'reply',
@@ -98,6 +99,9 @@ export function createStandaloneChannelWorker({
   let inFlightToken = 0;
   let inFlightWatchdog = null;
   const logPath = join(dataDir, 'channels-worker-standalone.log');
+  // One-shot bound at own-process boot: this runtime may never pass through
+  // the channels-worker rotation path, so cap the log writer-side.
+  rotateBoundedLog(logPath, PLUGIN_LOG_MAX_BYTES, PLUGIN_LOG_KEEP_BYTES);
   const useProcessWorker = process.env.MIXDOG_CHANNEL_WORKER_PROCESS !== '0';
   const clientDir = join(runtimeRoot(), 'channel-clients');
   const clientPath = join(clientDir, `${process.pid}.json`);

package/src/standalone/memory-runtime-proxy.mjs

@@ -6,6 +6,7 @@ import { tmpdir } from 'node:os';
 import { pathToFileURL } from 'node:url';
 import { claimSingletonOwner, handoffSingletonOwner, readSingletonOwner, releaseSingletonOwner } from '../runtime/shared/singleton-owner.mjs';
 import { scrubLoaderVars } from '../runtime/agent/orchestrator/tools/env-scrub.mjs';
+import { rotateBoundedLog, PLUGIN_LOG_MAX_BYTES, PLUGIN_LOG_KEEP_BYTES } from '../lib/mixdog-debug.cjs';
 
 function logLine(path, line) {
   try {
@@ -56,6 +57,19 @@ function delay(ms) {
 }
 
 const TRANSIENT_MEMORY_RPC_BACKOFF_MS = 400;
+// A child that dies during startup with one of these signatures is a hard,
+// deterministic failure (bad entry path, syntax/require error) — never a
+// transient owner-lock race. Surface it fast instead of burning the ready-wait.
+function looksLikeStartupCrash(text) {
+  // Only genuinely deterministic loader/parse failures. Runtime errors like
+  // TypeError/ReferenceError can be transient init races — matching them would
+  // poison crashState and cache a hard failure for a recoverable spawn.
+  return /Cannot find module|MODULE_NOT_FOUND|ERR_MODULE_NOT_FOUND|SyntaxError/i.test(String(text || ''));
+}
+// Once a spawn crashes deterministically, short-circuit re-forks for this
+// window so a persistent crash-loop returns the cached reason immediately
+// instead of paying spawn+ready-wait on every call.
+const MEMORY_CRASH_COOLDOWN_MS = Math.max(0, Number(process.env.MIXDOG_MEMORY_CRASH_COOLDOWN_MS) || 30_000);
 
 function isConnResetLikeError(err) {
   const code = String(err?.code || '');
@@ -141,6 +155,9 @@ export function createStandaloneMemoryRuntime({
   if (!dataDir) throw new Error('memory runtime dataDir is required');
 
   const logPath = join(dataDir, 'memory-runtime-proxy.log');
+  // One-shot bound at own-process boot: this runtime may never pass through
+  // the channels-worker rotation path, so cap the log writer-side.
+  rotateBoundedLog(logPath, PLUGIN_LOG_MAX_BYTES, PLUGIN_LOG_KEEP_BYTES);
   const ownerPath = join(dataDir, 'memory-runtime-owner.json');
   const singletonEnabled = process.env.MIXDOG_MEMORY_SINGLETON !== '0';
   const idleTtlMs = Math.max(0, Number(process.env.MIXDOG_MEMORY_IDLE_TTL_MS) || 10 * 60_000);
@@ -148,6 +165,7 @@ export function createStandaloneMemoryRuntime({
   let startPromise = null;
   let child = null;
   let nextCallId = 1;
+  let crashState = null; // { reason, at } — cached deterministic spawn crash
 
   function invalidateMemoryRuntimeAfterTransient(err) {
     portCache = null;
@@ -244,11 +262,27 @@ export function createStandaloneMemoryRuntime({
   async function start() {
     if (portCache) {
       const port = await findLivePort();
-      if (port) return { running: true, port, mode: 'http-proxy' };
+      if (port) { crashState = null; return { running: true, port, mode: 'http-proxy' }; }
       portCache = null;
     }
     const existing = await findLivePort();
-    if (existing) return { running: true, port: existing, mode: 'http-proxy' };
+    if (existing) { crashState = null; return { running: true, port: existing, mode: 'http-proxy' }; }
+    // Persistent crash-loop guard: no live daemon and a recent deterministic
+    // spawn crash → fail fast with the cached reason, don't re-fork per call.
+    // But a healthy singleton owner may be mid-boot and not yet advertising a
+    // port; probe/await it before trusting cached crashState so a recovering
+    // daemon isn't handed a stale hard failure.
+    if (crashState && Date.now() - crashState.at < MEMORY_CRASH_COOLDOWN_MS) {
+      if (singletonEnabled) {
+        const owner = readSingletonOwner(ownerPath);
+        if (owner.alive) {
+          const live = await waitForPort(15_000);
+          crashState = null;
+          return { running: true, port: live, mode: 'http-proxy' };
+        }
+      }
+      throw new Error(crashState.reason);
+    }
     if (startPromise) {
       const port = await startPromise;
       return { running: true, port, mode: 'http-proxy' };
@@ -309,9 +343,12 @@ export function createStandaloneMemoryRuntime({
           meta: { cwd, launcherPid: process.pid },
         });
       }
+      let stderrTail = '';
       child.stderr?.on('data', chunk => {
-        const text = String(chunk || '').trimEnd();
-        if (text) logLine(logPath, text);
+        const text = String(chunk || '');
+        const trimmed = text.trimEnd();
+        if (trimmed) logLine(logPath, trimmed);
+        stderrTail = (stderrTail + text).slice(-4000);
       });
       child.on('exit', () => {
         if (singletonEnabled && childPid) releaseSingletonOwner(ownerPath, childPid);
@@ -332,24 +369,37 @@ export function createStandaloneMemoryRuntime({
         });
         child.once('exit', (code, signal) => {
           clearTimeout(timer);
-          rejectReady(new Error(`memory worker exited before ready (${signal || code || 'unknown'})`));
+          const tail = stderrTail.trim().split('\n').slice(-8).join('\n');
+          const detail = tail ? `: ${tail}` : '';
+          const err = new Error(`memory worker exited before ready (${signal || code || 'unknown'})${detail}`);
+          err.stderrTail = tail;
+          rejectReady(err);
         });
       });
 
       try {
         await ready;
       } catch (err) {
+        // A deterministic startup crash (bad entry path -> MODULE_NOT_FOUND,
+        // syntax/require errors) is not an owner-lock race: cache the reason
+        // for the cooldown window and fail immediately with the stderr tail
+        // instead of burning waitForPort() on a child that will never publish.
+        const msg = String(err?.message || err || '');
+        if (looksLikeStartupCrash(err?.stderrTail || msg)) {
+          crashState = { reason: msg, at: Date.now() };
+          throw err;
+        }
         // Loser fallback: two proxies (TUI host vs channels worker) can race to
         // fork; the child that lost the owner-lock exits before ready. Instead
         // of propagating "exited before ready" (which would surface as no
         // daemon), wait for the WINNER's daemon to publish a live port and use
         // it. Only rethrow if no live daemon appears in the window.
-        const msg = String(err?.message || err || '');
         const raceLoss = /exited before ready|degraded|ready timeout|owner lock|lock/i.test(msg);
         if (!raceLoss) throw err;
         return await waitForPort(30_000);
       }
       const port = await waitForPort(15_000);
+      crashState = null;
       try { child.disconnect?.(); } catch {}
       try { child.unref?.(); } catch {}
       try { child.stderr?.unref?.(); } catch {}

package/src/tui/App.jsx

@@ -845,34 +845,6 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
     }, 2200);
   }, []);
 
-  // Copy the currently-highlighted selection to the OS clipboard. ink's fork
-  // refreshed store.getRenderSelectionText() on the synchronous render that the
-  // final setSelection() triggered, so the selected text is ready to read.
-  const copySelection = useCallback((attempt = 0) => {
-    const renderText = store.getRenderSelectionText?.();
-    const remembered = selectionTextRef.current || '';
-    // A selection that has partially scrolled out of the viewport renders —
-    // and therefore harvests — only its visible rows. The remembered text
-    // (captured while the selection was last fully painted) is the fuller
-    // copy; prefer whichever is longer so scrolling never shrinks a copy.
-    const text = renderText == null
-      ? remembered
-      : (remembered.length > renderText.length ? remembered : renderText);
-    if ((!text || !text.trim()) && attempt < 4) {
-      setTimeout(() => copySelection(attempt + 1), attempt === 0 ? 0 : 24);
-      return;
-    }
-    if (!text || !text.trim()) return;
-    selectionTextRef.current = text;
-    copyToClipboard(text)
-      .then(() => {
-        const lines = text.split('\n').length;
-        const chars = text.length;
-        showSelectionCopyHint(`copied ${chars} char${chars === 1 ? '' : 's'}${lines > 1 ? ` · ${lines} lines` : ''}`, 'plain');
-      })
-      .catch((e) => showSelectionCopyHint(`copy failed: ${e?.message || e}`, 'error'));
-  }, [store, showSelectionCopyHint]);
-
   // ── Post-mount input gate ──────────────────────────────────────────────
   // Let one event-loop poll pass so Ink processes (and discards, because
   // PromptInput is still disabled) any keystrokes queued during boot/first
@@ -1047,6 +1019,8 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
     scrollTranscriptRows,
     queueScrollCoalesced,
     moveSelectionFocus,
+    getStitchedSelectionText,
+    clearStitchBuffer,
   } = useTranscriptScroll({
     store,
     frameColumns,
@@ -1067,6 +1041,42 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
     selectionTextRef,
   });
 
+  // Copy the currently-highlighted selection to the OS clipboard. ink's fork
+  // refreshed store.getRenderSelectionText() on the synchronous render that the
+  // final setSelection() triggered, so the selected text is ready to read.
+  // NOTE: declared after useTranscriptScroll — the dependency array below
+  // evaluates getStitchedSelectionText at render time, so referencing it
+  // before the destructuring above is a TDZ ReferenceError.
+  const copySelection = useCallback((attempt = 0) => {
+    const renderText = store.getRenderSelectionText?.();
+    const remembered = selectionTextRef.current || '';
+    // A selection that has partially scrolled out of the viewport renders —
+    // and therefore harvests — only its visible rows. The remembered text
+    // (captured while the selection was last fully painted) is the fuller
+    // copy; prefer whichever is longer so scrolling never shrinks a copy.
+    let text = renderText == null
+      ? remembered
+      : (remembered.length > renderText.length ? remembered : renderText);
+    // The stitch buffer accumulates rows harvested across every scroll position
+    // during a transcript drag, so it can reconstruct rows that scrolled out of
+    // view entirely (neither renderText nor the last-full-paint remembered text
+    // ever saw them). Prefer it only when it is strictly longer than both.
+    const stitched = getStitchedSelectionText?.() || '';
+    if (stitched.length > text.length) text = stitched;
+    if ((!text || !text.trim()) && attempt < 4) {
+      setTimeout(() => copySelection(attempt + 1), attempt === 0 ? 0 : 24);
+      return;
+    }
+    if (!text || !text.trim()) return;
+    selectionTextRef.current = text;
+    copyToClipboard(text)
+      .then(() => {
+        const lines = text.split('\n').length;
+        const chars = text.length;
+        showSelectionCopyHint(`copied ${chars} char${chars === 1 ? '' : 's'}${lines > 1 ? ` · ${lines} lines` : ''}`, 'plain');
+      })
+      .catch((e) => showSelectionCopyHint(`copy failed: ${e?.message || e}`, 'error'));
+  }, [store, showSelectionCopyHint, getStitchedSelectionText]);
 
   useEffect(() => () => {
     stopSmoothScroll();
@@ -1102,6 +1112,7 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
     queueScrollCoalesced,
     setSlashIndex,
     setMeasuredRowsVersion,
+    clearStitchBuffer,
   });
 
   // Enable extended keyboard reporting (kitty + xterm modifyOtherKeys)

package/src/tui/app/core-memory-picker.mjs

@@ -47,7 +47,7 @@ export function createCoreMemoryPicker({
         const rows = [
           {
             value: 'memory-toggle',
-            label: 'Memory on/off',
+            label: 'Memory',
             meta: memoryOn ? 'On' : 'Off',
             description: memoryOn
               ? 'Background memory cycles on'

package/src/tui/app/use-mouse-input.mjs

@@ -54,6 +54,7 @@ export function useMouseInput({
   queueScrollCoalesced,
   setSlashIndex,
   setMeasuredRowsVersion,
+  clearStitchBuffer,
 }) {
   const mouseZoomPassthroughTimerRef = useRef(null);
 
@@ -353,6 +354,8 @@ export function useMouseInput({
               const hi = { x: wr.x2, y: wr.y2 };
               const rect = linearSelection(lo, hi);
               stopSmoothScroll();
+              // Fresh word/line anchor: reset the stitch buffer (see char-drag).
+              clearStitchBuffer?.();
               dragRef.current = {
                 anchor: { x, y },
                 anchorScroll: region === 'transcript' ? scrollTargetRef.current : 0,
@@ -376,6 +379,9 @@ export function useMouseInput({
           // there; keep the transcript scroll anchor only for the transcript.
           // Plain single press clears any word/line anchorSpan (char-drag mode).
           stopSmoothScroll();
+          // Fresh char-drag anchor: drop any rows stitched from a prior
+          // selection so the new drag reconstructs only its own content.
+          clearStitchBuffer?.();
           dragRef.current = {
             anchor: { x, y },
             anchorScroll: region === 'transcript' ? scrollTargetRef.current : 0,

package/src/tui/app/use-transcript-scroll.mjs

@@ -44,6 +44,71 @@ export function useTranscriptScroll({
   // SCROLL_COALESCE_MS). Both call sites accumulate into pendingRows.
   const scrollCoalesceRef = useRef({ pendingRows: 0, timer: null });
   const selectionTextTimerRef = useRef(null);
+  // Stitch buffer: accumulates harvested transcript selection rows across scroll
+  // positions so Ctrl+C copies the FULL drag even after it auto-scrolled past the
+  // viewport. Keyed by scroll-invariant content row = screenY - scrollTarget at
+  // harvest time; value = row text. Only transcript-region drags accumulate.
+  const stitchBufferRef = useRef(new Map());
+  const stitchHarvestTimerRef = useRef(null);
+  // Scroll offset captured at the SCHEDULE (paint) time of the pending harvest —
+  // the deferred timer must key rows by the frame's scroll, not by whatever
+  // scrollTargetRef holds when the timer eventually fires (a scroll in between
+  // would mis-key the rows). Latest schedule wins (latest paint = latest frame).
+  const stitchHarvestScrollRef = useRef(0);
+
+  const clearStitchBuffer = useCallback(() => {
+    stitchBufferRef.current.clear();
+    if (stitchHarvestTimerRef.current) {
+      clearTimeout(stitchHarvestTimerRef.current);
+      stitchHarvestTimerRef.current = null;
+    }
+  }, []);
+
+  // Deferred (like rememberSelectionTextSoon) harvest of the currently visible
+  // selection rows into the stitch buffer. Runs on EVERY transcript selection
+  // paint AND on scroll-shift repaints (the rememberText:false path) so rows
+  // revealed only mid-scroll are captured. Later harvest of a key overwrites,
+  // handling partial↔full endpoint rows on retraction.
+  const harvestStitchRowsSoon = useCallback(() => {
+    if (dragRef.current.region !== 'transcript') return;
+    // Capture the scroll offset for THIS paint (schedule time). If a timer is
+    // already pending, only refresh the captured offset to the latest frame and
+    // reuse the existing timer.
+    stitchHarvestScrollRef.current = Number(scrollTargetRef.current) || 0;
+    if (stitchHarvestTimerRef.current) return;
+    stitchHarvestTimerRef.current = setTimeout(() => {
+      stitchHarvestTimerRef.current = null;
+      if (dragRef.current.region !== 'transcript') return;
+      const rows = store.getRenderSelectionRows?.();
+      if (!Array.isArray(rows)) return;
+      const scroll = stitchHarvestScrollRef.current;
+      for (const row of rows) {
+        if (!row || typeof row.y !== 'number') continue;
+        stitchBufferRef.current.set(row.y - scroll, typeof row.text === 'string' ? row.text : '');
+      }
+    }, 0);
+  }, [store]);
+
+  // Map the CURRENT rect + current scrollTarget onto the content-key range and
+  // join buffered rows sorted by key with '\n' (skipping missing keys). Returns
+  // '' when unusable so callers can fall back to render/remembered text.
+  const getStitchedSelectionText = useCallback(() => {
+    const buf = stitchBufferRef.current;
+    if (!buf.size) return '';
+    if (dragRef.current.region !== 'transcript') return '';
+    const rect = dragRef.current.rect;
+    if (!rect) return '';
+    const y1 = Number(rect.y1);
+    const y2 = Number(rect.y2);
+    if (!Number.isFinite(y1) || !Number.isFinite(y2)) return '';
+    const scroll = Number(scrollTargetRef.current) || 0;
+    const lo = Math.min(y1, y2) - scroll;
+    const hi = Math.max(y1, y2) - scroll;
+    const keys = [...buf.keys()].filter((k) => k >= lo && k <= hi).sort((a, b) => a - b);
+    if (!keys.length) return '';
+    const text = keys.map((k) => buf.get(k)).filter((t) => t != null).join('\n');
+    return text.trim() ? text : '';
+  }, []);
 
   const stopSmoothScroll = useCallback(() => {
     if (!scrollAnimationRef.current) return;
@@ -145,19 +210,24 @@ export function useTranscriptScroll({
         store.setRenderSelection?.(nextRect, { immediate: true });
       }
       if (needsCapture) rememberSelectionTextSoon();
+      if (nextRect) harvestStitchRowsSoon();
       return true;
     }
     state.rect = nextRect;
     state.t = Date.now();
     store.setRenderSelection?.(nextRect, immediate ? { immediate: true } : undefined);
     if (nextRect && rememberText && nextRect.captureText !== false) rememberSelectionTextSoon();
+    if (nextRect) harvestStitchRowsSoon();
     return true;
-  }, [store, rememberSelectionTextSoon]);
+  }, [store, rememberSelectionTextSoon, harvestStitchRowsSoon]);
 
   const applySelectionRect = useCallback((rect) => {
     const clippedRect = withSelectionClip(rect);
     dragRef.current.rect = clippedRect || null;
-    if (!clippedRect) selectionTextRef.current = '';
+    if (!clippedRect) {
+      selectionTextRef.current = '';
+      clearStitchBuffer();
+    }
     const state = selectionPaintRef.current;
     if (state.timer) {
       clearTimeout(state.timer);
@@ -165,7 +235,7 @@ export function useTranscriptScroll({
       state.pending = null;
     }
     paintSelectionRect(clippedRect, { rememberText: true, immediate: true });
-  }, [paintSelectionRect, withSelectionClip]);
+  }, [paintSelectionRect, withSelectionClip, clearStitchBuffer]);
 
   const applySelectionRectThrottled = useCallback((rect) => {
     const clippedRect = withSelectionClip(rect, { captureText: false });
@@ -274,6 +344,8 @@ export function useTranscriptScroll({
     paintState.pending = null;
     if (selectionTextTimerRef.current) clearTimeout(selectionTextTimerRef.current);
     selectionTextTimerRef.current = null;
+    if (stitchHarvestTimerRef.current) clearTimeout(stitchHarvestTimerRef.current);
+    stitchHarvestTimerRef.current = null;
     const coalesceState = scrollCoalesceRef.current;
     if (coalesceState.timer) clearTimeout(coalesceState.timer);
     coalesceState.timer = null;
@@ -512,5 +584,7 @@ export function useTranscriptScroll({
     scrollTranscriptRows,
     queueScrollCoalesced,
     moveSelectionFocus,
+    getStitchedSelectionText,
+    clearStitchBuffer,
   };
 }