elanous 0.2.32 → 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/control/control-status.ts

@@ -33,6 +33,13 @@ export interface ControlStatusDeps {
   log?: typeof debug.log;
 }
 
+/** The same read-only HQ source used by `control status` and HQ-fenced control serve. */
+export function readControlHqLease(): ReturnType<typeof readHqLease> {
+  return readHqLease(getElanousConfigDirOverride() !== undefined
+    ? { store: fileLeaseStore(join(effectiveInstanceRoot(), 'hq', 'lease.json')), hostPath: join(effectiveInstanceRoot(), 'hq', 'host') }
+    : {});
+}
+
 const missing = (row: ControlStatusRowName, reason: string): ControlStatusRow => ({ row, state: 'unmeasured', text: '못 쟀다', reason });
 
 function localInstallRoot(): string {
@@ -76,9 +83,7 @@ export async function collectControlStatus(deps: ControlStatusDeps = {}): Promis
   };
 
   await add('집', async () => {
-    const readLease = deps.readLease ?? (() => readHqLease(getElanousConfigDirOverride() !== undefined
-      ? { store: fileLeaseStore(join(effectiveInstanceRoot(), 'hq', 'lease.json')), hostPath: join(effectiveInstanceRoot(), 'hq', 'host') }
-      : {}));
+    const readLease = deps.readLease ?? readControlHqLease;
     const { record, ageSeconds, expired } = await readLease();
     if (!record) return missing('집', '본부 임대 기록 없음');
     return { row: '집', state: expired ? 'warn' : 'ok',

package/src/control-plane/ledger.ts

@@ -23,6 +23,7 @@ export interface PodWorkerKey { context: string; imageDigest: string; lockHash:
 type PodWorkerState = 'idle' | 'leased' | 'sanitizing' | 'quarantined';
 interface PodWorkerLeaseAttrs {
   key: PodWorkerKey;
+  podUid: string;
   state: PodWorkerState;
   generation: number;
   idleTtlMs: number;
@@ -203,20 +204,20 @@ export class ResourceLedger {
   }
 
   /** A trusted host registers a clean instance; canary verification is a separate, still unwired step. */
-  registerPodWorker(request: { workerId: string; machine: string; key: PodWorkerKey; owner: string; ttlMs: number }, now?: number): ResourceRecord {
+  registerPodWorker(request: { workerId: string; machine: string; podUid: string; key: PodWorkerKey; owner: string; ttlMs: number }, now?: number): ResourceRecord {
     return this.mutate(() => {
+    if (typeof request.podUid !== 'string' || !request.podUid.trim()) throw new ResourceLedgerError(400, 'invalid-pod-worker-uid');
     now ??= Date.now();
     const rows = this.read();
     const id = `pod-worker-lease:${request.workerId}`;
     const index = rows.findIndex(row => row.id === id);
     const previous = index < 0 ? undefined : rows[index]!;
     if (previous && previous.kind !== 'pod-worker-lease') throw new ResourceLedgerError(409, 'worker-id-conflict');
-    if (previous && previous.owner !== request.owner) throw new ResourceLedgerError(403, 'not-owner');
     // A workerId identifies one Pod instance. Expiry never proves that a leased or quarantined Pod was cleaned.
     if (previous) throw new ResourceLedgerError(409, 'worker-id-used');
     const generation = 0;
     const row: ResourceRecord = { id, kind: 'pod-worker-lease', machine: request.machine, name: request.workerId,
-      owner: request.owner, attrs: { key: request.key, state: 'idle', generation, idleTtlMs: request.ttlMs }, observedAt: now, ttlMs: request.ttlMs };
+      owner: request.owner, attrs: { key: request.key, podUid: request.podUid, state: 'idle', generation, idleTtlMs: request.ttlMs }, observedAt: now, ttlMs: request.ttlMs };
     if (index < 0) rows.push(row); else rows[index] = row;
     this.write(rows);
     return row;
@@ -229,6 +230,7 @@ export class ResourceLedger {
     const rows = this.read();
     const index = rows.findIndex(row => row.kind === 'pod-worker-lease' && (!request.machine || row.machine === request.machine)
       && Math.max(0, at - row.observedAt) < row.ttlMs && workerAttrs(row).state === 'idle'
+      && typeof workerAttrs(row).podUid === 'string' && workerAttrs(row).podUid.trim().length > 0
       && sameWorkerKey(workerAttrs(row).key, request.key));
     if (index < 0) throw new ResourceLedgerError(409, 'no-warm-worker');
     const row = rows[index]!;

package/src/control-plane/server.ts

@@ -164,15 +164,16 @@ export function startControlServer(opts: ControlServerOptions = {}): {
           if (workerRegister) {
             if (!machine) throw new ResourceLedgerError(403, 'worker-host-required');
             const body = podWorkerBody(await req.json());
-            const { workerId, machine: workerMachine, key, ttlMs } = body;
+            const { workerId, machine: workerMachine, podUid, key, ttlMs } = body;
             if (typeof workerId !== 'string' || !/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,95}$/.test(workerId)
               || typeof workerMachine !== 'string' || !workerMachine.trim()
+              || typeof podUid !== 'string' || !podUid.trim()
               || typeof ttlMs !== 'number' || !Number.isSafeInteger(ttlMs) || ttlMs <= 0 || ttlMs > MAX_POD_WORKER_TTL_MS) throw new ResourceLedgerError(400, 'invalid-pod-worker-lease');
             requireMachine(workerMachine);
             const stale = await currentWorkerPrimary();
             if (stale) return stale;
             return json(await ledger.withGuardedWorkerMutation(async () => !(await currentWorkerPrimary()),
-              () => ledger.registerPodWorker({ workerId, machine: workerMachine, key: podWorkerKey(key), ttlMs, owner })));
+              () => ledger.registerPodWorker({ workerId, machine: workerMachine, podUid, key: podWorkerKey(key), ttlMs, owner })));
           }
           if (workerAcquire) {
             if (scope !== 'member') throw new ResourceLedgerError(403, 'worker-consumer-required');
@@ -244,7 +245,8 @@ export function startControlServer(opts: ControlServerOptions = {}): {
               name: url.searchParams.get('name') || undefined,
             });
             return json({ resources: rows.map(row => row.kind === 'pod-worker-lease'
-              ? { ...row, attrs: { key: row.attrs.key, state: row.attrs.state, generation: row.attrs.generation } }
+              ? { ...row, attrs: { key: row.attrs.key, podUid: row.attrs.podUid,
+                state: row.attrs.state, generation: row.attrs.generation, idleTtlMs: row.attrs.idleTtlMs } }
               : row.kind === 'port-lease'
               ? { ...row, attrs: { ...row.attrs, leaseId: undefined } }
               : row) });

package/src/core-turn/short-question.ts

@@ -105,7 +105,11 @@ function classifyTuiChatIntentBase(text: string, ctx: ShortQuestionContext): Tui
   if (!q || ctx.hasAttachments) return coding(ctx.hasAttachments ? 'attachment' : 'empty');
   if (/(?:하니스|구현|코딩|버그|리팩터|커밋|패치|테스트|시험\s*돌|빌드|배포|\b(?:implement|coding|refactor|commit|patch|tests?|build|deploy)\b)/i.test(q)) return coding('coding');
   // Destructive or executing verbs in any form (not only «…줘») are never a quick turn.
-  if (/(?:지워|지우|삭제|제거|옮겨|옮기|돌려|실행(?!\s*중(?:인)?(?:\s|[?!.~]|$))|설치|되돌려|롤백|재시작|죽여|\b(?:delete|remove|rm|rename|move|run|install|revert|rollback|drop|kill|restart)\b)/i.test(q)) return coding('write-verb');
+  // A no-tool answer can transcribe its first line. Keep the verb for file changes and
+  // remove only this copy phrase, so another write request in the same answer is still caught.
+  const answerOnly = /도구\s*쓰지\s*말고\s*답해\s*:/i.test(q);
+  const writeVerbInput = answerOnly ? q.replace(/첫\s*줄(?:을|를)?\s*그대로\s*옮기고/g, '') : q;
+  if (/(?:지워|지우|삭제|제거|옮겨|옮기|돌려|실행(?!\s*중(?:인)?(?:\s|[?!.~]|$))|설치|되돌려|롤백|재시작|죽여|\b(?:delete|remove|rm|rename|move|run|install|revert|rollback|drop|kill|restart)\b)/i.test(writeVerbInput)) return coding('write-verb');
   // Allowlist, not denylist: every «…줘» request verb must be one a quick turn can do; anything else
   // (지워줘 · 돌려줘 · 옮겨줘 …) keeps the coding goal loop.
   for (const match of q.matchAll(/([가-힣]+?)\s*(?:줘|주세요|줄래|주라)/g)) {

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