elanous 0.2.34 → 0.2.35

package/src/cli/usage-cli.ts

@@ -75,10 +75,11 @@ function configuredUsageHosts(): { local: string; remote: string[] } {
   return { local, remote: [...new Set(entries.map((entry) => entry.host?.trim()).filter((host): host is string => !!host && host !== local))] };
 }
 
-type UsageAxis = 'stage' | 'model' | 'account';
+type UsageAxis = 'stage' | 'phase' | 'model' | 'account';
 type ExtendedRunUsageInput = RunUsageInput & { stage?: string | null; account?: string | null; origin?: string; podJob?: string; job?: string; measured?: boolean };
 type AxisUsageRow = {
   stage?: string;
+  phase?: string;
   model?: string;
   account?: string;
   hostIds: string[];
@@ -97,7 +98,7 @@ type AxisUsageRow = {
 };
 
 type FederatedUsageRow = {
-  runId?: string; role?: string; site?: string; stage?: string; model?: string; account?: string;
+  runId?: string; role?: string; site?: string; stage?: string; phase?: string; model?: string; account?: string;
   billingProvider?: string; billing?: string; hostIds: string[]; rankUsd?: number;
   calls: number; inputTokens: number; outputTokens: number; cacheReadInputTokens: number;
   cacheCreationInputTokens: number; reasoningOutputTokens: number; usdKnown: number;
@@ -122,7 +123,7 @@ function validUsageRows(value: unknown, axis: 'run' | 'role' | UsageAxis): value
         const number = row[field];
         return typeof number === 'number' && Number.isFinite(number) && number >= 0;
       })
-      && (axis !== 'stage' && axis !== 'model' && axis !== 'account'
+      && (axis !== 'stage' && axis !== 'phase' && axis !== 'model' && axis !== 'account'
         || typeof row.rankUsd === 'number' && Number.isFinite(row.rankUsd));
   });
 }
@@ -137,7 +138,7 @@ function mergeUsageRows(groups: readonly FederatedUsageRow[][], axis: 'run' | 'r
     if (!previous) { merged.set(key, { ...row, hostIds: [...row.hostIds] }); continue; }
     for (const field of SUM_FIELDS) previous[field] += row[field];
     previous.hostIds = [...new Set([...previous.hostIds, ...row.hostIds])];
-    if (axis === 'stage' || axis === 'model' || axis === 'account') previous.rankUsd = previous.usdKnown + previous.apiEquivalentUsd;
+    if (axis === 'stage' || axis === 'phase' || axis === 'model' || axis === 'account') previous.rankUsd = previous.usdKnown + previous.apiEquivalentUsd;
   }
   return [...merged.values()];
 }
@@ -186,6 +187,7 @@ function rollupByAxis(inputs: readonly ExtendedRunUsageInput[], axis: UsageAxis)
   const groups = new Map<string, ExtendedRunUsageInput[]>();
   for (const data of inputs) {
     const value = axis === 'stage' ? stageForUsage(data)
+      : axis === 'phase' ? (typeof data.phase === 'string' && data.phase.length > 0 ? data.phase : '(none)')
       : axis === 'model' ? (data.model || '(none)')
         : (data.account || '(none)');
     const group = groups.get(value) ?? [];
@@ -216,7 +218,7 @@ function rollupByAxis(inputs: readonly ExtendedRunUsageInput[], axis: UsageAxis)
 }
 
 function isUsageAxis(value: string): value is 'run' | 'role' | UsageAxis {
-  return value === 'run' || value === 'role' || value === 'stage' || value === 'model' || value === 'account';
+  return value === 'run' || value === 'role' || value === 'stage' || value === 'phase' || value === 'model' || value === 'account';
 }
 
 function formatAxisUsage(row: AxisUsageRow, axis: UsageAxis): string {
@@ -249,9 +251,9 @@ export function registerUsageCommand(program: Command, deps: UsageCliDeps = {}):
 
   usage
     .command('runs')
-    .description('저장된 llm-usage 로그를 런·역할·단계·모델·계정별로 집계한다')
+    .description('저장된 llm-usage 로그를 런·역할·단계·phase·모델·계정별로 집계한다')
     .option('--run <runId>', '런 ID 정확 일치')
-    .option('--by <axis>', '집계 축 (run | role | stage | model | account)', 'run')
+    .option('--by <axis>', '집계 축 (run | role | stage | phase | model | account)', 'run')
     .option(...LOGS_SINCE_OPTION)
     .option('--hosts <scope>', '호스트 연합 (all: 이 호스트 + 설정된 taskAgent.parentHost)')
     .option('--json', '집계 행 JSON 출력')
@@ -298,14 +300,14 @@ export function registerUsageCommand(program: Command, deps: UsageCliDeps = {}):
         const complete = !rosterReason && hosts.every((host) => host.status === 'ok');
         const rows = mergeUsageRows(parts, opts.by as 'run' | 'role' | UsageAxis);
         if (opts.by === 'role') rows.sort((a, b) => b.calls - a.calls);
-        if (opts.by === 'stage' || opts.by === 'model' || opts.by === 'account') rows.sort((a, b) => (b.rankUsd ?? 0) - (a.rankUsd ?? 0) || b.calls - a.calls);
+        if (opts.by === 'stage' || opts.by === 'phase' || opts.by === 'model' || opts.by === 'account') rows.sort((a, b) => (b.rankUsd ?? 0) - (a.rankUsd ?? 0) || b.calls - a.calls);
         if (json) { out.log(JSON.stringify({ rows, hosts, complete, ...(rosterReason ? { reason: rosterReason } : {}) }, null, 2)); return; }
         out.log(`호스트 ${hosts.filter((host) => host.status === 'ok').length}/${hosts.length} 측정 · ${complete ? '완결' : '부분 합계'}`);
         if (rosterReason) out.log(`호스트 목록: 못 잼 (${rosterReason})`);
         for (const host of hosts) if (host.status === 'unmeasured') out.log(`${host.host}: 못 잼 (${host.reason})`);
         if (rows.length === 0) { out.log('(일치하는 런 사용량 없음)'); return; }
         for (const row of rows) {
-          if (opts.by === 'stage' || opts.by === 'model' || opts.by === 'account') out.log(formatAxisUsage(row as AxisUsageRow, opts.by));
+          if (opts.by === 'stage' || opts.by === 'phase' || opts.by === 'model' || opts.by === 'account') out.log(formatAxisUsage(row as AxisUsageRow, opts.by));
           else if (opts.by === 'role') out.log(`${row.role}  ${row.site}  ${row.model}  ${row.billingProvider}/${row.billing}  calls=${row.calls}  input=${row.inputTokens}  output=${row.outputTokens}  usdKnown=${row.usdKnown}  unknownCostCalls=${row.unknownCostCalls}  includedCalls=${row.includedCalls}  apiEquivalentUsd=${row.apiEquivalentUsd}`);
           else out.log(`${row.runId}  ${row.model}  ${row.billingProvider}/${row.billing}  hosts=${row.hostIds.join(',') || '(none)'}  calls=${row.calls}  input=${row.inputTokens}  output=${row.outputTokens}  cacheRead=${row.cacheReadInputTokens}  cacheCreation=${row.cacheCreationInputTokens}  reasoning=${row.reasoningOutputTokens}  usdKnown=${row.usdKnown}  unknownCostCalls=${row.unknownCostCalls}  includedCalls=${row.includedCalls}  apiEquivalentUsd=${row.apiEquivalentUsd}`);
         }
@@ -323,14 +325,14 @@ export function registerUsageCommand(program: Command, deps: UsageCliDeps = {}):
           localFailure = '로컬 logs.db 조회 실패';
         }
       }
-      const unwrapPod = opts.by === 'stage' || opts.by === 'model' || opts.by === 'account';
+      const unwrapPod = opts.by === 'stage' || opts.by === 'phase' || opts.by === 'model' || opts.by === 'account';
       // ⭐ METER-POD-ROLLUP-GAP-2 — Pod 사용량 재방출 행(podRollupKey)은 «더 완전한 한 행»만 센다(키 없는 행은 그대로).
       const selected = rows.map((row) => usageData(row, unwrapPod))
         .filter((data): data is ExtendedRunUsageInput => data !== null)
         .filter((data) => opts.run === undefined || data.runId === opts.run);
       // A returned Pod raw row and its host rollup describe the same usage. Keep raw rows when no measured rollup exists.
       const inputs = dedupePodRollupRows(unwrapPod ? excludeCoveredPodRawRows(selected) : selected);
-      if (opts.by === 'stage' || opts.by === 'model' || opts.by === 'account') {
+      if (opts.by === 'stage' || opts.by === 'phase' || opts.by === 'model' || opts.by === 'account') {
         const report = rollupByAxis(inputs, opts.by);
         if (opts.hosts === 'all') { emitFederated(report, localFailure); return; }
         if (json) {

package/src/clipboard/history.ts

@@ -8,15 +8,19 @@
 //
 // Why polling vs an OS event hook: macOS doesn't expose a clipboard-
 // changed notification to userland binaries without entitlements.
-// pbpaste at 1.5s cadence is cheap (sub-millisecond per call on a
-// recent Mac) and the small lag is fine for "look back at what I
-// copied 30s ago" use cases.
+// Keep a short active cadence, then back off while the TUI is idle so
+// an open terminal does not spawn pbpaste every 1.5s indefinitely.
+// CLASSIC-IDLE-CLIPBOARD (2026-10-21): callers that only show the history
+// inside a panel start with `active: false` and flip `setActive(true)` while
+// the panel is visible — a closed panel spawns zero pbpaste processes
+// (5-minute idle classic TUI measured 88 reads before this change).
 //
 // Image entries: we already track a separate path-based registry for
 // pasted screenshots (context.ts). This module is text-only by
 // design — image previews live in the main scratchpad already.
 
 import { readClipboardText, isClipboardSupported } from './index.js';
+import { debug } from '../debug/log.js';
 
 export interface ClipboardEntry {
   /** UTF-8 text. Trimmed of a single trailing newline so visually
@@ -29,6 +33,19 @@ export interface ClipboardEntry {
 export interface ClipboardHistoryOpts {
   /** Polling interval in ms. Defaults to 1500. */
   intervalMs?: number;
+  /** Start slowing clipboard reads after this much user inactivity. Defaults to 2 minutes. */
+  idleAfterMs?: number;
+  /** Poll interval multiplier after idleAfterMs. Defaults to 10 (15s with the default cadence). */
+  idleIntervalMultiplier?: number;
+  /** Start the deepest backoff after this much user inactivity. Defaults to 10 minutes. */
+  longIdleAfterMs?: number;
+  /** Poll interval multiplier after longIdleAfterMs. Defaults to 60 (90s with the default cadence). */
+  longIdleIntervalMultiplier?: number;
+  /** Start polling immediately. Defaults to true. `false` keeps the poller
+   *  dormant (no reads, no timer) until `setActive(true)`. */
+  active?: boolean;
+  /** Busy streams keep the active cadence and restart the idle grace period when they finish. */
+  isBusy?: () => boolean;
   /** Cap on stored entries; oldest fall off when exceeded. Defaults
    *  to 50 — enough for a typical session, not so big the list
    *  becomes unscrollable. */
@@ -40,6 +57,17 @@ export interface ClipboardHistoryOpts {
   maxBytes?: number;
 }
 
+/** Dependencies are injectable so tests can exercise the real poller without
+ * process-wide `mock.module()` state. Production callers use the defaults. */
+export interface ClipboardHistoryDependencies {
+  readClipboardText(): Promise<string | null>;
+  isClipboardSupported(): boolean;
+  /** Observation sink for poll-state transitions. Defaults to
+   *  `debug.log('clipboard.history', …)`; tests inject a recorder because
+   *  the debug sink arms its own flush timer. */
+  observe?(event: 'poll-state', data: { active: boolean; reason: string }): void;
+}
+
 export interface ClipboardHistory {
   /** Snapshot list, newest first. Caller may read but should not
    *  mutate — use `clear` to reset. */
@@ -54,12 +82,27 @@ export interface ClipboardHistory {
    *  history reflects the just-promoted entry without waiting for
    *  the next tick. */
   pokeNow(): Promise<void>;
+  /** Mark TUI input. Wakes the poller immediately if it had slowed down. */
+  noteActivity(): void;
+  /** Notify the poller immediately when its busy source changes state. */
+  noteBusyChange(): void;
+  /** Start/stop background polling (e.g. history panel opened/closed).
+   *  Activating reads once immediately; deactivating clears the timer.
+   *  Repeating the current state is a no-op. */
+  setActive(active: boolean, reason?: string): void;
 }
 
 /** Start polling. No-op on non-clipboard platforms — returns a stub
  *  with empty entries so callers don't need to guard every call. */
-export function startClipboardHistory(opts: ClipboardHistoryOpts = {}): ClipboardHistory {
+export function startClipboardHistory(
+  opts: ClipboardHistoryOpts = {},
+  dependencies: ClipboardHistoryDependencies = { readClipboardText, isClipboardSupported },
+): ClipboardHistory {
   const intervalMs = opts.intervalMs ?? 1500;
+  const idleAfterMs = opts.idleAfterMs ?? 2 * 60_000;
+  const idleIntervalMultiplier = opts.idleIntervalMultiplier ?? 10;
+  const longIdleAfterMs = opts.longIdleAfterMs ?? 10 * 60_000;
+  const longIdleIntervalMultiplier = opts.longIdleIntervalMultiplier ?? 60;
   const maxEntries = opts.maxEntries ?? 50;
   const maxBytes = opts.maxBytes ?? 8 * 1024;
 
@@ -67,15 +110,51 @@ export function startClipboardHistory(opts: ClipboardHistoryOpts = {}): Clipboar
   const subs = new Set<() => void>();
   let stopped = false;
   let lastSeenText: string | null = null;
-  let timer: ReturnType<typeof setInterval> | null = null;
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  let inFlight: Promise<void> | null = null;
+  let immediatePollAfterInFlight = false;
+  let queuedActivityPoll: Promise<void> | null = null;
+  let lastActivityAt = Date.now();
+  let wasBusy = readBusy();
+  let active = opts.active ?? true;
+
+  function readBusy(): boolean {
+    try { return opts.isBusy?.() ?? false; } catch { return false; }
+  }
+
+  const idleMs = (): number => {
+    const busy = readBusy();
+    if (wasBusy && !busy) lastActivityAt = Date.now();
+    wasBusy = busy;
+    return busy ? 0 : Math.max(0, Date.now() - lastActivityAt);
+  };
+
+  const nextDelayMs = (): number => {
+    const idle = idleMs();
+    if (idle >= longIdleAfterMs) return intervalMs * longIdleIntervalMultiplier;
+    if (idle >= idleAfterMs) return intervalMs * idleIntervalMultiplier;
+    return intervalMs;
+  };
+
+  const scheduleNext = (): void => {
+    if (stopped || !active) return;
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = null;
+      void poll();
+    }, nextDelayMs());
+  };
 
-  if (!isClipboardSupported()) {
+  if (!dependencies.isClipboardSupported()) {
     return {
       entries,
       onChange: (fn) => { subs.add(fn); return () => subs.delete(fn); },
       stop: () => { stopped = true; },
       clear: () => { entries.length = 0; },
       pokeNow: async () => { /* no-op */ },
+      noteActivity: () => {},
+      noteBusyChange: () => {},
+      setActive: () => {},
     };
   }
 
@@ -97,25 +176,112 @@ export function startClipboardHistory(opts: ClipboardHistoryOpts = {}): Clipboar
     for (const fn of subs) { try { fn(); } catch { /* ignore */ } }
   };
 
-  const poll = async (): Promise<void> => {
-    if (stopped) return;
-    try { ingest(await readClipboardText()); } catch { /* swallow */ }
+  const poll = (): Promise<void> => {
+    if (stopped) return Promise.resolve();
+    if (inFlight) return inFlight;
+    const run = Promise.resolve().then(async (): Promise<void> => {
+      try { ingest(await dependencies.readClipboardText()); } catch { /* swallow */ }
+      finally {
+        inFlight = null;
+        if (immediatePollAfterInFlight && !stopped) {
+          immediatePollAfterInFlight = false;
+          queuedActivityPoll = poll();
+          void queuedActivityPoll;
+        } else {
+          immediatePollAfterInFlight = false;
+          scheduleNext();
+        }
+      }
+    });
+    inFlight = run;
+    return run;
+  };
+
+  const pollImmediately = (): void => {
+    if (inFlight) {
+      immediatePollAfterInFlight = true;
+      return;
+    }
+    void poll();
+  };
+
+  const noteActivity = (): void => {
+    const wokeFromIdle = idleMs() >= idleAfterMs;
+    lastActivityAt = Date.now();
+    wasBusy = readBusy();
+    if (wokeFromIdle && active) {
+      if (timer) clearTimeout(timer);
+      timer = null;
+      pollImmediately();
+    }
+  };
+
+  const noteBusyChange = (): void => {
+    const busy = readBusy();
+    if (busy === wasBusy) return;
+    wasBusy = busy;
+    lastActivityAt = Date.now();
+    if (!active) return;
+    if (timer) clearTimeout(timer);
+    timer = null;
+    pollImmediately();
+  };
+
+  const setActive = (next: boolean, reason = 'unspecified'): void => {
+    if (stopped || next === active) return;
+    active = next;
+    const observe = dependencies.observe
+      ?? ((event: string, data: unknown) => { debug.log('clipboard.history', event, data); });
+    try { observe('poll-state', { active, reason }); } catch { /* observation must not break polling */ }
+    if (timer) clearTimeout(timer);
+    timer = null;
+    if (!active) {
+      immediatePollAfterInFlight = false;
+      return;
+    }
+    lastActivityAt = Date.now();
+    wasBusy = readBusy();
+    pollImmediately();
   };
 
   // Kick off immediately so the very first frame already has at
   // least one entry (whatever's currently on the clipboard).
-  void poll();
-  timer = setInterval(() => { void poll(); }, intervalMs);
+  // A dormant poller (active:false) reads on its first setActive(true).
+  if (active) void poll();
 
   return {
     entries,
     onChange: (fn) => { subs.add(fn); return () => subs.delete(fn); },
     stop: () => {
       stopped = true;
-      if (timer) clearInterval(timer);
+      if (timer) clearTimeout(timer);
       timer = null;
     },
     clear: () => { entries.length = 0; lastSeenText = null; },
-    pokeNow: async () => { await poll(); },
+    pokeNow: async () => {
+      // Keep this request independent from noteActivity. If a wake poll is
+      // already queued behind the current read, it will satisfy this poke.
+      lastActivityAt = Date.now();
+      wasBusy = readBusy();
+      const currentRead = inFlight;
+      const canUseQueuedWake = Boolean(currentRead && immediatePollAfterInFlight);
+      if (timer) clearTimeout(timer);
+      timer = null;
+      if (currentRead) {
+        await currentRead;
+        if (canUseQueuedWake && queuedActivityPoll) {
+          await queuedActivityPoll;
+          return;
+        }
+        if (timer) clearTimeout(timer);
+        timer = null;
+      }
+      // Reads already in progress may have captured the clipboard before
+      // this promotion, so take a fresh snapshot after they finish.
+      await poll();
+    },
+    noteActivity,
+    noteBusyChange,
+    setActive,
   };
 }

package/src/config.ts

@@ -6,6 +6,7 @@ import { lookupLlmTierSpec } from './model-tier/llm-tier-map.js';
 import { listSshHosts } from './ssh/ssh-hosts.js';
 import { isInstalledPackagePath } from './instance/installed-package.js';
 import { defaultObsidianVault } from './obsidian/default-vault.js';
+import { OPENGATEWAY_DEFAULT_MODEL } from './llm/opengateway-models.js';
 
 // ── User config ──
 export const REMOTE_HOME = homedir();
@@ -191,7 +192,7 @@ export function refreshKeyFromCache(envName: string): boolean {
  * 자식 프로세스도 이 env 를 물려받는다. 반환 = 캐시로 채운 이름(값은 절대 안 싣는다).
  */
 export const DAEMON_KEY_ENV_NAMES = [
-  'ANTHROPIC_API_KEY', 'GEMINI_API_KEY', 'OPENAI_API_KEY', 'XAI_API_KEY', 'OPENROUTER_API_KEY',
+  'ANTHROPIC_API_KEY', 'GEMINI_API_KEY', 'OPENAI_API_KEY', 'XAI_API_KEY', 'OPENROUTER_API_KEY', 'OPENGATEWAY_API_KEY',
   'ELANOUS_OPENAI_RELAY_SHARED_SECRET',
 ] as const;
 
@@ -239,6 +240,12 @@ export const OPENROUTER_API_URL = 'https://openrouter.ai/api/v1/chat/completions
 // 기본 = 사다리 `balanced`(`llm-tier-map.ts` OPENROUTER). 카탈로그 id 는 `openrouter/<vendor>/<model>`,
 //   wire 로는 `openrouter/` 를 떼고 보낸다(`makeOpenRouterProvider`).
 export const OPENROUTER_MODEL = process.env.OPENROUTER_MODEL || 'openrouter/z-ai/glm-5.3';
+/** Optional OpenAI-compatible gateway. Cache wins over inherited env, as for other API keys. */
+export function getOpenGatewayApiKey(): string | undefined {
+  return keyFromCacheOrEnv('OPENGATEWAY_API_KEY');
+}
+export const OPENGATEWAY_API_URL = 'https://apis.opengateway.ai/v1/chat/completions';
+export const OPENGATEWAY_MODEL = process.env.OPENGATEWAY_MODEL || OPENGATEWAY_DEFAULT_MODEL;
 export function getLocalLLMUrl(): string | undefined {
   return process.env.LOCAL_LLM_URL; // e.g. http://localhost:11434/v1 (ollama)
 }

package/src/dashboard/chat/acp-chat.ts

@@ -137,6 +137,8 @@ export interface DashboardAcpChatOpts {
   /** Logger for subprocess stderr / protocol events. Route into the
    *  dashboard debug log (pushLog). */
   log?: (msg: string) => void;
+  /** Notify idle-sensitive dashboard services when an ACP turn starts or ends. */
+  onBusyChange?: () => void;
   /** Dependency injection hook for tests — overrides the default
    *  `globalAcpAgentManager()` lookup. Production call sites omit
    *  this field. */
@@ -180,6 +182,7 @@ export interface DashboardAcpChatOpts {
 export class DashboardAcpChat {
   private readonly getCwd: () => string;
   private readonly log: (msg: string) => void;
+  private readonly onBusyChange?: () => void;
   private readonly agentManager: NonNullable<DashboardAcpChatOpts['agentManager']>;
   private readonly sessionStore: NonNullable<DashboardAcpChatOpts['sessionStore']>;
   private readonly permissionApprover?: AcpPermissionApprover;
@@ -209,6 +212,7 @@ export class DashboardAcpChat {
       this.getCwd = () => getSessionCwd();
     }
     this.log = opts.log ?? ((_m) => { /* default: drop */ });
+    this.onBusyChange = opts.onBusyChange;
     this.agentManager = opts.agentManager ?? {
       getAgent: (backendId, o) => globalAcpAgentManager().getAgent(backendId, o) as any,
     };
@@ -321,6 +325,7 @@ export class DashboardAcpChat {
         throw new Error(`${displayBackendName(backendId)} already has a turn in flight — /acp cancel first`);
       }
       sess.inFlight = true;
+      this.onBusyChange?.();
       if (debug.enabled) {
         handlers.pushLine(`  → sending to ${displayBackendName(backendId)}…`);
       }
@@ -359,11 +364,14 @@ export class DashboardAcpChat {
       }
       this.closeStreamBuffer(sess, 'flush');
       sess.inFlight = false;
+      this.onBusyChange?.();
       handlers.onDone(result.stopReason);
     } catch (err) {
       if (sess) {
         this.closeStreamBuffer(sess, 'flush');
+        const wasBusy = sess.inFlight;
         sess.inFlight = false;
+        if (wasBusy) this.onBusyChange?.();
       }
       handlers.onError(err instanceof Error ? err : new Error(formatAcpError(err)));
     }

package/src/dashboard/index.ts

@@ -889,7 +889,8 @@ import {
   refreshDirtyAsync as refreshGitDirtyAsync,
   refreshGitSnapshotAsync,
 } from '../git-fs/index.js';
-import { refreshSelfAmbientCache } from '../agent/self-ambient-cache.js';
+import { createIdleGitPoll, dashboardIdleMs, gitDirtyRefreshIntervalMs } from '../git-fs/idle-refresh.js';
+import { refreshSelfAmbientCache, selfAmbientKeepWarmIntervalMs } from '../agent/self-ambient-cache.js';
 import { getPty, listPty, requestPtyTakeover } from '../pty-shell/registry.js';
 import { listPtyManifestRowsAt } from '../pty-shell/pty-manifest.js';
 import { ptyManifestTargets } from '../domains/fleet.js';
@@ -1183,7 +1184,7 @@ export function registerDashboardCoreHostTools(host: Pick<PluginHost, 'registerH
 }
 import { registerDashboardPaneHostTools } from './panes/host-tools.js';
 import { type ThemeTokens } from '../theme/tokens.js';
-import { resolveActiveTheme } from './render/theme-resolver.js';
+import { getActiveThemeName, resolveActiveTheme } from './render/theme-resolver.js';
 import { getTheme } from '../themes/index.js';
 import type { PaneFocus, PreviewSource, WorkingDirView } from '../workspace-types.js';
 import type { DisplayMouseEvent } from '../display/types.js';
@@ -2876,6 +2877,11 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   // current value so log analysis can filter "what keys fired while
   // a turn was in flight".
   let streamingInFlight = false;
+  let noteClipboardActivity: () => void = () => {};
+  let noteClipboardBusyChange: () => void = () => {};
+  let noteClipboardPanelState: (active: boolean, reason: string) => void = () => {};
+  let dashboardAcpIsBusy: () => boolean = () => false;
+  let lastDashboardInputAt = Date.now();
   /** 지금 턴의 escGate 중단 — 외부 `/stop`(TUI-STOP-INPUT-BYPASS)이 대기열을 건너뛰어 부른다. 턴 밖이면 null. */
   let currentTurnExternalStop: (() => void) | null = null;
   const resolveTmuxStatusLabel = (): string | null => {
@@ -4049,6 +4055,8 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       // makes the "*N" suffix tick up within the same frame so the
       // user sees feedback for their own action immediately.
       // TUI-TYPING-LAG — async probe: `git status` must not block key input.
+      lastDashboardInputAt = Date.now();
+      lastGitDirtyProbeAt = lastDashboardInputAt;
       void refreshGitDirtyAsync(getSessionCwd(), { force: true })
         .then(() => { try { draw(); } catch { /* TUI torn down */ } }, () => { /* noop */ });
     });
@@ -4073,9 +4081,11 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   //      extras.
   //   3. SWD flip → dispose + re-wire (fresh repo root).
   let gitUnsub: (() => void) | null = null;
+  let lastGitDirtyProbeAt = Date.now();
   const wireGitForSwd = (): void => {
     if (gitUnsub) { try { gitUnsub(); } catch {} gitUnsub = null; }
     const swd = getSessionCwd();
+    lastGitDirtyProbeAt = Date.now();
     gitUnsub = subscribeGitChanges(swd, () => {
       try { draw(); } catch { /* noop */ }
     });
@@ -4113,17 +4123,18 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   // the git snapshot (async subprocesses) and the self-ambient store scan (worker thread). A turn
   // then serves them from cache instead of rebuilding synchronously on the turn path. Both are
   // no-ops while the cached value is younger than the threshold; failures are fail-soft.
+  const currentDashboardIdleMs = (): number =>
+    dashboardIdleMs(Date.now(), lastDashboardInputAt, streamingInFlight || dashboardAcpIsBusy());
   const warmTurnPreambleCaches = (): void => {
-    try { void refreshGitSnapshotAsync(getSessionCwd(), { ifOlderThanMs: 30_000 }); } catch { /* noop */ }
-    try { void refreshSelfAmbientCache({}, { ifOlderThanMs: 25_000 }); } catch { /* noop */ }
+    const ambientCacheTtlMs = selfAmbientKeepWarmIntervalMs(currentDashboardIdleMs());
+    try { void refreshSelfAmbientCache({}, { ifOlderThanMs: ambientCacheTtlMs }); } catch { /* noop */ }
   };
-  warmTurnPreambleCaches();
-  const gitDirtyTimer: ReturnType<typeof setInterval> = setInterval(() => {
-    warmTurnPreambleCaches();
+  const probeGitDirty = (minIntervalMs: number): void => {
+    lastGitDirtyProbeAt = Date.now();
     try {
       const before = getGitStatusView(getSessionCwd());
       // TUI-TYPING-LAG — the 5s probe ran `git status` synchronously (130ms+, hundreds under load).
-      void refreshGitDirtyAsync(getSessionCwd(), { minIntervalMs: 4_000 }).then((after) => {
+      void refreshGitDirtyAsync(getSessionCwd(), { minIntervalMs }).then((after) => {
         if (
           (before.dirty?.total ?? -1) !== (after.dirty?.total ?? -1) ||
           (before.aheadBehind?.ahead ?? -1) !== (after.aheadBehind?.ahead ?? -1)
@@ -4132,6 +4143,26 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
         }
       }, () => { /* noop */ });
     } catch { /* noop */ }
+  };
+  // CLASSIC-IDLE-GIT-POLL — no git children while idle (2 min without input); the next key warms once
+  // off the input path (deferred) and polling resumes. `git-fs.idle poll-state` records each flip.
+  const gitIdlePoll = createIdleGitPoll({
+    idleMs: currentDashboardIdleMs,
+    poll: (idleMs) => {
+      try { void refreshGitSnapshotAsync(getSessionCwd(), { ifOlderThanMs: 30_000 }); } catch { /* noop */ }
+      if (Date.now() - lastGitDirtyProbeAt < gitDirtyRefreshIntervalMs(idleMs)) return;
+      probeGitDirty(gitDirtyRefreshIntervalMs(idleMs));
+    },
+    warm: () => {
+      try { void refreshGitSnapshotAsync(getSessionCwd(), { ifOlderThanMs: 30_000 }); } catch { /* noop */ }
+      probeGitDirty(0);
+    },
+  });
+  warmTurnPreambleCaches();
+  try { void refreshGitSnapshotAsync(getSessionCwd(), { ifOlderThanMs: 30_000 }); } catch { /* noop */ }
+  const gitDirtyTimer: ReturnType<typeof setInterval> = setInterval(() => {
+    warmTurnPreambleCaches();
+    gitIdlePoll.tick();
   }, 5_000);
   (gitDirtyTimer as unknown as { unref?: () => void }).unref?.();
   // The running module's installed version, not the user's working directory, is the baseline.
@@ -4546,6 +4577,8 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   };
   let pluginHost: PluginHost;
   let lastThemeLoadError = '';
+  let lastThemeResolutionName: string | null = null;
+  let lastPluginThemeAppliedDebugKey: string | null = null;
   let iulThemePreviewOverride: string | null = null;
   let lastHostChromePolicyDebugKey = '';
   const observeEssentialFrameCursor = createDashboardEssentialCursorObserver({
@@ -4560,9 +4593,26 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     const raw = iulThemePreviewOverride
       ? { ...(getUserConfig().dashboard.theme as object ?? {}), active: iulThemePreviewOverride }
       : getUserConfig().dashboard.theme;
+    const activeThemeName = getActiveThemeName(raw);
+    if (activeThemeName !== lastThemeResolutionName) {
+      lastThemeResolutionName = activeThemeName;
+      lastPluginThemeAppliedDebugKey = null;
+    }
     return resolveActiveTheme({
       raw,
-      loadPlugin: (id) => pluginHost?.loadThemeTokens(id) ?? null,
+      loadPlugin: (id) => {
+        const tokens = pluginHost?.loadThemeTokens(id) ?? null;
+        if (!tokens) lastPluginThemeAppliedDebugKey = null;
+        return tokens;
+      },
+      onPluginApplied: (event) => {
+        const key = `${event.id}:${event.tokensCount}:${event.source}`;
+        if (key === lastPluginThemeAppliedDebugKey) return;
+        try {
+          debug.log('tui.theme', 'plugin-theme-applied', event);
+          lastPluginThemeAppliedDebugKey = key;
+        } catch { /* observation is best-effort */ }
+      },
       onPluginError: (message) => {
         if (lastThemeLoadError !== message) {
           lastThemeLoadError = message;
@@ -6011,6 +6061,8 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     }
   };
   const syncCompanionPopups = (): void => {
+    // CLASSIC-IDLE-CLIPBOARD: every clipboard open/close/dock path ends here — keep it the only gate.
+    noteClipboardPanelState(companionPopupHost.isActive('clipboard'), companionPopupHost.isDocked('clipboard') ? 'panel-docked' : companionPopupHost.isOpen('clipboard') ? 'panel-open' : 'panel-close');
     const { cols, rows } = termSize();
     const workspaceHost = display.workspaceHostAPI();
     const ownerId = companionPopupHost.ownerId;
@@ -7011,6 +7063,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     };
 
     const cleanup = attachStreamingKeys(async (key) => {
+      noteClipboardActivity();
       // ── Pre-dispatch gates ────────────────────────────────────
       //
       // These run BEFORE `routeInputEventAsync` because:
@@ -7108,6 +7161,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     // ⛔ TUI-STALE-BUSY-MARKER — busy 는 «끄는 closure 를 돌려주기 직전»에 켠다. 위 준비(ESC 게이트·키 리스너)가
     //    던지면 호출자는 cleanup 을 못 받으므로, 먼저 켜 두면 아무도 못 끄는 busy 가 남는다(#37).
     streamingInFlight = true;
+    noteClipboardBusyChange();
     reportTuiTurn('busy');
     const externalStop = (): void => { stopTurnViaEscGate(escGate); };
     currentTurnExternalStop = externalStop;
@@ -7126,6 +7180,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       } finally {
         userScrolledDuringStream = false;
         streamingInFlight = false;
+        noteClipboardBusyChange();
         reportTuiTurn('idle');
         const failedTurnRaw = autowakeTurnFailureRaw;
         autowakeTurnFailureRaw = null;
@@ -7196,6 +7251,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   const dashboardAcpChat = new DashboardAcpChat({
     cwd: () => workingDir.cwd,
     log: (msg) => pushLog('debug', `  [acp] ${msg}`),
+    onBusyChange: () => noteClipboardBusyChange(),
     // Follow-up #9 — wrap the modal approver so BG records flip to
     // `waiting_for_confirmation` even when the peer (codex-acp /
     // gemini-cli) doesn't emit the `tool_call_update.status` field.
@@ -7205,6 +7261,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       globalBackgroundManager(),
     ),
   });
+  dashboardAcpIsBusy = () => dashboardAcpChat.isBusy();
   activeAcpRuntimeModel = () => dashboardAcpChat.activeRuntimeModel();
 
   // Obsidian vault browser (Phase O3). Shares the FsEntry shape and
@@ -12358,7 +12415,17 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   // ticks every ~1.5s on Darwin and stores up to 50 unique text
   // snapshots. Stopped during dashboard teardown to avoid leaking
   // intervals if the host re-enters showDashboard.
-  const clipHistory: ClipboardHistory = startClipboardHistory({});
+  // CLASSIC-IDLE-CLIPBOARD: dormant until the clipboard companion is open.
+  const clipHistory: ClipboardHistory = startClipboardHistory({
+    active: companionPopupHost.isActive('clipboard'),
+    isBusy: () => streamingInFlight || dashboardAcpChat.isBusy(),
+  });
+  noteClipboardPanelState = (active, reason) => clipHistory.setActive(active, reason);
+  noteClipboardActivity = () => {
+    lastDashboardInputAt = Date.now();
+    clipHistory.noteActivity();
+  };
+  noteClipboardBusyChange = () => clipHistory.noteBusyChange();
   process.once('beforeExit', () => { clipHistory.stop(); });
   // Re-render whenever the poller picks up a new entry — only when
   // we're actually showing the history viewer, otherwise the side-
@@ -15160,6 +15227,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       const key: import('../tui.js').Key = wdAutoInput
         ? { name: CHAT_MAIN_AUTO_ENTRY_KEY_NAME, ctrl: false, shift: false }
         : await readKey();
+      if (!wdAutoInput) { noteClipboardActivity(); gitIdlePoll.noteActivity('input'); }
       const helpModal = currentTransientTerminalModal('dashboard-help');
       if (key.name === 'escape' && helpModal) {
         helpModal.dispose();