elanous 0.2.36 → 0.2.38

package/src/dashboard/side-basic-runtime.ts

@@ -0,0 +1,61 @@
+import { loadSidetabRows, type SidetabRow } from '../tui/sidetab/list.js';
+import { stripAnsi, termSize } from '../tui.js';
+import { requestRemotePtyControl } from '../pty-shell/pty-control-ipc.js';
+import type { SlashCommandRegistry } from './slash-runtime/registry.js';
+import type { DashboardSlashContext, DashboardSlashReturn } from './slash-runtime/dashboard-handlers.js';
+
+/** Classic /side: the Next TUI manifest is the sole source of list ordering. */
+export function registerClassicSideSlash(
+  registry: SlashCommandRegistry<DashboardSlashContext, DashboardSlashReturn>,
+  loadRows: (sessionId?: string) => SidetabRow[] = (sessionId) => loadSidetabRows(false, sessionId),
+  snapshot: typeof requestRemotePtyControl = requestRemotePtyControl,
+): void {
+  registry.register(['side'], async (args, ctx) => {
+    const sub = (args[0] ?? 'list').toLowerCase();
+    if (sub === 'new') {
+      if (args.length > 1) ctx.chatLines.push(ctx.warning('  사용법: /side new'));
+      else ctx.termSlash.openNewTerminal();
+      ctx.setChatScrollOffset(-1);
+      return;
+    }
+    if (sub !== 'list' && sub !== 'attach') {
+      ctx.chatLines.push(ctx.muted('  사용법: /side [list] | new | attach <번호>'));
+      ctx.setChatScrollOffset(-1);
+      return;
+    }
+    // Use the same filtered manifest rows for display and numeric resolution;
+    // never let an exited row shift the number shown to the user.
+    const rows = loadRows(ctx.chatPersona?.sessionId()).filter(row => row.badge !== 'exited');
+    if (sub === 'list') {
+      if (rows.length === 0) ctx.chatLines.push(ctx.muted('  사이드탭 없음'));
+      rows.forEach((row, i) => ctx.chatLines.push(ctx.muted(`  ${i + 1}. ${row.badge} ${row.label}`)));
+      ctx.setChatScrollOffset(-1);
+      return;
+    }
+    const raw = args[1] ?? '';
+    const index = /^\d+$/.test(raw) ? Number(raw) - 1 : -1;
+    const row = rows[index];
+    if (args.length !== 2 || !row) {
+      ctx.chatLines.push(ctx.warning('  사용법: /side attach <목록 번호>'));
+    } else if (row.currentProcess) {
+      ctx.chatLines.push(ctx.muted('  현재 세션입니다'));
+    } else if (row.sessionId && ctx.termSlash.sessionRegistry.get(row.sessionId)) {
+      const { cols, rows: height } = termSize();
+      const session = ctx.termSlash.sessionRegistry.attach(row.sessionId, { termCols: cols, termRows: height });
+      if (session?.modal) ctx.termSlash.openSession(session);
+      else ctx.chatLines.push(ctx.warning('  PTY attach 실패'));
+    } else if (row.ptyId) {
+      try {
+        // A foreign child belongs to another PTY owner: snapshot only, no takeover.
+        const result = await snapshot(row.ptyId, 'snapshot', { ansi: false }, { timeoutMs: 450 });
+        if (result.status === 'success' && result.screen?.trim()) {
+          ctx.chatLines.push(ctx.muted(`  ${row.label} · 읽기 전용 snapshot (입력은 전달되지 않습니다)`));
+          ctx.chatLines.push(...stripAnsi(result.screen).split('\n'));
+        } else ctx.chatLines.push(ctx.warning(`  PTY 화면 읽기 실패 · ${result.status}`));
+      } catch (error) {
+        ctx.chatLines.push(ctx.warning(`  PTY 화면 읽기 오류 · ${error instanceof Error ? error.message : String(error)}`));
+      }
+    } else ctx.chatLines.push(ctx.warning('  attach할 PTY가 없습니다'));
+    ctx.setChatScrollOffset(-1);
+  });
+}

package/src/dashboard/slash-runtime/dashboard-handlers.ts

@@ -364,13 +364,15 @@ import {
   attachTelegramBinding as sessionAttachTelegram,
   listBoundSessions as sessionListBound,
 } from '../../session/index.js';
+import { idPrefixCell, sessionIdPrefixes, sessionListTime } from '../../session/id-prefix.js';
 import { safeReadLock as telegramSafeReadLock, defaultLockPath as telegramDefaultLockPath } from '../../telegram-lock.js';
 import { userConfigPath as userConfigPathFn } from '../../user-config.js';
 import { dirname as pathDirname, relative, resolve as resolvePath } from 'node:path';
 import { existsSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { installPlugin, listInstalledPlugins, type InstalledPlugin } from '../../plugins/install/plugin-install.js';
 import type { SurfaceUx } from '../../agent/surface-ux/types.js';
-import { renderReplayPreviewLines } from '../replay-preview.js';
+import { renderRestoredTranscriptLines } from '../replay-preview.js';
+import { noteRestoredContext } from '../../status/metrics.js';
 import {
   deriveDaemonHttpBase,
   fetchDaemonSessionList,
@@ -385,6 +387,7 @@ import { readDashboardAskClarification } from './ask-clarification.js';
 export { readDashboardAskClarification };
 import { createLoopScheduler, type LoopScheduler } from '../loop-scheduler.js';
 import { registerShellSlash } from './shell-slash.js';
+import { registerClassicSideSlash } from '../side-basic-runtime.js';
 export { registerShellSlash } from './shell-slash.js';
 import { registerMissionSlash } from '../../tui/slash/mission.js';
 // TUI-SLASH-SPLIT-MISSION(D4b) — /mission 은 src/tui/slash/mission.ts 로 이사. 옛 입구 re-export shim 은 slash-runtime/index.ts 한 곳뿐(RFC A5).
@@ -2395,6 +2398,8 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
         }
       } else if (result.kind === 'stopped-before-authoring') {
         ctx.chatLines.push(ctx.error('  ⛔ 저작 «전» 예비 검사에서 막혔다 — 위 이름을 확인하라'));
+      } else if (result.kind === 'stopped-by-timebox') {
+        ctx.chatLines.push(ctx.error(`  ⛔ AUTHOR-TIMEBOX 초과로 접지 없이 끝났다 — 골은 남아 있다: ${result.goalFile}`));
       } else {
         ctx.chatLines.push(ctx.error(`  ⛔ 전제 검사에서 막혔다 — 골은 남아 있다: ${result.goalFile}`));
       }
@@ -2573,6 +2578,7 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
 
 
   registerShellSlash(registry);
+  registerClassicSideSlash(registry);
 
   // ── B-3.b ─────────────────────────────────────────────────────────
 
@@ -2602,6 +2608,8 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
     if (seSub === 'list' || seSub === 'ls') {
       const limit = args[1] ? Math.max(1, Math.min(50, Number(args[1]) || 10)) : 10;
       const rows = sessionListSessions({ limit });
+      // Unique prefixes, not a fixed 8 — `/session load <shown prefix>` must resolve (TUI-RESUME-PICKER).
+      const idPrefixes = sessionIdPrefixes(rows.map((m) => m.id));
       // Tier 1 daemon merge — when attached to a remote daemon w/ a
       // derivable HTTP base, fetch the daemon's session list too so
       // the user sees web/PWA/other-client sessions alongside their
@@ -2628,9 +2636,9 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
           if (m.bindings?.telegram) binds.push(`tg:${m.bindings.telegram.chatId}`);
           if (m.bindings?.discord) binds.push(`dc:${m.bindings.discord.channelId}`);
           const bindStr = binds.length > 0 ? ctx.subtext(`[${binds.join(' ')}]`) : '';
-          const ts = m.updatedAt.slice(5, 16).replace('T', ' ');
+          const ts = sessionListTime(m.updatedAt);
           const title = (m.title || '(no title)').slice(0, 48);
-          ctx.chatLines.push(`  ${marker} ${ctx.text(m.id.slice(0, 8))}  ${ctx.muted(ts)}  ${ctx.muted(`${m.messageCount}t`.padStart(4))}  ${bindStr.padEnd(10)}  ${title}`);
+          ctx.chatLines.push(`  ${marker} ${ctx.text(idPrefixCell(idPrefixes, m.id))}  ${ctx.muted(ts)}  ${ctx.muted(`${m.messageCount}t`.padStart(4))}  ${bindStr.padEnd(10)}  ${title}`);
         }
       }
       if (daemonRows.length > 0) {
@@ -2734,13 +2742,14 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
               }
               ctx.setAttachedSessionId(match.id);
               try { sessionSetActiveId(match.id); } catch { /* best-effort */ }
+              noteRestoredContext(chatHistory);
               ctx.chatLines.push('');
               ctx.chatLines.push(ctx.success(`  ✓ swapped to daemon session ${match.id}`));
               if (past && past.length > 0) {
-                ctx.chatLines.push(ctx.muted(`    ${past.length} turn${past.length === 1 ? '' : 's'} restored. Preview of last 5:`));
+                ctx.chatLines.push(ctx.muted(`    ${past.length} turn${past.length === 1 ? '' : 's'} restored:`));
                 const swapPreviewWidth = Math.max(40, termSize().cols - 8);
                 const swapPreviewWrap = getUserConfig().chat.rendering.wrap;
-                const swapPreviewLines = renderReplayPreviewLines(past, {
+                const swapPreviewLines = renderRestoredTranscriptLines(past, {
                   maxWidth: swapPreviewWidth,
                   wrapOpts: swapPreviewWrap,
                 });
@@ -2792,11 +2801,13 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
       // side /attach (no-arg) picks up the same session automatically.
       try { sessionSetActiveId(resolvedId); } catch { /* best-effort */ }
       ctx.chatLines.push('');
-      ctx.chatLines.push(ctx.success(`  ✓ loaded session ${resolvedId.slice(0, 8)}  (${loaded.meta.title || '(no title)'})`));
-      ctx.chatLines.push(ctx.muted(`    ${loaded.history.length} turns restored. Preview of last 5:`));
+      ctx.chatLines.push(ctx.success(`  ✓ loaded session ${sessionIdPrefixes([resolvedId]).get(resolvedId) ?? resolvedId}  (${loaded.meta.title || '(no title)'})`));
+      ctx.chatLines.push(ctx.muted(`    ${loaded.history.length} turns restored:`));
+      const restoredTokens = noteRestoredContext(chatHistory);
+      debug.log('chat.session.load', 'restored', { sessionId: resolvedId, turns: loaded.history.length, estimatedContextTokens: restoredTokens });
       const loadPreviewWidth = Math.max(40, termSize().cols - 8);
       const loadPreviewWrap = getUserConfig().chat.rendering.wrap;
-      const loadPreviewLines = renderReplayPreviewLines(loaded.history, {
+      const loadPreviewLines = renderRestoredTranscriptLines(loaded.history, {
         maxWidth: loadPreviewWidth,
         wrapOpts: loadPreviewWrap,
       });

package/src/dashboard/synchronized-frame-output.ts

@@ -0,0 +1,74 @@
+/**
+ * TUI-FLICKER-DRAW-INTEGRATION — one synchronized-output owner per dashboard frame.
+ *
+ * A dashboard frame is not a single write: the transient-overlay cleanup, the
+ * base frame, the coordinator modal overlay, the prompt repaint and the
+ * post-frame overlay stamp are flushed one after another. Under tmux each of
+ * those flushes is presented on its own, so a tick that rewrites the frame is
+ * visible as a flicker. Wrapping the whole compose in DEC synchronized output
+ * (`CSI ? 2026 h` … `CSI ? 2026 l`) lets the terminal present the composite
+ * frame atomically.
+ *
+ * The owner is deliberately tiny and synchronous: callers open it, draw, and
+ * close it in a `finally` so a throw inside the draw still emits the ESU and
+ * the *next* frame is not swallowed by a dangling synchronized-output region.
+ *
+ * The wrap nests with the display coordinator, which opens the same region
+ * around its own flush and whose `onRender` hook is what calls `drawNow()`.
+ * `src/display/synchronized-output-region.ts` keeps that single-owner: an
+ * inner open contributes no bytes, so the coordinator's overlay + cursor stamp
+ * stays inside the one presentation instead of being pushed out by an early
+ * inner ESU.
+ */
+
+import {
+  SYNCHRONIZED_OUTPUT_BEGIN,
+  SYNCHRONIZED_OUTPUT_END,
+  openSynchronizedOutputRegion,
+  synchronizedOutputDisabledByEnv,
+} from '../display/synchronized-output-region.js';
+
+export { SYNCHRONIZED_OUTPUT_BEGIN, SYNCHRONIZED_OUTPUT_END };
+
+export interface SynchronizedFrameOutputDeps {
+  /** Sink for the control sequences — production passes `process.stdout.write`. */
+  write: (chunk: string) => void;
+  /**
+   * Whether the sink may receive DEC 2026. Defaults to `true`. Production
+   * passes `process.stdout.isTTY` so piped/captured output stays
+   * byte-identical to what it was before this seam existed.
+   */
+  supported?: boolean;
+  /** Environment escape hatch (`ELANOUS_SYNC_OUTPUT=off`). Defaults to `process.env`. */
+  env?: Record<string, string | undefined>;
+}
+
+export interface SynchronizedFrameOutput {
+  /** Closes the region. Idempotent — a second call writes nothing. */
+  close: () => void;
+}
+
+export function beginSynchronizedFrameOutput(
+  deps: SynchronizedFrameOutputDeps,
+): SynchronizedFrameOutput {
+  const region = openSynchronizedOutputRegion();
+  const enabled =
+    region.outermost && deps.supported !== false && !synchronizedOutputDisabledByEnv(deps.env);
+  let closed = false;
+  if (enabled) {
+    try {
+      deps.write(SYNCHRONIZED_OUTPUT_BEGIN);
+    } catch (err) {
+      region.close();
+      throw err;
+    }
+  }
+  return {
+    close: () => {
+      if (closed) return;
+      closed = true;
+      if (enabled) deps.write(SYNCHRONIZED_OUTPUT_END);
+      region.close();
+    },
+  };
+}

package/src/dashboard/term-slash-runtime.ts

@@ -127,6 +127,8 @@ export function createDashboardTermSlashRuntime(
       deps.muted('  /term list                List all alive sessions (fg / bg / exited).'),
       deps.muted('  /term attach <id>         Bring a backgrounded session to foreground.'),
       deps.muted('  /term detach              Send foreground session to background (PTY survives).'),
+      deps.muted('  Ctrl+B (while streaming)  Background running child tasks; turn continues.'),
+      deps.muted('  Ctrl+X c (chat input)     Enter control mode.'),
       deps.muted('  /term switch              Open the session picker modal.'),
       deps.muted('  /term kill <id>           Stop the PTY and remove the session.'),
       deps.muted('  /term snapshot <id> [tail [bytes]]   Capture current grid (snapshot) or last N bytes (tail).'),

package/src/dashboard/turn-preamble.ts

@@ -25,6 +25,7 @@ import { buildConcisenessSystemMessages } from '../prompt-library/chat-concisene
 import {
   buildSessionRuntimeSystemMessages,
   buildSessionRuntimeTurnSystemMessages,
+  buildResearchDateSystemMessage,
   type SessionTurnProfile,
 } from '../session-runtime/index.js';
 import { buildExecutionAskSystemMessages } from '../ask-user-question/index.js';
@@ -208,9 +209,13 @@ function buildDashboardTurnPreambleUnmeasured(
     gitSnapshotStaleMs: DASHBOARD_GIT_SNAPSHOT_STALE_MS,
   }));
   const turnProfile = ctx.turnProfile;
+  const researchTurn = turnProfile?.surface.id === 'research/agent';
   const surfaceSystemMsgs = turnProfile
     ? timed(builderMs, 'surface', () => buildSessionRuntimeTurnSystemMessages(turnProfile, ctx.userText))
     : ([] as LLMMessage[]);
+  if (researchTurn) {
+    surfaceSystemMsgs.push(buildResearchDateSystemMessage());
+  }
   // ⭐⭐ `tools.nativeStructure` 는 «어느 provider 에 켤지»를 목록으로 고를 수 있다(2026-08-18).
   //   ⛔ 목록이 없으면 종전대로 «전 provider» — 기존 설정을 쓰는 사람의 값이 안 바뀐다.
   //   ⛔ `config.llm.provider` 를 그대로 읽지 않는다. 그것은 `'auto'` 일 수 있고,
@@ -240,9 +245,9 @@ function buildDashboardTurnPreambleUnmeasured(
     nativeStructureEnabled,
     ...(nativeTools !== undefined ? { enabledTools: nativeTools } : {}),
   }) as LLMMessage[]);
-  const concisenessSystemMsgs = timed(builderMs, 'conciseness', () => buildConcisenessSystemMessages(
-    ctx.userConfig.chat.conciseness,
-  ) as LLMMessage[]);
+  const concisenessSystemMsgs = timed(builderMs, 'conciseness', () => researchTurn
+    ? [] as LLMMessage[]
+    : buildConcisenessSystemMessages(ctx.userConfig.chat.conciseness) as LLMMessage[]);
   // ★ elanous 자기접근 규율 + 자기인지 ambient(P3 · 2026-07-13) — 텔레그램/디스코드
   //   (makeElanousAgentRunTurn)와 단일 출처(agent/self-ambient.ts). TUI 채팅에서도 미션
   //   진단("P2 왜 실패?")·자율 시스템 관측·회상이 규율+ambient+툴(self-ops family) 3박자로
@@ -313,10 +318,29 @@ function buildDashboardTurnPreambleUnmeasured(
   let taskNotificationCount = 0;
   try {
     timed(builderMs, 'taskNotifications', () => {
+      // ACP may ask for a preamble while the session is idle. Keep queued
+      // completion receipts for the next actual user/auto-wake turn.
+      if (!ctx.userText.trim()) return;
+      const notificationOnlyWake = /(?:^|\n)(?:Question: )?\[자동 재개\] 위임 끝: .+ \((?:done|error|aborted)\) — <task-notification> 의 결과를 읽고 이어서 처리$/u
+        .test(ctx.userText);
+      if (notificationOnlyWake) {
+        preamble.push({ role: 'system', content: '[알림 전용 턴] 이것은 완료 알림을 전달한 비요청 status receipt다. 작업 요청으로 취급하지 말고 Agent 또는 SelfImplement 위임을 시작하지 않는다. 포함된 결과를 바탕으로 한 번의 간결한 상태 요약만 답하고 멈춘다. 결과가 전달되지 않았다면 결과가 아직 제공되지 않았다고 알리고 내용을 추측하지 않는다.' });
+      }
       const pendingNotifications = globalTaskNotificationQueue.drain();
       taskNotificationCount = pendingNotifications.length;
-      const taskNotificationsXml = renderTaskNotificationsXml(pendingNotifications);
+      if (pendingNotifications.length === 0) {
+        if (notificationOnlyWake) {
+          debug.log('tui.notify', 'notification-only-turn', { notificationCount: 0, resultAvailable: false });
+        }
+        return;
+      }
+      const taskNotificationsXml = renderTaskNotificationsXml(pendingNotifications, {
+        statusReceipt: notificationOnlyWake,
+      });
       if (taskNotificationsXml) {
+        debug.log('tui.notify', notificationOnlyWake ? 'notification-only-turn' : 'notification-with-user-request', {
+          notificationCount: pendingNotifications.length,
+        });
         preamble.push({ role: 'user', content: taskNotificationsXml });
       }
     });

package/src/display/coordinator.ts

@@ -22,6 +22,10 @@ import { TIER_ORDER, tierRank, tiersCompatible } from './types.js';
 import { resolveKeyAlias } from '../input-core/key-alias-table.js';
 import type { DisplayEventBus } from './events.js';
 import { paintCursor, type CursorState } from './cursor-state.js';
+import {
+  openSynchronizedOutputRegion,
+  synchronizedOutputDisabledByEnv,
+} from './synchronized-output-region.js';
 import { deriveCursor, type CursorDecision } from './cursor-owner.js';
 import {
   createVirtualCursorRegistry,
@@ -261,7 +265,6 @@ export class DisplayCoordinator {
    *  even when its bytes are unchanged, because the base rows under it
    *  were just repainted. Replaces the old forceNext follow-up. */
   private overlayRowsInvalidated = false;
-
   private surfaces = new Map<SurfaceId, DisplaySurface>();
   private focusNodes = new Map<SurfaceId, FocusNode>();
   private keyBindings = new Map<string, DisplayKeyBinding>();
@@ -288,6 +291,7 @@ export class DisplayCoordinator {
   private dirty = new Set<SurfaceId | 'all' | 'status' | 'dock'>();
   private forceNext = false;
   private scheduled: Timer | null = null;
+  private scheduleGeneration = 0;
   // P2.2.b — cursor state. Last-writer-wins. cursorVersion bumps on
   // every setCursor; lastEmittedCursorVersion tracks what's been
   // written so flushCursor only emits on change.
@@ -966,6 +970,36 @@ export class DisplayCoordinator {
     }, 'dashboard');
   }
 
+  /** Mark a render dirty and flush it before returning. Used when a host
+   *  already owns a synchronized output batch around the render. */
+  requestRenderNow(opts?: { region?: SurfaceId | 'all'; force?: boolean }): void {
+    this.markDirty(opts?.region ?? 'all');
+    if (opts?.force) this.forceNext = true;
+    this.scheduleGeneration += 1;
+    this.scheduled = null;
+    this.flush();
+  }
+
+  /** Run synchronous terminal writes inside DECSET 2026 when enabled.
+   *  Coordinator flushes, the dashboard draw seam, and host paint batches
+   *  share the same re-entrant region instead of emitting nested markers. */
+  withSynchronizedOutput<T>(paint: () => T): T {
+    const syncRegion = openSynchronizedOutputRegion();
+    const syncOutput = syncRegion.outermost && this.syncOutputEnabled;
+    try {
+      if (syncOutput) {
+        this.writeOverlay?.('\x1b[?2026h');
+      }
+      return paint();
+    } finally {
+      try {
+        if (syncOutput) this.writeOverlay?.('\x1b[?2026l');
+      } finally {
+        syncRegion.close();
+      }
+    }
+  }
+
   handle(owner: SurfaceOwner): DisplayHandle {
     return {
       owner,
@@ -2629,10 +2663,16 @@ export class DisplayCoordinator {
 
   private requestFrame(): void {
     if (this.scheduled !== null) return;
-    this.scheduled = this.scheduleFn(() => {
+    const generation = ++this.scheduleGeneration;
+    const marker = {} as Timer;
+    let scheduled: Timer | undefined;
+    this.scheduled = marker;
+    scheduled = this.scheduleFn(() => {
+      if (generation !== this.scheduleGeneration || (this.scheduled !== marker && this.scheduled !== scheduled)) return;
       this.scheduled = null;
       this.flush();
     }, this.frameMs);
+    if (this.scheduled === marker) this.scheduled = scheduled;
   }
 
   private flush(): void {
@@ -2661,9 +2701,7 @@ export class DisplayCoordinator {
     // `ELANOUS_SYNC_OUTPUT=off` for buggy terminals (none observed in
     // practice, 2026-04-21). Pattern matches Textual (synchronized
     // output since v0.47) + Ratatui backend buffer-swap semantics.
-    const syncOutput = this.syncOutputEnabled;
-    if (syncOutput) this.writeOverlay?.('\x1b[?2026h');
-    try {
+    this.withSynchronizedOutput(() => {
       // H1.6 · W2 shadow flush. Fires rc.on('before-flush') +
       // rc.on('after-flush') synchronously. Subscriber paints (if any
       // are wired in Phase γ) land INSIDE the DECSET 2026 atomic-frame
@@ -2696,11 +2734,7 @@ export class DisplayCoordinator {
       // so the prior cursor position may have been overwritten. Always
       // re-assert. The bypass-batch path calls flushCursor(false).
       this.flushCursor(true);
-    } finally {
-      // Always close the sync block — a throw inside render hooks
-      // must not leave the terminal stuck in "buffering" mode.
-      if (syncOutput) this.writeOverlay?.('\x1b[?2026l');
-    }
+    });
     this.eventBus?.emit({ type: 'render:after', request, snapshot });
     this.pendingWidgetPatches = [];
     this.pendingLogLines = [];
@@ -2713,8 +2747,7 @@ export class DisplayCoordinator {
    *  not a TTY (unit-test + CI environment) so overlay assertions
    *  don't have to strip the ?2026h / ?2026l pair. */
   private get syncOutputEnabled(): boolean {
-    const v = (process.env.ELANOUS_SYNC_OUTPUT ?? 'on').toLowerCase();
-    if (v === 'off' || v === '0' || v === 'false') return false;
+    if (synchronizedOutputDisabledByEnv()) return false;
     // Non-TTY environments (tests, piped output) gain nothing from
     // atomic frame wrapping and the sequences would pollute assertions.
     if (typeof process !== 'undefined' && process.stdout && process.stdout.isTTY !== true) {

package/src/display/resize-listener.ts

@@ -5,10 +5,9 @@
 // resize produced a stale paint (old input prompt row + ghost tab
 // bar) until the next keystroke triggered a redraw.
 //
-// Strategy: on every stdout resize event, (1) push a forced dashboard
-// redraw and (2) invoke the prompt's repaint hook so input-mode
-// overlays catch up too. Both calls are wrapped in try/catch so a
-// transient paint error doesn't kill the listener.
+// Strategy: debounce resize bursts for one frame (16ms), then paint the
+// dashboard, prompt, and overlays synchronously inside one atomic output
+// block. Transient paint errors do not kill the listener.
 //
 // (3) TUI-PICKER-RESIZE-SHRINK (#76 · 2026-10-17) — then ask the
 // coordinator for one FORCED frame. Steps (1)+(2) bypass the
@@ -28,6 +27,8 @@
 
 import { debug } from '../debug/log.js';
 
+const RESIZE_DEBOUNCE_MS = 16;
+
 export interface ResizeListenerDeps {
   draw: (opts?: { force?: boolean }) => void;
   promptCtl: { repaint: () => void };
@@ -35,6 +36,9 @@ export interface ResizeListenerDeps {
    *  re-emitted on top of the chrome the prompt repaint just wrote.
    *  Optional: hosts without a coordinator keep the legacy two-step. */
   requestOverlayFrame?: () => void;
+  /** Run the whole resize repaint batch inside the host's atomic output
+   *  block. Nested coordinator frames must share this outer block. */
+  withSynchronizedOutput?: (paint: () => void) => void;
 }
 
 /** Registers the resize listener and returns a dispose fn that
@@ -42,26 +46,43 @@ export interface ResizeListenerDeps {
  *  fresh listener; the caller is responsible for disposing previous
  *  installations. */
 export function installResizeListener(deps: ResizeListenerDeps): () => void {
-  const handler = (): void => {
-    try { deps.draw({ force: true }); } catch { /* swallow — paint errors shouldn't break resize */ }
-    try { deps.promptCtl.repaint(); } catch { /* swallow */ }
-    let overlayFrame: 'requested' | 'absent' | 'failed' = 'absent';
-    if (deps.requestOverlayFrame) {
-      try {
-        deps.requestOverlayFrame();
-        overlayFrame = 'requested';
-      } catch {
-        overlayFrame = 'failed';
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let disposed = false;
+  const repaint = (): void => {
+    timer = undefined;
+    if (disposed) return;
+    const paint = (): void => {
+      try { deps.draw({ force: true }); } catch { /* swallow — paint errors shouldn't break resize */ }
+      try { deps.promptCtl.repaint(); } catch { /* swallow */ }
+      let overlayFrame: 'requested' | 'absent' | 'failed' = 'absent';
+      if (deps.requestOverlayFrame) {
+        try {
+          deps.requestOverlayFrame();
+          overlayFrame = 'requested';
+        } catch {
+          overlayFrame = 'failed';
+        }
       }
-    }
-    debug.log('display.resize', 'repaint', {
-      cols: process.stdout.columns ?? null,
-      rows: process.stdout.rows ?? null,
-      overlayFrame,
-    });
+      debug.log('display.resize', 'repaint', {
+        cols: process.stdout.columns ?? null,
+        rows: process.stdout.rows ?? null,
+        overlayFrame,
+      });
+    };
+    try {
+      if (deps.withSynchronizedOutput) deps.withSynchronizedOutput(paint);
+      else paint();
+    } catch { /* resize painting must not detach the listener */ }
+  };
+  const handler = (): void => {
+    if (timer !== undefined) clearTimeout(timer);
+    timer = setTimeout(repaint, RESIZE_DEBOUNCE_MS);
   };
   process.stdout.on('resize', handler);
   return (): void => {
+    disposed = true;
+    if (timer !== undefined) clearTimeout(timer);
+    timer = undefined;
     process.stdout.removeListener('resize', handler);
   };
 }

package/src/display/synchronized-output-region.ts

@@ -0,0 +1,60 @@
+/**
+ * DECSET 2026 (synchronized output) region registry.
+ *
+ * Two owners wrap their writes in `CSI ? 2026 h` … `CSI ? 2026 l`: the
+ * display coordinator (`flush()`) and the dashboard draw seam
+ * (`src/dashboard/synchronized-frame-output.ts`). They nest — the
+ * coordinator opens a region and its `onRender` hook runs `drawNow()`,
+ * which wants the same wrap for the frame + prompt repaint. A second pair
+ * emitted inside the outer one is not harmless: the inner ESU flushes the
+ * terminal early, so everything the coordinator writes afterwards (modal
+ * overlay, cursor) lands in a separate presentation — exactly the flicker
+ * the wrap exists to prevent.
+ *
+ * The registry makes the wrap re-entrant: whoever opens first owns the
+ * byte pair; nested openers contribute no bytes and never close the outer
+ * region. Every opener must close its handle (idempotent) so the depth
+ * stays balanced even when a draw throws.
+ */
+
+export const SYNCHRONIZED_OUTPUT_BEGIN = '\x1b[?2026h';
+export const SYNCHRONIZED_OUTPUT_END = '\x1b[?2026l';
+
+export interface SynchronizedOutputRegion {
+  /** true when this region owns the emitted BSU/ESU pair. */
+  readonly outermost: boolean;
+  /** Idempotent — closes this region exactly once. */
+  close(): void;
+}
+
+let openDepth = 0;
+
+/** True while any owner holds a synchronized-output region open. */
+export function isSynchronizedOutputRegionOpen(): boolean {
+  return openDepth > 0;
+}
+
+/**
+ * `ELANOUS_SYNC_OUTPUT=off|0|false` escape hatch for terminals that
+ * mishandle DEC 2026. Anything else (including unset) keeps the wrap on.
+ */
+export function synchronizedOutputDisabledByEnv(
+  env: Record<string, string | undefined> = process.env,
+): boolean {
+  const value = (env.ELANOUS_SYNC_OUTPUT ?? 'on').toLowerCase();
+  return value === 'off' || value === '0' || value === 'false';
+}
+
+export function openSynchronizedOutputRegion(): SynchronizedOutputRegion {
+  const outermost = openDepth === 0;
+  openDepth += 1;
+  let closed = false;
+  return {
+    outermost,
+    close(): void {
+      if (closed) return;
+      closed = true;
+      if (openDepth > 0) openDepth -= 1;
+    },
+  };
+}

package/src/domains/guardian-tick.ts

@@ -19,6 +19,8 @@ export interface GuardianDeps {
   execute?: (command: string) => Promise<SpawnOutcome>;
   /** Injected only for deterministic expiry-alert tests. Production reads the local Grok auth file. */
   grokExpiry?: () => string | null;
+  /** Injected in tests; production reevaluates recorded doctor visits without dispatching a prescription. */
+  doctorShadow?: () => void | Promise<void>;
   hostName?: string;
 }
 
@@ -100,6 +102,13 @@ export async function guardianTick(now: Date, plan: GuardianPlan, deps: Guardian
       errorName: error instanceof Error ? error.name : 'unknown',
     });
   }
+  try {
+    await deps.doctorShadow?.();
+  } catch (error) {
+    debug.log('guardian.doctor-shadow', 'reevaluation-failed', {
+      errorName: error instanceof Error ? error.name : 'unknown',
+    });
+  }
   const timeZone = plan.timeZone ?? resolveTimeZone().timeZone;
   const wouldRun: string[] = [];
   let executed = 0;