mixdog 0.9.95 → 0.9.97

package/src/tui/{engine-local-session.mjs → session-local.mjs}

@@ -1,12 +1,12 @@
 /**
- * src/tui/engine-local-session.mjs - daemon-hosted local session store.
+ * src/tui/session-local.mjs - daemon-hosted local session store.
  *
- * Runs mixdog's session manager inside the singleton backend and exposes the
+ * Runs mixdog's session manager inside the singleton daemon and exposes the
  * subscribable store projected to clients. React/ink consumes the matching
- * remote view through useSyncExternalStore (see hooks/useEngine.mjs).
+ * remote view through useSyncExternalStore (see hooks/useSession.mjs).
  *
- * Product TUI/CLI callers use ./engine.mjs and never load this module directly.
- * The singleton backend daemon and explicit parity tests are the only callers.
+ * Product TUI/CLI callers use ./session.mjs and never load this module directly.
+ * The singleton daemon and explicit parity tests are the only callers.
  */
 import { performance } from 'node:perf_hooks';
 import { mkdtempSync, readFileSync, readdirSync, rmSync, statSync, watch, writeFileSync } from 'node:fs';
@@ -29,8 +29,8 @@ 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';
-import { createSessionStats, applyUsageDelta } from './engine/session-stats.mjs';
+import { bootProfile } from './session/boot-profile.mjs';
+import { createSessionStats, applyUsageDelta } from './session/session-stats.mjs';
 import {
   pickVerb,
   pickDoneVerb,
@@ -38,27 +38,27 @@ import {
   compactEventLabel,
   compactEventDetail,
   projectNameFromPath,
-} from './engine/labels.mjs';
-import { polishNoticeText } from './engine/notice-text.mjs';
+} from './session/labels.mjs';
+import { polishNoticeText } from './session/notice-text.mjs';
 import {
   toolResultText,
   toolAggregateDetailFallback,
   toolGroupedDisplayFallback,
   toolErrorDisplay,
-} from './engine/tool-result-text.mjs';
+} from './session/tool-result-text.mjs';
 import {
   toolCallId,
   toolResultCallId,
   toolCallName,
   toolCallArgs,
-} from './engine/tool-call-fields.mjs';
+} from './session/tool-call-fields.mjs';
 import {
   buildExecutionResponseToolItem,
   parseBackgroundTaskEnvelope,
   parseSyntheticAgentMessage,
   toolResultStatus,
   isErrorToolStatus,
-} from './engine/agent-envelope.mjs';
+} from './session/agent-envelope.mjs';
 import {
   queuePriorityValue,
   defaultQueuePriority,
@@ -72,50 +72,50 @@ import {
   mergePastedImages,
   mergePastedTexts,
   callCommitCallbacks,
-} from './engine/queue-helpers.mjs';
+} from './session/queue-helpers.mjs';
 import {
   resolveTuiRuntimeNotificationDelivery,
-} from './engine/notification-plan.mjs';
+} from './session/notification-plan.mjs';
 import {
   TUI_FRAME_MS,
   cancelRenderAlignedStoreFlush,
   scheduleRenderAlignedStoreFlush,
   yieldToRenderer,
-} from './engine/render-timing.mjs';
+} from './session/render-timing.mjs';
 import {
   aggregateRawResult,
   aggregateBucketForCategory,
   aggregateSummaries,
   assignAggregateSummaryOrder,
-} from './engine/tool-result-status.mjs';
-import { createToolApproval } from './engine/tool-approval.mjs';
-import { createToolCardResults } from './engine/tool-card-results.mjs';
-import { createAgentJobFeed } from './engine/agent-job-feed.mjs';
-import { appendAgentResponseTail } from './engine/agent-response-tail.mjs';
+} from './session/tool-result-status.mjs';
+import { createToolApproval } from './session/tool-approval.mjs';
+import { createToolCardResults } from './session/tool-card-results.mjs';
+import { createAgentJobFeed } from './session/agent-job-feed.mjs';
+import { appendAgentResponseTail } from './session/agent-response-tail.mjs';
 import {
   appendTuiSteeringPersist,
   dropTuiSteeringPersist,
   drainTuiSteeringPersist,
   flushTuiSteeringPersist,
-} from './engine/tui-steering-persist.mjs';
-import { createContextState } from './engine/context-state.mjs';
-import { recomputePromptHistory } from './engine/prompt-history.mjs';
+} from './session/tui-steering-persist.mjs';
+import { createContextState } from './session/context-state.mjs';
+import { recomputePromptHistory } from './session/prompt-history.mjs';
 import {
   appendPromptHistory,
   buildMergedPromptHistory,
   loadPromptHistory,
 } from './prompt-history-store.mjs';
-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 { createSessionFlow } from './session/session-flow.mjs';
+import { createRunTurn } from './session/turn.mjs';
+import { createSessionApi } from './session/session-api.mjs';
+import { createFrameBatchedStorePublisher } from './session/frame-batched-store.mjs';
+import { createLiveShare, forwardViewerSubmit, liveSharePipePath } from './session/live-share.mjs';
 import { displayModelName } from '../ui/model-display.mjs';
 
 const SESSION_RUNTIME_MODULE = '../mixdog-session-runtime.mjs';
 
 // The runtime graph is imported lazily, but that import (measured ~250ms) used
-// to land inside the FIRST engine creation, which desktop performs while it
+// to land inside the FIRST session runtime creation, which desktop performs while it
 // holds its transition lock — so the user's first navigation paid for it. Hosts
 // can start it during their own idle startup instead; the promise is shared, so
 // the create path either awaits an in-flight preload or does the import itself.
@@ -132,6 +132,17 @@ export function preloadSessionRuntimeModule() {
   });
 }
 
+let agentLoopPrewarmPromise = null;
+export function preloadAgentLoopRuntime() {
+  agentLoopPrewarmPromise ??= import(
+    '../runtime/agent/orchestrator/session/manager/runtime-loaders.mjs'
+  ).then((module) => module.prewarmAgentLoop());
+  void agentLoopPrewarmPromise.catch(() => {
+    // Reservation-time prewarm retries through the same shared loader.
+    agentLoopPrewarmPromise = null;
+  });
+}
+
 // Windows keychain reads go through a DPAPI PowerShell host whose cold start
 // dominates a packaged boot (measured ~1.5s). The runtime batches every secret
 // into one call, but it only starts that batch when the runtime is created —
@@ -155,26 +166,14 @@ const TOOL_APPROVAL_TIMEOUT_MS = (() => {
   return Number.isFinite(value) && value > 0 ? Math.max(1000, Math.round(value)) : 120_000;
 })();
 
-// Idle cap for a single lead TUI turn: the timer is reset by observable model,
-// tool, usage, stage, compact, or steering progress. A provider call that stops
-// producing progress otherwise leaves runTurn holding busy=true with no unwind,
-// so submit() only ever queues and the UI is permanently input-dead. On trip we
-// abort through the SAME interrupt path Esc uses; if that does not unwind, a
-// short grace path force-releases busy=false and drains the queue. Default is
-// intentionally finite (5min). Env-overridable for long local experiments.
-const LEAD_TURN_TIMEOUT_MS = (() => {
-  const value = Number(process.env.MIXDOG_LEAD_TURN_TIMEOUT_MS);
-  return Number.isFinite(value) && value > 0 ? Math.max(10_000, Math.round(value)) : 5 * 60_000;
-})();
-
 // Opt-in diagnostic trace for the hang chain (runTurn start/end, busy-queue
-// enqueue/drain, watchdog trip). Quiet by default so it can never tear through
+// enqueue/drain). Quiet by default so it can never tear through
 // the alternate-screen render; enable with MIXDOG_TUI_DEBUG=1.
-import { tuiDebug, nextId, cleanupStaleTranscriptSpillDirs, createTranscriptSpillBuffer, refillTranscriptViewOverlap, replaceEngineItemsState, createEngineItemMutators, TRANSCRIPT_LIVE_ITEM_CAP, TRANSCRIPT_SPILL_CHUNK_ITEMS } from './engine/transcript-spill.mjs';
-export { cleanupStaleTranscriptSpillDirs, createTranscriptSpillBuffer, refillTranscriptViewOverlap, replaceEngineItemsState, createEngineItemMutators, TRANSCRIPT_LIVE_ITEM_CAP, TRANSCRIPT_SPILL_CHUNK_ITEMS } from './engine/transcript-spill.mjs';
-export { parseBackgroundTaskEnvelope } from './engine/agent-envelope.mjs';
+import { tuiDebug, nextId, cleanupStaleTranscriptSpillDirs, createTranscriptSpillBuffer, refillTranscriptViewOverlap, replaceSessionItemsState, createSessionItemMutators, TRANSCRIPT_LIVE_ITEM_CAP, TRANSCRIPT_SPILL_CHUNK_ITEMS } from './session/transcript-spill.mjs';
+export { cleanupStaleTranscriptSpillDirs, createTranscriptSpillBuffer, refillTranscriptViewOverlap, replaceSessionItemsState, createSessionItemMutators, TRANSCRIPT_LIVE_ITEM_CAP, TRANSCRIPT_SPILL_CHUNK_ITEMS } from './session/transcript-spill.mjs';
+export { parseBackgroundTaskEnvelope } from './session/agent-envelope.mjs';
 
-export async function createLocalEngineSession({
+export async function createLocalSessionRuntime({
   provider: providerName,
   model,
   toolMode = 'full',
@@ -183,7 +182,7 @@ export async function createLocalEngineSession({
   desktopSession,
 } = {}) {
   const startedAt = performance.now();
-  bootProfile('engine:create:start', { provider: providerName, model, toolMode, remote });
+  bootProfile('session:create:start', { provider: providerName, model, toolMode, remote });
   // Silence provider/session diagnostics so they cannot tear through the
   // alternate-screen React/ink render.
   process.env.MIXDOG_QUIET_PROVIDER_LOG = '1';
@@ -203,7 +202,7 @@ export async function createLocalEngineSession({
     ...(cwd ? { cwd } : {}),
     ...(desktopSession ? { desktopSession } : {}),
   });
-  bootProfile('engine:create:runtime-ready', { ms: (performance.now() - startedAt).toFixed(1) });
+  bootProfile('session:create:runtime-ready', { ms: (performance.now() - startedAt).toFixed(1) });
   const runtimeCwd = runtime.cwd || process.cwd();
   const stateStartedAt = performance.now();
   const flags = {
@@ -224,7 +223,7 @@ export async function createLocalEngineSession({
   const displayedExecutionNotificationKeys = new Set();
   const bag = {};
   let state;
-  // Route/context/agent-status derivations live in ./engine/context-state.mjs.
+  // Route/context/agent-status derivations live in ./session/context-state.mjs.
   // getState()/getPendingSessionReset() are late-bound to the `state` and
   // `pendingSessionReset` closures declared below; the sync helpers mutate
   // state.stats / display fields IN PLACE exactly as the old inline versions
@@ -266,7 +265,7 @@ export async function createLocalEngineSession({
     toolApproval: null,
     lastTurn: null,
     stats: createSessionStats(),
-    // Incremental derivations published by the engine so App does not scan all
+    // Incremental derivations published by the session runtime so App does not scan all
     // transcript items on every change:
     //  - activeToolSummary: running Explore/Search active counts + earliest
     //    startedAt for the prompt-line status (replaces App.jsx O(n) items scan).
@@ -285,17 +284,17 @@ export async function createLocalEngineSession({
     cwd: runtimeCwd,
     themeEpoch: 0,
   };
-  bootProfile('engine:route-state-ready', { ms: (performance.now() - stateStartedAt).toFixed(1) });
-  bootProfile('engine:state-ready', { ms: (performance.now() - stateStartedAt).toFixed(1) });
+  bootProfile('session:route-state-ready', { ms: (performance.now() - stateStartedAt).toFixed(1) });
+  bootProfile('session:state-ready', { ms: (performance.now() - stateStartedAt).toFixed(1) });
   const contextStartedAt = performance.now();
   syncContextStats({ allowEstimated: true });
-  bootProfile('engine:context-ready', { ms: (performance.now() - contextStartedAt).toFixed(1) });
+  bootProfile('session:context-ready', { ms: (performance.now() - contextStartedAt).toFixed(1) });
   const listeners = new Set();
   // React/useSyncExternalStore reads only this immutable published snapshot.
-  // `state` remains the engine's synchronous draft until a frame flush swaps
+  // `state` remains the session runtime's synchronous draft until a frame flush swaps
   // the complete draft (including its single revision bump) into this slot.
   let publishedState = process.env.NODE_ENV === 'production' ? state : Object.freeze(state);
-  // The mutable engine draft must never be the object exposed to React.
+  // The mutable session runtime draft must never be the object exposed to React.
   state = { ...state, stats: { ...state.stats } };
   // Mutations stay synchronous, but React publications are frame-coalesced.
   // structureRevision is committed by the publisher exactly once immediately
@@ -305,7 +304,7 @@ export async function createLocalEngineSession({
     publishState: (next) => {
       publishedState = process.env.NODE_ENV === 'production' ? next : Object.freeze(next);
       // Detach the next draft, including the only intentionally mutable nested
-      // record, so legacy/internal draft writes cannot mutate the publication.
+      // record, so internal draft writes cannot mutate the publication.
       state = { ...next, stats: { ...next.stats } };
     },
     listeners,
@@ -413,7 +412,7 @@ export async function createLocalEngineSession({
     // discards the old transcript, so drop any tracked active tool calls.
     activeToolCalls.clear();
     const structureRevision = state.structureRevision;
-    state = replaceEngineItemsState({
+    state = replaceSessionItemsState({
       state,
       items: liveItems,
       itemIndexById,
@@ -430,7 +429,7 @@ export async function createLocalEngineSession({
         ...transcriptHistoryFlags(),
       },
     });
-    // replaceEngineItemsState retains its standalone/test contract. In the live
+    // replaceSessionItemsState retains its standalone/test contract. In the live
     // store, defer its revision increment to the frame publication boundary.
     state = { ...state, structureRevision };
     publisher.markStructureChange();
@@ -446,7 +445,7 @@ export async function createLocalEngineSession({
   // (App.jsx recentPromptHistory useMemo). It only changes when a user item is
   // appended, so rebuild it there and on bulk item swaps, publishing to
   // state.promptHistoryList. Pure derivation now lives in
-  // ./engine/prompt-history.mjs (recomputePromptHistory); callers still pass the
+  // ./session/prompt-history.mjs (recomputePromptHistory); callers still pass the
   // NEW items array explicitly and publish via set().
   // --- Active-tool summary (Explore/Search) maintained incrementally ---
   // App previously scanned every transcript item on every change to derive the
@@ -576,7 +575,7 @@ export async function createLocalEngineSession({
     }
     return set({ streamingTail: null, ...extra });
   };
-  const { patchItem, settleStreamingTail } = createEngineItemMutators({
+  const { patchItem, settleStreamingTail } = createSessionItemMutators({
     getState: () => state,
     set,
     itemIndexById,
@@ -823,7 +822,7 @@ export async function createLocalEngineSession({
 
 
   Object.assign(bag, {
-    runtime, nextId, tuiDebug, LEAD_TURN_TIMEOUT_MS,
+    runtime, nextId, tuiDebug,
     flags, lifecycle, pending, pendingNotificationKeys, displayedExecutionNotificationKeys, clearExecutionDedupState, listeners, itemIndexById,
     getState: () => state, getPublishedState: () => publishedState,
     set, flushEmit, flushEmitImmediate, disposeEmit: publisher.dispose,
@@ -842,7 +841,7 @@ export async function createLocalEngineSession({
   });
   Object.assign(bag, createSessionFlow(bag));
   bag.runTurn = createRunTurn(bag);
-  const api = createEngineApi(bag);
+  const api = createSessionApi(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.
@@ -869,14 +868,10 @@ export async function createLocalEngineSession({
       const injected = (await runtime.takeRemoteInjections?.()) || [];
       if (injected.length === 0) return;
       for (const item of injected) {
-        // New shape: { text, id }. Legacy drains still yield bare strings.
-        if (item && typeof item === 'object' && (item.text != null || item.content != null)) {
-          const text = item.text ?? item.content;
-          const id = typeof item.id === 'string' && item.id.trim() ? item.id.trim() : undefined;
-          bag.enqueue(text, id ? { id } : {});
-        } else {
-          bag.enqueue(item);
-        }
+        if (!item || typeof item !== 'object' || (item.text == null && item.content == null)) continue;
+        const text = item.text ?? item.content;
+        const id = typeof item.id === 'string' && item.id.trim() ? item.id.trim() : undefined;
+        bag.enqueue(text, id ? { id } : {});
       }
       void bag.drain();
     })().catch(() => { /* the watch/tick pair retries */ });
@@ -895,7 +890,7 @@ export async function createLocalEngineSession({
     getPublishedState: () => publishedState,
     listeners,
     onRemoteSubmit: (text, meta) => {
-      // A refusal must be REPORTED, never silent. This engine can be unable to
+      // A refusal must be REPORTED, never silent. This session runtime can be unable to
       // take a foreign prompt (disposed, or it became an attached viewer
       // itself); swallowing it here is what made a submitted message vanish
       // with no transcript row and no error (user: 입력이 씹힘). The ack sent
@@ -948,41 +943,46 @@ export async function createLocalEngineSession({
   // owner frames own stats/agent/tool state (see runtimePulseTimer above).
   bag.liveShareMirroring = () => state.sessionRemoteAttached && liveShare.viewerConnected();
   // Live viewer submits ride the owner's pipe (instant user bubble + shared
-  // streaming); the durable spool path below remains the fallback.
+  // streaming); the durable spool remains the fallback. Returns null when this
+  // surface is NOT an attached viewer, so the local session runtime keeps the prompt.
+  const viewerSubmitIntake = (prompt, options = {}) => {
+    if (!state.sessionRemoteAttached) return null;
+    const text = String(promptDisplayText(prompt, options) || '').trim();
+    if (!text) return { accepted: false };
+    return {
+      accepted: forwardViewerSubmit({
+        text,
+        options,
+        share: liveShare,
+        // Writing to the owner's spool instead of starting a fake local turn
+        // that would render an error/synthetic assistant message here.
+        spool: (submissionId) => runtime.enqueueRemoteAttachedPrompt?.({
+          content: prompt,
+          text,
+          id: submissionId,
+        }) === true,
+      }),
+    };
+  };
   if (typeof api.submit === 'function') {
     const baseSubmit = api.submit;
     api.submit = (prompt, options = {}) => {
-      if (state.sessionRemoteAttached) {
-        const text = String(promptDisplayText(prompt, options) || '').trim();
-        if (!text) return false;
-        // Reconcile first so a session that became attachable this event-loop
-        // turn uses the instant pipe path. If the pipe is still opening, write
-        // directly to the durable owner spool instead of starting a fake local
-        // turn that renders an error/synthetic assistant message.
-        try { liveShare.ensure(); } catch { /* durable fallback below */ }
-        const submissionId = options.id != null && String(options.id).trim()
-          ? String(options.id).trim()
-          : `view-submit-${process.pid}-${Date.now()}`;
-        const spoolFallback = () => runtime.enqueueRemoteAttachedPrompt?.({
-          content: prompt,
-          text: text,
-          id: submissionId,
-        }) === true;
-        // A pipe WRITE is not a delivery: the owner may refuse the prompt or
-        // the socket may die between write and read. sendSubmit stays
-        // synchronous (the store contract), but an unacknowledged submit is
-        // re-delivered through the durable spool — late, never lost.
-        if (text && liveShare.sendSubmit(text, {
-          id: submissionId,
-          submittedAt: options.submittedAt,
-          onUndelivered: spoolFallback,
-        })) return true;
-        return spoolFallback();
-      }
-      return baseSubmit(prompt, options);
+      const forwarded = viewerSubmitIntake(prompt, options);
+      return forwarded ? forwarded.accepted : baseSubmit(prompt, options);
+    };
+  }
+  // The daemon's intake boundary is submitAsync (session-service prefers
+  // it over submit). Leaving it unwrapped let a daemon-hosted VIEWER — the
+  // desktop pane on a session the terminal owns — queue the prompt locally, so
+  // its own user row stood beside the owner's mirrored twin.
+  if (typeof api.submitAsync === 'function') {
+    const baseSubmitAsync = api.submitAsync;
+    api.submitAsync = async (prompt, options = {}) => {
+      const forwarded = viewerSubmitIntake(prompt, options);
+      return forwarded ? forwarded.accepted : baseSubmitAsync(prompt, options);
     };
   }
-  // Viewer stop button: the local engine has no in-flight turn to cancel —
+  // Viewer stop button: the local session runtime has no in-flight turn to cancel —
   // forward the interrupt to the owner over the pipe. Falls back to the local
   // abort (no-op safe) when the pipe is down.
   if (typeof api.abort === 'function') {
@@ -1010,7 +1010,7 @@ export async function createLocalEngineSession({
       reconcileLiveShareNow();
       if (method === 'resume' && result === true && state.sessionRemoteAttached) {
         const id = String(state.sessionId || '');
-        // EngineHost holds renderer publications across resume. Keep that hold
+        // The session projection 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().
         // A healthy local owner serves its full frame on connect within tens
@@ -1025,7 +1025,7 @@ export async function createLocalEngineSession({
       return result;
     };
   }
-  // Cover engines whose runtime already has a session at construction time;
+  // Cover session runtimes whose runtime already has a session at construction time;
   // do not wait for a lifecycle method or the 3s safety pulse to open the pipe.
   reconcileLiveShareNow();
   // Instant input pickup: watch the shared pending spool so an attached

package/src/tui/session.mjs

@@ -0,0 +1,22 @@
+/**
+ * TUI session facade.
+ *
+ * Product clients receive only a daemon-owned session projection. The large
+ * in-process store is isolated in session-local.mjs and is not exposed
+ * from this client facade.
+ */
+export {
+  cleanupStaleTranscriptSpillDirs,
+  createTranscriptSpillBuffer,
+  refillTranscriptViewOverlap,
+  replaceSessionItemsState,
+  createSessionItemMutators,
+  TRANSCRIPT_LIVE_ITEM_CAP,
+  TRANSCRIPT_SPILL_CHUNK_ITEMS,
+} from './session/transcript-spill.mjs';
+export { parseBackgroundTaskEnvelope } from './session/agent-envelope.mjs';
+
+export async function createSessionRuntime(options = {}) {
+  const { createSession } = await import('../standalone/session-client.mjs');
+  return await createSession(options);
+}

package/src/tui/spinner-meta.mjs

@@ -9,9 +9,6 @@
  * for 30s. One builder, one answer.
  */
 
-/** Short turns stay quiet: elapsed/token meta only after this long. */
-export const SHOW_TOKENS_AFTER_MS = 30_000;
-
 const compactNumberFormatter = new Intl.NumberFormat('en-US', {
   notation: 'compact',
   maximumFractionDigits: 1,
@@ -62,7 +59,10 @@ export function buildSpinnerMeta({
   const thinkingText = spinnerThinkingLabel({ thinking, thinkingSince, thinkingMs, effort });
   return {
     tokensText: tokens > 0 ? `${formatSpinnerTokens(tokens)} tokens` : '',
-    showTokens: tokens > 0 && (Boolean(verbose) || Number(elapsedMs) > SHOW_TOKENS_AFTER_MS),
+    // The count appears with the FIRST token (user: 30초가 아니라 바로).
+    // Elapsed was never gated, so the byline used to grow a second field
+    // mid-turn for no reason the reader could see; now both arrive together.
+    showTokens: tokens > 0,
     thinkingText,
     thinkingActive: Boolean(thinking || Number(thinkingSince) > 0),
   };

package/src/tui/spinner-verbs.mjs

@@ -48,6 +48,40 @@ export const SPINNER_VERBS = [
 /** How long one phrase holds before the pool advances. */
 export const SPINNER_VERB_ROTATE_MS = 30_000;
 
+/** Odds that a 30s boundary actually swaps the phrase (user: 바꿀지 말지만
+ *  랜덤 돌리면 되잖아). Below 1 the window stretches: ~half the boundaries
+ *  hold, so a phrase lives 30s, 60s, 90s… and the rhythm stops being a
+ *  metronome. */
+export const SPINNER_VERB_CHANGE_ODDS = 0.5;
+
+/**
+ * Deterministic coin for ONE (turn, boundary) pair.
+ *
+ * Math.random() is not an option here: spinnerVerbFor runs on every render
+ * tick (~1/s) and the TUI and the desktop each call it for themselves, so a
+ * real RNG would reroll the word every second AND let the two surfaces
+ * disagree. An integer hash keeps each boundary's answer fixed forever while
+ * making the SEQUENCE of answers unpredictable — which is the part that reads
+ * as random.
+ */
+function boundarySwaps(anchor, boundary) {
+  let h = (Math.floor(anchor / 1000) + Math.imul(boundary, 0x9e3779b1)) | 0;
+  h = Math.imul(h ^ (h >>> 16), 0x21f0aaad);
+  h = Math.imul(h ^ (h >>> 15), 0x735a2d97);
+  h = (h ^ (h >>> 15)) >>> 0;
+  return h / 0x100000000 < SPINNER_VERB_CHANGE_ODDS;
+}
+
+/** Past this many boundaries (~34h) every boundary simply swaps; the walk is
+ *  re-counted each render and must not grow without bound. */
+const MAX_COUNTED_BOUNDARIES = 4096;
+
+/** A coin streak can hold a phrase for a very long time (measured: up to 9
+ *  minutes over 300 turns). After this many consecutive holds the next
+ *  boundary swaps regardless of its coin, capping one phrase at 4 windows
+ *  (~2 min) while leaving the 30/60/90/120s variety intact. */
+const MAX_HELD_BOUNDARIES = 3;
+
 /**
  * Modes that describe a STATE rather than ongoing work: they replace the pool
  * phrase for as long as the mode lasts, then the rotation resumes. Everything
@@ -64,14 +98,28 @@ export const SPINNER_MODE_OVERRIDE_VERBS = {
 /**
  * The phrase for a turn at a point in time. Derived from the turn's
  * `startedAt` so the TUI and the desktop show the SAME word at the same
- * second, and so mode flips cannot change it — only the 30s window can.
+ * second, and so mode flips cannot change it — only a 30s boundary can, and
+ * only when that boundary's coin says so.
  */
 export function spinnerVerbFor(startedAt = 0, now = 0, pool = SPINNER_VERBS) {
   const list = Array.isArray(pool) && pool.length ? pool : SPINNER_VERBS;
   const anchor = Math.max(0, Number(startedAt) || 0);
   const elapsed = anchor > 0 ? Math.max(0, (Number(now) || 0) - anchor) : 0;
-  const slot = Math.floor(elapsed / SPINNER_VERB_ROTATE_MS);
-  const seed = Math.floor(anchor / 1000) + slot;
+  const boundaries = Math.floor(elapsed / SPINNER_VERB_ROTATE_MS);
+  // Only the boundaries that FIRED advance the pool; a held boundary leaves
+  // the phrase exactly where it was, which is what stretches the window.
+  const counted = Math.min(boundaries, MAX_COUNTED_BOUNDARIES);
+  let swaps = boundaries - counted;
+  let held = 0;
+  for (let boundary = 1; boundary <= counted; boundary += 1) {
+    if (held >= MAX_HELD_BOUNDARIES || boundarySwaps(anchor, boundary)) {
+      swaps += 1;
+      held = 0;
+    } else {
+      held += 1;
+    }
+  }
+  const seed = Math.floor(anchor / 1000) + swaps;
   return list[((seed * 7) + 3) % list.length];
 }
 

package/src/ui/statusline-segments.mjs

@@ -54,7 +54,7 @@ export function shellJobsStatus({ clientHostPid, sessionId } = {}) {
   return (scope && value.sessions?.[scope]) || EMPTY_SHELL_JOBS_SESSION;
 }
 
-// Memory cycle L2 segment source. The memory daemon writes
+// Memory cycle L2 segment source. The daemon-hosted memory runtime 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"

package/src/ui/statusline.mjs

@@ -351,7 +351,7 @@ function renderNativeStatusline({
   ], agentJobs);
   const { runningWorkers } = classifyAgentWorkers(agentPayload.workers);
   // Shell segment scope: one host process can own MANY sessions' jobs (the
-  // desktop pools every pane's engine; the daemon backend hosts every
+  // desktop pools every pane's engine; the daemon hosts every
   // terminal's session), so the owner-wide aggregate would show one
   // terminal's running shell on every other terminal. Render this session's
   // own jobs whenever we know which session we are; only a session-less

package/vendor/ink/build/components/App.js

@@ -42,7 +42,8 @@ function App({ children, stdin, stdout, stderr, writeToStdout, writeToStderr, ex
     const readableListenerRef = useRef(undefined);
     const inputParserRef = useRef(createInputParser());
     const pendingInputFlushRef = useRef(undefined);
-    // Small delay to let chunked escape sequences complete before flushing as literal input.
+    // Only partial multi-byte escape sequences wait. A raw read containing one
+    // bare ESC is an explicit cancel gesture and must dispatch in this turn.
     const pendingInputFlushDelayMilliseconds = 20;
     const clearPendingInputFlush = useCallback(() => {
         if (!pendingInputFlushRef.current) {
@@ -233,10 +234,18 @@ function App({ children, stdin, stdout, stderr, writeToStdout, writeToStderr, ex
         let chunk;
         // eslint-disable-next-line @typescript-eslint/no-restricted-types
         while ((chunk = stdin.read()) !== null) {
+            const hadPendingEscape = inputParserRef.current.hasPendingEscape();
+            const bareEscapeChunk = !hadPendingEscape && String(chunk) === escape;
             const inputEvents = inputParserRef.current.push(chunk);
             for (const event of inputEvents) {
                 dispatchParsedEvent(event);
             }
+            if (bareEscapeChunk && inputParserRef.current.hasPendingEscape()) {
+                const escapeEvents = inputParserRef.current.flushPendingEscape();
+                for (const event of escapeEvents ?? []) {
+                    dispatchParsedEvent(event);
+                }
+            }
         }
         if (inputParserRef.current.hasPendingEscape()) {
             schedulePendingInputFlush();

package/src/session-runtime/memory-daemon-probe.mjs

@@ -1,61 +0,0 @@
-// Eager memory-daemon boot for remote sessions. The channels worker forwards
-// transcript ingests to the memory HTTP service, so its port must be published
-// (and actually listening) before the worker sends its first ingest — otherwise
-// early channel traffic finds no port and gets buffered. Extracted from
-// runtime-core's startRemote, which now just fires it.
-import * as httpMod from 'node:http';
-
-const HEALTH_ATTEMPTS = 30;
-const HEALTH_RETRY_MS = 500;
-const HEALTH_TIMEOUT_MS = 1500;
-
-function healthOk(port) {
-  return new Promise((resolve) => {
-    const request = httpMod.request(
-      { hostname: '127.0.0.1', port, path: '/health', timeout: HEALTH_TIMEOUT_MS },
-      (response) => {
-        let body = '';
-        response.on('data', (chunk) => { body += chunk; });
-        response.on('end', () => {
-          try { resolve(JSON.parse(body)?.status === 'ok'); } catch { resolve(false); }
-        });
-      },
-    );
-    request.on('error', () => resolve(false));
-    request.on('timeout', () => { request.destroy(); resolve(false); });
-    request.end();
-  });
-}
-
-/** Detached, never throws: resolving the module only hands back a handle, so
- *  this awaits start() and then polls /health until the daemon is provably
- *  reachable (or the failure is profiled). */
-export function startMemoryDaemonEagerly({ getMemoryModule, bootProfile }) {
-  void (async () => {
-    try {
-      // Yield one tick first: the module resolve + daemon fork below is a long
-      // synchronous chain that would otherwise starve Ink's queued render and
-      // keypress handling.
-      await new Promise((resolve) => setImmediate(resolve));
-      const module = await getMemoryModule();
-      const started = typeof module?.start === 'function' ? await module.start() : null;
-      const port = started?.port;
-      if (!port) {
-        bootProfile('channels:memory-eager-init-failed', { error: 'no port from start()' });
-        return;
-      }
-      for (let attempt = 0; attempt < HEALTH_ATTEMPTS; attempt += 1) {
-        try {
-          if (await healthOk(port)) {
-            bootProfile('channels:memory-eager-init-ready', { port });
-            return;
-          }
-        } catch { /* probe failure is retried below */ }
-        await new Promise((resolve) => setTimeout(resolve, HEALTH_RETRY_MS));
-      }
-      bootProfile('channels:memory-eager-init-failed', { error: `health not ok after retries (port ${port})` });
-    } catch (error) {
-      bootProfile('channels:memory-eager-init-failed', { error: error?.message || String(error) });
-    }
-  })();
-}