mixdog 0.9.95 → 0.9.96

package/src/tui/engine/live-share.mjs

@@ -709,3 +709,37 @@ export function createLiveShare({
     },
   };
 }
+
+/**
+ * ONE viewer-submit intake for EVERY engine entry point. The TUI store calls
+ * submit(); the daemon awaits submitAsync() (engine-daemon-service prefers it).
+ * Wrapping only one of them let the other path enqueue the prompt on the VIEWER
+ * engine, so that surface rendered its own local user row beside the owner's
+ * mirrored one — the same message twice on screen
+ * (user: 데스크탑에서만 입력이 두 개로 들어간다).
+ *
+ * `spool(submissionId)` is the durable fallback. The submission id is minted
+ * here when the caller has none, so the pipe frame and the spool entry carry
+ * the SAME identity and the owner reuses it for the settled user row — which is
+ * what releases the submitting surface's optimistic bubble.
+ */
+export function forwardViewerSubmit({ text, options = {}, share, spool, pid = process.pid }) {
+  const value = String(text || '').trim();
+  if (!value) return false;
+  // Reconcile first so a session that became attachable this event-loop turn
+  // takes the instant pipe path instead of the durable detour.
+  try { share.ensure?.(); } catch { /* durable fallback below */ }
+  const submissionId = options.id != null && String(options.id).trim()
+    ? String(options.id).trim()
+    : `view-submit-${pid}-${Date.now()}`;
+  const deliverDurably = () => spool?.(submissionId) === true;
+  // A pipe WRITE is not a delivery: the owner may refuse the prompt and the
+  // socket may die between write and read, so an unacknowledged submit is
+  // re-delivered through the spool — late, never lost.
+  if (share.sendSubmit(value, {
+    id: submissionId,
+    submittedAt: options.submittedAt,
+    onUndelivered: deliverDurably,
+  })) return true;
+  return deliverDurably();
+}

package/src/tui/engine/session-api-ext.mjs

@@ -623,9 +623,6 @@ export function createEngineApiB(bag) {
     setAgentRoute: async (agentId, opts) => {
       return await runtime.setAgentRoute?.(agentId, opts);
     },
-    setDefaultProvider: async (provider) => {
-      return await runtime.setDefaultProvider?.(provider);
-    },
     listProviders: () => {
       return runtime.listProviders();
     },
@@ -883,7 +880,7 @@ export function createEngineApiB(bag) {
     renameSessionTitle: (id, title) => {
       return runtime.renameSessionTitle?.(id, title) ?? false;
     },
-    // Desktop sidebar watcher hook: EngineHost fs.watches this directory so
+    // Desktop sidebar watcher hook: the backend watches this directory so
     // heartbeat sidecar create/delete pushes instant working/dot updates.
     // Without it the watcher silently no-ops and the sidebar falls back to
     // the 60s safety poll (user: spinner kept spinning after the turn ended).

package/src/tui/engine/session-api.mjs

@@ -7,8 +7,7 @@ import { isQueuedEntryEditable, promptDisplayText } from './queue-helpers.mjs';
 import { createEngineApiB } from './session-api-ext.mjs';
 import { buildDoctorReport } from '../app/doctor.mjs';
 import { recomputePromptHistory } from './prompt-history.mjs';
-import { buildMergedPromptHistory, loadPromptHistory } from '../prompt-history-store.mjs';
-import { touchProjectSelected } from '../../standalone/projects.mjs';
+import { appendPromptHistory, buildMergedPromptHistory, loadPromptHistory, promptHistoryKey } from '../prompt-history-store.mjs';
 
 // Upper bound on how long a manual Esc abort may leave the store busy while the
 // in-flight runtime.ask() unwinds. runtime.abort() normally rejects the pending
@@ -33,7 +32,7 @@ export function createEngineApi(bag) {
     const snapshot = {
       autoClear: await read(api.getAutoClear),
       compaction: await read(api.getCompactionSettings),
-      memory: await read(api.getMemorySettings),
+      recap: await read(api.getRecapSettings),
       channels: await read(api.getChannelSettings, { includeStatus: false }),
       systemShell: await read(api.getSystemShell),
       outputStyle: (await read(api.getOutputStyle)) || (await read(api.listOutputStyles)),
@@ -58,27 +57,34 @@ export function createEngineApiA(bag) {
   const {
     runtime, nextId, flags, pending, listeners, getState, getPublishedState = getState, set, flushEmitImmediate, pushItem, patchItem, replaceItems, restoreOlderTranscript, restoreNewerTranscript, settleStreamingTail, clearStreamingTail, pushNotice, autoClearState, agentStatusState, routeState, syncContextStats, denyAllToolApprovals, updateAgentJobCard, requeueEntriesFront, enqueue, autoClearBeforeSubmit, restoreQueued, resetStatsAndSyncContext, drain, flushDeferredExecutionPendingResumeKick, discardExecutionPendingResume,
   } = bag;
-  const submit = (text, options = {}) => {
+  const submission = (text, options = {}) => {
     const t = promptDisplayText(text, options).trim();
-    if (!t) return false;
+    if (!t) return null;
     const mode = options.mode || 'prompt';
-   // Prompt input queued while a turn is active keeps the
-   // default `next` priority, so it is injected at the next tool/model
-   // boundary. Explicit options.priority still wins.
+    // Prompt input queued while a turn is active keeps the default `next`
+    // priority, so it is injected at the next tool/model boundary. Explicit
+    // options.priority still wins.
    const priority = options.priority;
-    const queueOptions = {
-      ...options,
-      // Always mint a submission id so daemon retries / dual-path intake
-      // can dedupe instead of booking the same prompt twice.
-      id: String(options.id || '').trim() || nextId(),
-      mode,
-      displayText: promptDisplayText(text, options),
-      priority,
+    return {
+      text,
+      queueOptions: {
+        ...options,
+        // Always mint a submission id so daemon retries / dual-path intake
+        // can dedupe instead of booking the same prompt twice.
+        id: String(options.id || '').trim() || nextId(),
+        mode,
+        displayText: promptDisplayText(text, options),
+        priority,
+      },
     };
+  };
+  const submit = (text, options = {}) => {
+    const intake = submission(text, options);
+    if (!intake) return false;
     // A running clear (idle auto-clear or session_manage) sets commandBusy;
     // queue the prompt instead of dropping it — it drains after the clear.
     if (flags.autoClearRunning) {
-      return enqueue(text, queueOptions) !== false;
+      return enqueue(intake.text, intake.queueOptions) !== false;
     }
     // Any in-flight session command (clear/setModel/newSession/resume/...)
     // holds commandBusy. Previously the prompt was dropped here and only the
@@ -86,17 +92,31 @@ export function createEngineApiA(bag) {
     // commandBusy, and the central release hook re-kicks drain once the
     // command settles, so the prompt runs afterwards rather than vanishing.
     if (getState().commandBusy) {
-      return enqueue(text, queueOptions) !== false;
+      return enqueue(intake.text, intake.queueOptions) !== false;
     }
     if (getState().busy) {
-      return enqueue(text, queueOptions) !== false;
+      return enqueue(intake.text, intake.queueOptions) !== false;
     }
     // If autoClearBeforeSubmit rejects (e.g. compaction timeout throws), the
     // prompt must still be queued — swallow the rejection so enqueue always
     // runs and the submit is never silently lost.
-    void autoClearBeforeSubmit().catch(() => {}).then(() => enqueue(text, queueOptions));
+    void autoClearBeforeSubmit().catch(() => {}).then(
+      () => enqueue(intake.text, intake.queueOptions),
+    );
     return true;
   };
+  const submitAsync = async (text, options = {}) => {
+    const intake = submission(text, options);
+    if (!intake) return false;
+    // Daemon intake needs an acknowledgement boundary stronger than the TUI's
+    // synchronous submit(): by the time this Promise resolves, the prompt is
+    // present either as a visible queue entry or as the first durable user row.
+    // Provider execution still runs detached through drain().
+    if (!flags.autoClearRunning && !getState().commandBusy && !getState().busy) {
+      await autoClearBeforeSubmit().catch(() => {});
+    }
+    return enqueue(intake.text, intake.queueOptions) !== false;
+  };
   return {
     getState: () => getPublishedState(),
     patchItem,
@@ -107,7 +127,7 @@ export function createEngineApiA(bag) {
       return () => listeners.delete(listener);
     },
     submit,
-    submitAsync: async (text, options = {}) => submit(text, options),
+    submitAsync,
     reserveSession: (sessionId) => {
       const id = runtime.reserveSessionId?.(sessionId);
       if (!id) return false;
@@ -116,6 +136,46 @@ export function createEngineApiA(bag) {
       return String(getState().sessionId || '') === String(id);
     },
     restoreQueued,
+    // Claude Code's message selector ("jump back to a previous message"):
+    // rewind the conversation to just before a user prompt and hand its text
+    // back for editing. Idle-only — a live turn must be interrupted first.
+    rewindToItem: async (itemId) => {
+      const target = String(itemId ?? '').trim();
+      if (!target) return null;
+      if (getState().busy || getState().commandBusy) return null;
+      const items = getState().items || [];
+      const index = items.findIndex(
+        (item) => item?.kind === 'user' && String(item?.id) === target,
+      );
+      if (index < 0) return null;
+      const text = String(items[index]?.text || '').trim();
+      if (!text) return null;
+      set({ commandBusy: true });
+      try {
+        const rewound = await runtime.rewindMessages?.({ text });
+        if (!rewound) return null;
+        const restoreKey = promptHistoryKey(text);
+        set({
+          items: replaceItems(items.slice(0, index), {
+            preserveSpill: true,
+            preserveTranscriptView: true,
+          }),
+          spinner: null,
+          thinking: null,
+          lastTurn: null,
+          // The prompt returns to the draft, so it must not ALSO sit in the
+          // Up-arrow history — otherwise it shows up twice.
+          promptHistoryList: (getState().promptHistoryList || [])
+            .filter((entry) => promptHistoryKey(entry) !== restoreKey),
+        });
+        syncContextStats({ allowEstimated: true });
+        set({ stats: { ...getState().stats } });
+        flushEmitImmediate?.();
+        return { text, removed: items.length - index, messages: rewound.removed };
+      } finally {
+        set({ commandBusy: false });
+      }
+    },
     setModel: async (m) => {
       if (getState().commandBusy) return false;
       set({ commandBusy: true });
@@ -209,14 +269,14 @@ export function createEngineApiA(bag) {
         set({ commandBusy: false });
       }
     },
-    getMemorySettings: () => {
-      return runtime.getMemorySettings?.() || { enabled: true };
+    getRecapSettings: () => {
+      return runtime.getRecapSettings?.() || { enabled: true };
     },
-    setMemoryEnabled: async (enabled) => {
+    setRecapEnabled: async (enabled) => {
       if (getState().commandBusy) return null;
       set({ commandBusy: true });
       try {
-        const next = await runtime.setMemoryEnabled?.(enabled);
+        const next = await runtime.setRecapEnabled?.(enabled);
         set({ ...routeState(), stats: { ...getState().stats } });
         // Deferred for the same reason as setCompactionSettings above: keep
         // the recompute off the key-handler tick so the toggle repaints
@@ -296,12 +356,6 @@ export function createEngineApiA(bag) {
     },
     setCwd: (path, options = {}) => {
       const next = runtime.setCwd(path);
-      // "Last opened" recency belongs to the ACTUAL cwd switch, not to one
-      // caller: the project picker, its Current Path row and the /cwd prompt
-      // all land here, so the project list stays ordered by what was really
-      // opened last. Unregistered folders are ignored — this never registers
-      // a project on its own (addProject remains the only registration path).
-      try { touchProjectSelected(next); } catch { /* best-effort recency */ }
       // Republish up-arrow history for the NEW project: current session prompts
       // merged with the cwd-scoped persisted store for the new cwd.
       const sessionList = recomputePromptHistory(getState().items);
@@ -311,6 +365,15 @@ export function createEngineApiA(bag) {
       }
       return next;
     },
+    rememberPromptHistory: (value) => {
+      const text = String(value || '').trim();
+      if (!text) return false;
+      const persisted = appendPromptHistory(getState().cwd, text);
+      if (!persisted) return false;
+      const sessionList = recomputePromptHistory(getState().items);
+      set({ promptHistoryList: buildMergedPromptHistory(sessionList, persisted) });
+      return true;
+    },
     getSystemShell: () => {
       return runtime.getSystemShell?.() || runtime.systemShell || { source: 'auto', command: '', effective: '' };
     },
@@ -608,7 +671,7 @@ export function createEngineApiA(bag) {
         set({ commandBusy: false, commandStatus: null });
       }
     },
-    abort: () => {
+    abort: (options = {}) => {
       if (!getState().busy) return false;
       denyAllToolApprovals('interrupted by user');
       const restoreState = flags.activePromptRestore;
@@ -616,7 +679,9 @@ export function createEngineApiA(bag) {
       // interrupting should just cancel the running turn and let the steering
       // prompt run next, NOT resurrect the in-flight prompt back into the draft.
       const hasPendingSteering = pending.some((entry) => isQueuedEntryEditable(entry));
-      const canRestore = restoreState?.restorable && !hasPendingSteering;
+      const canRestore = options?.restorePrompt !== false
+        && restoreState?.restorable
+        && !hasPendingSteering;
       const restoreText = canRestore ? restoreState.text : '';
       const restorePastedImages = canRestore && restoreState?.pastedImages ? restoreState.pastedImages : null;
       const restorePastedTexts = canRestore && restoreState?.pastedTexts ? restoreState.pastedTexts : null;
@@ -644,6 +709,11 @@ export function createEngineApiA(bag) {
           restoreState.reclaimed = true;
           const idSet = new Set((restoreState.submittedIds || []).filter((id) => id != null));
           const patch = { spinner: null, thinking: null, lastTurn: null };
+          if (restoreText) {
+            const restoreKey = promptHistoryKey(restoreText);
+            patch.promptHistoryList = (getState().promptHistoryList || [])
+              .filter((entry) => promptHistoryKey(entry) !== restoreKey);
+          }
           if (idSet.size > 0) {
             const items = getState().items.filter((item) => !idSet.has(item?.id));
             if (items.length !== getState().items.length) {

package/src/tui/engine/session-flow.mjs

@@ -560,7 +560,13 @@ export function createSessionFlow(bag) {
     removeQueuedEntries(queued);
     const queuedText = queued.map((item) => item.text).filter((text) => String(text || '').trim()).join('\n');
     const combinedText = [queuedText, String(currentText || '')].filter((text) => text.trim()).join('\n');
-    return { count: queued.length, text: combinedText, pastedImages: mergePastedImages(queued), pastedTexts: mergePastedTexts(queued) };
+    return {
+      count: queued.length,
+      ids: queued.map((item) => String(item.id || '')).filter(Boolean),
+      text: combinedText,
+      pastedImages: mergePastedImages(queued),
+      pastedTexts: mergePastedTexts(queued),
+    };
   }
 
   const resetStats = () => {

package/src/tui/engine/tool-card-results.mjs

@@ -11,7 +11,7 @@
  * is the original engine.mjs logic verbatim.
  */
 import { summarizeToolResult, aggregateDoneCategories } from '../../runtime/shared/tool-surface.mjs';
-import { toolResultText, toolErrorDisplay, toolGroupedDisplayFallback } from './tool-result-text.mjs';
+import { toolResultText, toolErrorDisplay, toolGroupedDisplayFallback, stripShellExitHeader } from './tool-result-text.mjs';
 import { toolResultCallId } from './tool-call-fields.mjs';
 import { parseAgentJob } from './agent-envelope.mjs';
 import {
@@ -82,7 +82,9 @@ export function createToolCardResults({
     // outcomes remain successful calls with their raw/semantic result detail.
     const { exitCode, isExitError, isCallError } = toolCallOutcome(message, rawText);
     const isError = isCallError;
-    const text = isError ? toolErrorDisplay(rawText, card?.name || 'tool') : rawText;
+    const text = isError
+      ? toolErrorDisplay(rawText, card?.name || 'tool')
+      : (isExitError ? stripShellExitHeader(rawText) : rawText);
 
     if (aggregate && card.itemId === aggregate.itemId) {
       if (!callRec) return false;

package/src/tui/engine/tool-result-text.mjs

@@ -124,3 +124,13 @@ export function toolErrorDisplay(value, surface = 'tool') {
   }
   return /^error\s*:/i.test(text) ? text : `Error: ${text}`;
 }
+
+// Display-only: a command-exit card already renders `Exit N` as its state, so
+// the machine header (`Error: [shell-run-failed] [exit code: N]`) is redundant
+// in the body — and the bare word "Error" reads as a tool failure even though
+// the tool ran fine and the command merely exited non-zero. The model-facing
+// result keeps the header untouched; only the rendered body drops it.
+export function stripShellExitHeader(text) {
+  const body = String(text ?? '');
+  return body.replace(/(^|\n)(?:Error:\s*)?\[shell-run-failed\][^\n]*\n{0,2}/i, '$1');
+}

package/src/tui/engine/turn.mjs

@@ -4,7 +4,7 @@
 import { aggregateToolCategoryEntry, aggregateDoneCategories, classifyToolCategory, formatAggregateDetail, summarizeToolResult } from '../../runtime/shared/tool-surface.mjs';
 import { applyUsageDelta } from './session-stats.mjs';
 import { pickVerb, pickDoneVerb, compactEventLabel, compactEventDetail } from './labels.mjs';
-import { toolResultText, toolErrorDisplay } from './tool-result-text.mjs';
+import { toolResultText, toolErrorDisplay, stripShellExitHeader } from './tool-result-text.mjs';
 import { toolCallId, toolResultCallId, toolCallName, toolCallArgs } from './tool-call-fields.mjs';
 import { promptDisplayText, STEERING_SUPPRESSED_DISPLAY } from './queue-helpers.mjs';
 import { TUI_FRAME_MS, yieldToRenderer } from './render-timing.mjs';
@@ -183,12 +183,6 @@ export function createRunTurn(bag) {
     const toolCards = [];
     const toolGroups = new Map();
     const resultsDone = new Set();
-    // apply_patch+post_shell twin display: parent callId → synthetic shell
-    // callId. The protocol stays ONE call/ONE result, but the transcript shows
-    // TWO cards (edit + verify shell) so a long post_shell no longer looks
-    // like a stuck 'Editing 1 file'. deliverToolResultMessage splits the
-    // combined result text back between the two cards.
-    const postShellTwins = new Map();
     // ── 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
@@ -748,7 +742,9 @@ export function createRunTurn(bag) {
         // the provider's isError/error-tool envelope drives failure counts/red.
         const { exitCode, isExitError, isCallError } = toolCallOutcome(message, rawText);
         const isError = isCallError;
-        const text = isError ? toolErrorDisplay(rawText, callRec.name || 'tool') : rawText;
+        const text = isError
+          ? toolErrorDisplay(rawText, callRec.name || 'tool')
+          : (isExitError ? stripShellExitHeader(rawText) : rawText);
         callRec.summary = !isError ? summarizeToolResult(callRec.name, callRec.args, rawText, isError) : null;
         assignAggregateSummaryOrder(aggregate, callRec);
         callRec.isError = isError;
@@ -805,51 +801,9 @@ export function createRunTurn(bag) {
         const earlyCallId = toolResultCallId(message);
         if (earlyCallId) {
           markToolCardCompletedState(earlyCallId, message);
-          const earlyTwin = postShellTwins.get(earlyCallId);
-          if (earlyTwin) markToolCardCompletedState(earlyTwin, message);
         }
         return;
       }
-      const parentCallId = toolResultCallId(message);
-      const twinCallId = parentCallId ? postShellTwins.get(parentCallId) : null;
-      if (twinCallId && !resultsDone.has(twinCallId)) {
-        const combined = String(toolResultText(message?.content) ?? '');
-        // tool-exec composes `${patch}\n\n${header}\n${shell}` (or appends the
-        // skipped marker to a failed patch). Split on those exact seams.
-        const headerMatch = combined.match(/\n+--- post_shell( FAILED[^\n]*)? ---\n?/);
-        const skippedMatch = headerMatch ? null : combined.match(/\n+--- post_shell skipped: patch failed ---\s*$/);
-        let patchPart = combined;
-        let shellPart = null;
-        if (headerMatch) {
-          patchPart = combined.slice(0, headerMatch.index);
-          shellPart = combined.slice(headerMatch.index + headerMatch[0].length);
-          // Keep the FAILED banner on the shell card so its error state and
-          // fix-and-re-verify guidance survive the split.
-          if (headerMatch[1]) shellPart = `Error: post_shell FAILED (patch is applied; fix and re-verify)\n${shellPart}`;
-        } else if (skippedMatch) {
-          patchPart = combined.slice(0, skippedMatch.index);
-          shellPart = 'Error: post_shell skipped: patch failed';
-        }
-        if (shellPart !== null) {
-          flushToolResults([
-            {
-              role: 'tool',
-              tool_call_id: parentCallId,
-              content: patchPart,
-              ...(Object.hasOwn(message || {}, 'uiDiff') ? { uiDiff: message.uiDiff } : {}),
-            },
-            { role: 'tool', tool_call_id: twinCallId, content: shellPart },
-          ], toolCards, cardByCallId, toolGroups, resultsDone);
-          return;
-        }
-        // Unsplittable (offloaded/preview-shaped result): parent keeps the
-        // combined text; settle the twin instead of leaving it Running.
-        flushToolResults([
-          message,
-          { role: 'tool', tool_call_id: twinCallId, content: '(post_shell output included in the patch result above)' },
-        ], toolCards, cardByCallId, toolGroups, resultsDone);
-        return;
-      }
       flushToolResults([message], toolCards, cardByCallId, toolGroups, resultsDone);
     };
 
@@ -918,24 +872,7 @@ export function createRunTurn(bag) {
           }
           const batchCalls = (calls || []).filter(Boolean);
           if (batchCalls.length === 0) return;
-          // Expand each apply_patch carrying post_shell into itself PLUS a
-          // synthetic trailing shell call, so the (possibly long) verify phase
-          // renders as its own Running command card in call order.
-          const displayCalls = [];
-          for (const c of batchCalls) {
-            displayCalls.push(c);
-            if (toolCallName(c) !== 'apply_patch') continue;
-            let patchCallArgs = toolCallArgs(c);
-            if (typeof patchCallArgs === 'string') {
-              try { patchCallArgs = JSON.parse(patchCallArgs); } catch { patchCallArgs = null; }
-            }
-            const postShellCmd = typeof patchCallArgs?.post_shell === 'string' ? patchCallArgs.post_shell.trim() : '';
-            const parentCallId = toolCallId(c);
-            if (!postShellCmd || !parentCallId) continue;
-            const twinCallId = `${parentCallId}::post_shell`;
-            postShellTwins.set(parentCallId, twinCallId);
-            displayCalls.push({ id: twinCallId, name: 'shell', args: { command: postShellCmd } });
-          }
+          const displayCalls = batchCalls;
           const agentBatch = ++providerToolBatch;
           const committedAssistantSegment = commitAssistantSegment({ sealToolBlock: true });
           if (committedAssistantSegment) {
@@ -1230,8 +1167,11 @@ export function createRunTurn(bag) {
           if (!isCurrentTurn() || watchdog.tripped) return;
           if (String(chunk ?? '')) {
             if (!markTurnProgress('reasoning-delta')) return;
-            markPromptCommitted();
           }
+          // Reasoning is NOT a commit boundary (Claude Code parity): a turn
+          // interrupted while it is still thinking produced no model-visible
+          // message, so Esc must hand the prompt back to the input box. Text,
+          // tool calls and turn end still commit it below.
           startThinkingSegment();
           thinkingText += String(chunk ?? '');
           // Accumulate reasoning text; fire at most one render per STREAM_BATCH_INTERVAL_MS.

package/src/tui/engine-local-session.mjs

@@ -109,7 +109,7 @@ 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 { createLiveShare, forwardViewerSubmit, liveSharePipePath } from './engine/live-share.mjs';
 import { displayModelName } from '../ui/model-display.mjs';
 
 const SESSION_RUNTIME_MODULE = '../mixdog-session-runtime.mjs';
@@ -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 —
@@ -948,38 +959,43 @@ 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 engine 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 (engine-daemon-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 —
@@ -1010,7 +1026,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

package/src/tui/index.jsx

@@ -30,7 +30,6 @@ import { POP_KITTY, DISABLE_MODIFY_OTHER_KEYS } from './keyboard-protocol.mjs';
 import { displayWidth } from './display-width.mjs';
 import { rotateBoundedLog, PLUGIN_LOG_MAX_BYTES, PLUGIN_LOG_KEEP_BYTES } from '../lib/mixdog-debug.cjs';
 import { localPackageVersion } from '../runtime/shared/update-checker.mjs';
-import { touchProjectSelected } from '../standalone/projects.mjs';
 
 // Trailing `\x1b[>0s` restores XTSHIFTESCAPE (shift-to-select-extend) to its
 // terminal default; MOUSE_TRACKING_ON opts into `\x1b[>1s`, so every mouse/alt
@@ -517,7 +516,7 @@ export async function runTui({ provider, model, toolMode, remote, forceOnboardin
     // this, a project entered straight from the shell never moved in the
     // picker's most-recent-first order. Unregistered folders are ignored.
     try {
-      touchProjectSelected(store.getState?.()?.cwd || process.cwd());
+      await store.touchProjectSelected(store.getState?.()?.cwd || process.cwd());
     } catch { /* best-effort recency */ }
     // The palette lives in THIS process: on a daemon-backed store the engine's
     // theme methods would run inside the daemon, so the picker saw a promise

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),
   };