elanous 0.2.31 → 0.2.34

package/src/task-orchestrator/surfaces/self-implement.ts

@@ -20,14 +20,16 @@
  */
 import { lstatSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import type { ReviewRework } from '../../self-dev/run-types.js';
+import type { WarmWorkerCommand } from './pod-warm-worker-protocol.js';
 import { oldDoorInternalEnv } from '../../self-dev/old-door.js';
 import { selfDevRunsDir } from '../../self-dev/run-store.js';
-import { debug } from '../../debug/log.js';
+import { debug, redactSecretText } from '../../debug/log.js';
 import { join, resolve } from 'node:path';
 import { findGitDir } from '../../git-fs/locate.js';
 import { isAbandonedClassification, type AbandonedClassificationResult } from '../../self-implement/abandoned-classification.js';
 import { createExecution, type Task, type TaskExecution } from '../types.js';
 import type { DispatchContext, DispatchResult } from '../surface-registry.js';
+import { nestedPodResult } from './pod-failure-reason.js';
 
 /** Result of one self-implement subprocess. */
 export interface SelfImplementJobDone {
@@ -92,6 +94,70 @@ export interface SelfImplementDisposition {
   reviewMustFixCount?: number;
   rework?: ReviewRework;
   mustFix?: string[];
+  /** Structured failure facts copied from the child's terminal JSON into the host ledger. */
+  childEvidence?: PodChildEvidence;
+}
+
+export interface PodChildEvidence {
+  /** Bounded, redacted diagnostics copied only from a failed child terminal result. */
+  error?: string;
+  detail?: string;
+  stderr?: string;
+  exitCode?: number;
+  classification?: string;
+  scopeEscape?: true;
+  outOfScopeEdits?: unknown;
+  abandonedClassification?: Record<string, unknown>;
+  supervisorVerdict?: unknown;
+  goalCauseObserved?: true;
+  terminationReason?: unknown;
+  accountAvailability?: Record<string, unknown>;
+}
+
+/** Preserve only named terminal facts; the full child detail may contain logs or credentials. */
+export function podChildEvidenceFromResult(o: Record<string, unknown>): PodChildEvidence | undefined {
+  const object = (value: unknown): Record<string, unknown> | undefined =>
+    value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
+  const scrub = (value: Record<string, unknown> | undefined): Record<string, unknown> | undefined => {
+    if (!value) return undefined;
+    try { return JSON.parse(redactSecretText(JSON.stringify(value))) as Record<string, unknown>; }
+    catch { return undefined; }
+  };
+  const abandoned = scrub(object(o.abandonedClassification));
+  const quota = object(o.quotaExhaustionAssessment);
+  const accountAvailability = scrub(object(quota?.accountAvailability) ?? object(abandoned?.quotaAccountAvailability));
+  const scrubValue = (value: unknown): unknown => {
+    if (value === undefined) return undefined;
+    try { return JSON.parse(redactSecretText(JSON.stringify(value))); }
+    catch { return undefined; }
+  };
+  const failedText = (value: unknown): string | undefined => {
+    if (o.ok !== false || typeof value !== 'string' || !value.trim()) return undefined;
+    return redactSecretText(value).slice(0, 4_000);
+  };
+  const failureExitCode = o.ok === false && typeof o.exitCode === 'number'
+    && Number.isInteger(o.exitCode) && o.exitCode >= 0 && o.exitCode <= 255 ? o.exitCode : undefined;
+  const outOfScopeEdits = scrubValue(o.outOfScopeEdits);
+  const scopeEscape = (Array.isArray(outOfScopeEdits) && outOfScopeEdits.length > 0)
+    || (typeof o.detail === 'string' && /^Out-of-scope edits held in the worktree(?:[.;]|$)/i.test(o.detail.trim()));
+  const classification = scopeEscape ? 'scope-escape'
+    : typeof abandoned?.classification === 'string' ? redactSecretText(abandoned.classification)
+      : typeof o.failureClassification === 'string' ? redactSecretText(o.failureClassification) : undefined;
+  const evidence: PodChildEvidence = {
+    ...(failedText(o.error) ? { error: failedText(o.error) } : {}),
+    ...(failedText(o.detail) ? { detail: failedText(o.detail) } : {}),
+    ...(failedText(o.stderr) ? { stderr: failedText(o.stderr) } : {}),
+    ...(failureExitCode !== undefined ? { exitCode: failureExitCode } : {}),
+    ...(classification ? { classification } : {}),
+    ...(scopeEscape ? { scopeEscape: true } : {}),
+    ...(outOfScopeEdits !== undefined ? { outOfScopeEdits } : {}),
+    ...(abandoned ? { abandonedClassification: abandoned } : {}),
+    ...(o.supervisorVerdict !== undefined ? { supervisorVerdict: scrubValue(o.supervisorVerdict) } : {}),
+    ...(o.goalCauseObserved === true ? { goalCauseObserved: true } : {}),
+    ...(o.terminationReason !== undefined ? { terminationReason: scrubValue(o.terminationReason) } : {}),
+    ...(accountAvailability ? { accountAvailability } : {}),
+  };
+  return Object.keys(evidence).length ? evidence : undefined;
 }
 
 /**
@@ -117,6 +183,8 @@ export interface SelfImplementJobSpawn {
     /** Distinct-per-job harness-space id → own screen/log buffer. */
     spaceId: string;
     signal?: AbortSignal;
+    /** Optional TC-owned warm-worker command. The warm request is advisory; this feature Job remains authoritative. */
+    warmWorkerCommand?: WarmWorkerCommand;
   }): {
     /** `self-impl:<spaceId>` — keyed so `elanous logs --space` / metrics
      *  can attribute without re-parsing. */
@@ -462,7 +530,18 @@ export function parseSelfImplementJson(stdout: string): SelfImplementDisposition
     const line = lines[i]!.trim();
     if (!line.startsWith('{') || !line.endsWith('}')) continue;
     try {
-      const o = JSON.parse(line) as Record<string, unknown>;
+      const row = JSON.parse(line) as Record<string, unknown>;
+      if (typeof row.kind === 'string' && row.kind !== 'self' && row.kind !== 'external') continue;
+      const childKind = row.kind === 'self' || row.kind === 'external';
+      const nestedEnvelope = childKind && Object.prototype.hasOwnProperty.call(row, 'result');
+      let o = row;
+      let nestedSuccess = false;
+      if (nestedEnvelope) {
+        const terminal = nestedPodResult(row);
+        if (!terminal || !row.result || typeof row.result !== 'object' || Array.isArray(row.result)) continue;
+        o = { ...(row.result as Record<string, unknown>), stage: terminal.stage, ok: terminal.ok };
+        nestedSuccess = terminal.ok;
+      }
       if (typeof o.stage !== 'string' && typeof o.ok !== 'boolean') continue;
       const failureClassification = failureClassificationFromJson(o);
       const rawRework = o.rework && typeof o.rework === 'object' && !Array.isArray(o.rework)
@@ -475,6 +554,7 @@ export function parseSelfImplementJson(stdout: string): SelfImplementDisposition
         // A measured trend needs two reviews, a direction change three — a contradictory pair is not an observation.
         && (rawRework.trend === 'unmeasured' ? rawRework.rounds === 1 : rawRework.rounds >= (rawRework.trend === 'oscillating' ? 3 : 2))
         ? { trend: rawRework.trend as ReviewRework['trend'], signature: rawRework.signature, rounds: rawRework.rounds } : undefined;
+      const childEvidence = nestedSuccess ? undefined : podChildEvidenceFromResult(o);
       const mapped: SelfImplementDisposition = {
         ...(typeof o.stage === 'string' ? { stage: o.stage } : {}),
         ...(typeof o.ok === 'boolean' ? { ok: o.ok } : {}),
@@ -502,6 +582,7 @@ export function parseSelfImplementJson(stdout: string): SelfImplementDisposition
         ...(typeof o.completionDisposition === 'string' && o.completionDisposition.trim()
           ? { completionDisposition: o.completionDisposition } : {}),
         ...(failureClassification ? { failureClassification } : {}),
+        ...(childEvidence ? { childEvidence } : {}),
         ...(o.providerErrors && typeof o.providerErrors === 'object' && !Array.isArray(o.providerErrors)
           && typeof (o.providerErrors as Record<string, unknown>).count === 'number'
           && Number.isFinite((o.providerErrors as Record<string, unknown>).count)

package/src/tool-runtime/truncation-store.ts

@@ -6,6 +6,10 @@ import type { ChatToolOutputConfig } from '../user-config.js';
 function defaultToolResultsRoot(): string {
   return join(effectiveInstanceRoot(), 'tool-results');
 }
+/** 넘침 파일 뿌리 — TUI 가 «넘침 파일 다시 읽기» 를 잡무로 접을 때 같은 뿌리로 판별한다(TUI-TURN-NARRATION FU-5). */
+export function toolResultsRoot(): string {
+  return defaultToolResultsRoot();
+}
 const SWEEP_INTERVAL_MS = 60 * 60 * 1000;
 const lastSweepAt = new Map<string, number>();
 

package/src/tui/chat/execution-badge.ts

@@ -12,7 +12,7 @@
 // completion-line presentation. dashboard/execution-badge.ts is now a
 // re-export shim for backward compat until callers migrate.
 
-import { currentRouteDecision } from '../../llm/route-decision.js';
+import { currentRouteDecision, routeFallbackLabel } from '../../llm/route-decision.js';
 import { getUserConfig } from '../../user-config.js';
 import { effectiveReasoningLevel, modelSupportsReasoning } from '../../llm.js';
 import { executionBadge } from '../../telegram-exec-footer.js';
@@ -24,6 +24,10 @@ import { executionBadge } from '../../telegram-exec-footer.js';
  *  execution footer uses, so both surfaces report the same truth. */
 export function resolveDashboardExecutionBadge(): string | undefined {
   const cfg = getUserConfig();
+  // 폴백(TUI-MODEL-BADGE-ACTUAL · 10-16) — 턴이 고른 모델과 «실제로 응답한» 모델이 다르면 «sol → grok».
+  //   생각 깊이는 결정 쪽 값이라 넘어간 공급자엔 맞지 않는다 → 폴백 배지엔 안 붙인다.
+  const fallback = routeFallbackLabel('dashboard');
+  if (fallback) return executionBadge({ model: fallback });
   const decision = currentRouteDecision('dashboard');
   const model = decision?.model || cfg.llm.model;
   if (!model) return undefined;

package/src/tui/input-lag-probe.ts

@@ -0,0 +1,230 @@
+// TUI-TYPING-LAG-OBS — 타이핑 지연을 «재는» 관측(#28063 이 «실물 불가» 로 착지한 빈칸).
+//
+// 계약(UX SCENARIO-MOCK-RIG 와 합의 · ⛔ 이름·칸을 바꾸지 않는다):
+//   debug.log('tui.input-lag', 'measured', {
+//     phase: 'keystroke' | 'turn-start', keyToPaintMs?, loopDelayMs: { p99, max }, turnId?, busy, sampled })
+//
+// - keystroke: stdin 키 수신 → 그 뒤 첫 화면 칠(render · typeahead echo) 의 write 호출까지.
+//   이벤트 루프가 막힌 동안 온 키는 막힘이 풀린 뒤에야 'data' 로 배달되므로, 배달 시각만 보면
+//   막힌 시간이 빠진다. ⇒ 20ms 심장박동으로 «배달 전 기다린 시간» 을 추정해 더한다(상한 추정 ·
+//   오차 ≤ 심장박동 간격). 기본 표본 = 10키 중 1(`sampled: 0.1`) · 50ms 이상은 항상 남긴다.
+// - turn-start: turn-preamble 을 감싼 창(시작 → 끝 + 박동 두 번)의 루프 지연(`sampled: 1`) · busy 는 창 끝 값.
+// - loopDelayMs: 그 창의 루프 지연 p99/max(ms) — 같은 20ms 심장박동의 드리프트 표본(최근 ~20초 고리).
+//   ⚠️ perf_hooks.monitorEventLoopDelay 를 «안» 쓴다: Bun 1.4.2 에서 동작은 하지만 인스턴스들이
+//   «히스토그램 하나를 공유» 하고 한 인스턴스의 disable() 이 전부를 멈춘다(node-c 실측 · 라이브에서
+//   turn-start 창을 닫은 뒤 keystroke 창이 {p99:0,max:0} 만 찍었다). 창이 겹치는 이 프로브엔 못 쓴다.
+//
+// 키 경로 비용: 키 청크마다 시각 호출 1회 ⊕ 비교 몇 개 · 할당 0(대기 중 키는 숫자 둘로 쥔다).
+// 화면 칠마다: 대기 키가 없으면 비교 1회. 로그 객체는 «남길 때만» 만든다.
+// 프로브가 등록되지 않으면(대시보드 밖 · 시험) 모든 훅은 null 검사 한 번으로 끝난다.
+
+export const INPUT_LAG_CATEGORY = 'tui.input-lag';
+export const INPUT_LAG_EVENT = 'measured';
+/** 표본 비율의 분모 — 측정한 키 N개 중 1개를 남긴다. */
+export const INPUT_LAG_SAMPLE_EVERY = 10;
+/** 이 ms 이상 걸린 키는 표본과 무관하게 항상 남긴다. */
+export const INPUT_LAG_ALWAYS_MS = 50;
+const HEARTBEAT_MS = 20;
+/** 루프가 «안 막힌 채» 이만큼 지나도 칠이 없으면 그 키는 칠을 안 낳은 키(무시 키 등)로 보고 놓는다 —
+ *  안 그러면 한참 뒤 다른 칠이 그 키에 붙어 수 분짜리 가짜 지연이 찍힌다(라이브 실측 150,963ms). */
+export const INPUT_LAG_ABANDON_MS = 1000;
+/** 루프 지연 표본 고리 크기 — 20ms 박동이면 ~20초. */
+const LOOP_RING = 1024;
+
+export interface LoopDelayMs { p99: number; max: number }
+
+export interface InputLagMeasured {
+  phase: 'keystroke' | 'turn-start';
+  keyToPaintMs?: number;
+  loopDelayMs: LoopDelayMs;
+  turnId?: string;
+  busy: boolean;
+  sampled: number;
+}
+
+interface TimerLike { unref?: () => void }
+
+export interface InputLagProbeOptions {
+  log: (category: string, event: string, data: InputLagMeasured) => void;
+  isBusy: () => boolean;
+  now?: () => number;
+  sampleEvery?: number;
+  alwaysMs?: number;
+  heartbeatMs?: number;
+  setIntervalFn?: (fn: () => void, ms: number) => TimerLike;
+  clearIntervalFn?: (timer: TimerLike) => void;
+  setTimeoutFn?: (fn: () => void, ms: number) => TimerLike;
+}
+
+export interface InputLagProbe {
+  /** 키 `count` 개가 한 번에 도착했다(한 stdin 청크가 여러 키를 낳을 수 있다). */
+  noteKey(count?: number): void;
+  notePaint(): void;
+  measureTurnStart<T>(fn: () => T, turnId?: string): T;
+  /** 같은 심장박동을 다른 관측(턴 시작 덩어리 · `dashboard/turn-start-segments.ts`)이 읽는 창 — 시계·할당 0. */
+  beats: InputLagBeatView;
+  dispose(): void;
+}
+
+export interface InputLagBeatView {
+  heartbeatMs: number;
+  /** 마지막 박동 시각(같은 `now` 시계). */
+  lastBeatAt(): number;
+  /** `since` 뒤 박동들의 루프 지연 p99/max — 남길 때만 부른다. */
+  loopDelaySince(since: number): LoopDelayMs;
+}
+
+const round1 = (ms: number): number => Math.round(Math.max(0, ms) * 10) / 10;
+
+/** 드리프트 표본 고리에서 `since` «뒤»(초과) 표본의 p99/max. 남길 때만 부른다(그때만 할당). */
+function readLoopDelay(drift: Float64Array, at: Float64Array, count: number, head: number, since: number): LoopDelayMs {
+  const picked: number[] = [];
+  for (let i = 0; i < count; i++) {
+    const idx = (head - 1 - i + LOOP_RING) % LOOP_RING;
+    if (at[idx]! <= since) break;
+    picked.push(drift[idx]!);
+  }
+  if (picked.length === 0) return { p99: 0, max: 0 };
+  picked.sort((x, y) => x - y);
+  return {
+    // 최근순위(nearest-rank) p99 — 짧은 창([0, 300])에서도 큰 막힘을 내림으로 잃지 않는다.
+    p99: round1(picked[Math.max(0, Math.ceil(picked.length * 0.99) - 1)]!),
+    max: round1(picked[picked.length - 1]!),
+  };
+}
+
+export function createInputLagProbe(opts: InputLagProbeOptions): InputLagProbe {
+  const now = opts.now ?? (() => performance.now());
+  const sampleEvery = Math.max(1, Math.floor(opts.sampleEvery ?? INPUT_LAG_SAMPLE_EVERY));
+  const alwaysMs = opts.alwaysMs ?? INPUT_LAG_ALWAYS_MS;
+  const heartbeatMs = opts.heartbeatMs ?? HEARTBEAT_MS;
+  const setIntervalFn = opts.setIntervalFn ?? ((fn, ms) => setInterval(fn, ms));
+  const clearIntervalFn = opts.clearIntervalFn ?? ((t) => clearInterval(t as ReturnType<typeof setInterval>));
+  const setTimeoutFn = opts.setTimeoutFn ?? ((fn, ms) => setTimeout(fn, ms));
+
+  // 칠을 기다리는 첫 키(뒤따르는 키는 같은 칠을 기다리므로 첫 키가 최악값이다).
+  let pendingAt = -1;
+  let pendingWaitMs = 0;
+  // 심장박동 — 마지막 박동 시각 ⊕ 방금 끝난 막힘(같은 루프 회전에서 키가 배달되면 그만큼 기다렸다).
+  let lastBeatAt = now();
+  let stallMs = 0;
+  let stallEndedAt = -Infinity;
+  const ringDrift = new Float64Array(LOOP_RING);
+  const ringAt = new Float64Array(LOOP_RING);
+  let ringHead = 0;
+  let ringCount = 0;
+  let keyWindowStart = lastBeatAt;
+  const loopDelaySince = (since: number): LoopDelayMs => readLoopDelay(ringDrift, ringAt, ringCount, ringHead, since);
+  const beat = setIntervalFn(() => {
+    const t = now();
+    const drift = t - lastBeatAt - heartbeatMs;
+    ringDrift[ringHead] = Math.max(0, drift);
+    ringAt[ringHead] = t;
+    ringHead = (ringHead + 1) % LOOP_RING;
+    if (ringCount < LOOP_RING) ringCount += 1;
+    if (drift > heartbeatMs) { stallMs = drift; stallEndedAt = t; }
+    lastBeatAt = t;
+    if (pendingAt >= 0 && t - Math.max(pendingAt, stallEndedAt) > INPUT_LAG_ABANDON_MS) pendingAt = -1;
+  }, heartbeatMs);
+  beat.unref?.();
+
+  // 표본 줄 사이에 들어온 실제 키 수(측정 횟수가 아니다) — 표본 줄을 남기면 sampleEvery 의 나머지를 이월한다.
+  let keysSinceLine = 0;
+  let disposed = false;
+
+  return {
+    noteKey(count = 1): void {
+      if (disposed) return;
+      keysSinceLine += count;
+      if (pendingAt >= 0) return;
+      const t = now();
+      // 박동이 밀려 있으면 루프가 아직 막혀 있었다. 마지막 박동이 막힘을 끝낸 박동이면(그 뒤 평상 박동이
+      // 아직 없으면) 막힘 동안 쌓인 키가 이제 배달되는 중이다 — 막힘 ⊕ 그 뒤 흐른 시간(상한 추정).
+      const overdue = t - lastBeatAt - heartbeatMs;
+      const justStalled = stallEndedAt === lastBeatAt ? stallMs + (t - stallEndedAt) : 0;
+      pendingAt = t;
+      pendingWaitMs = Math.max(0, overdue, justStalled);
+    },
+    notePaint(): void {
+      if (pendingAt < 0) return;
+      const keyToPaintMs = now() - pendingAt + pendingWaitMs;
+      pendingAt = -1;
+      // 50ms↑ 강제 줄은 표본을 소비하지 않는다(표본이 때가 됐어도 다음 칠로 넘긴다) ·
+      // 표본 줄은 넘친 키를 다음 표본으로 이월한다.
+      const forced = keyToPaintMs >= alwaysMs;
+      if (!forced) {
+        if (keysSinceLine < sampleEvery) return;
+        keysSinceLine %= sampleEvery;
+      }
+      const t = now();
+      const loopDelayMs = loopDelaySince(keyWindowStart);
+      keyWindowStart = t;
+      opts.log(INPUT_LAG_CATEGORY, INPUT_LAG_EVENT, {
+        phase: 'keystroke',
+        keyToPaintMs: round1(keyToPaintMs),
+        loopDelayMs,
+        busy: opts.isBusy(),
+        sampled: 1 / sampleEvery,
+      });
+    },
+    measureTurnStart<T>(fn: () => T, turnId?: string): T {
+      if (disposed) return fn();
+      const windowStart = now();
+      const finish = (): void => {
+        // busy 는 창이 닫히는 «지금» 잡는다 — 박동 두 번 뒤 읽으면 그 사이 바뀐 상태가 창에 붙는다.
+        const busy = opts.isBusy();
+        // 동기 막힘은 루프가 풀린 «뒤» 첫 박동에 찍힌다 — 박동 두 번만큼 기다렸다 읽는다.
+        const timer = setTimeoutFn(() => {
+          if (disposed) return;
+          const loopDelayMs = loopDelaySince(windowStart);
+          opts.log(INPUT_LAG_CATEGORY, INPUT_LAG_EVENT, {
+            phase: 'turn-start',
+            loopDelayMs,
+            ...(turnId !== undefined ? { turnId } : {}),
+            busy,
+            sampled: 1,
+          });
+        }, heartbeatMs * 2);
+        timer.unref?.();
+      };
+      try {
+        return fn();
+      } finally {
+        finish();
+      }
+    },
+    beats: {
+      heartbeatMs,
+      lastBeatAt: () => lastBeatAt,
+      loopDelaySince,
+    },
+    dispose(): void {
+      if (disposed) return;
+      disposed = true;
+      pendingAt = -1;
+      clearIntervalFn(beat);
+    },
+  };
+}
+
+// ── 등록 자리 — 대시보드가 하나 등록하고, 저수준 훅(tui.ts · chat · turn-preamble)은 부르기만 한다. ──
+let activeProbe: InputLagProbe | null = null;
+
+export function setInputLagProbe(probe: InputLagProbe | null): void {
+  activeProbe = probe;
+}
+
+/** stdin(또는 주입) 키 `count` 개 수신 — 키 경로 훅. 등록이 없으면 null 검사 한 번. */
+export function noteInputLagKey(count = 1): void {
+  activeProbe?.noteKey(count);
+}
+
+/** 화면 칠(write 호출) 직후 — 칠 경로 훅. */
+export function noteInputLagPaint(): void {
+  activeProbe?.notePaint();
+}
+
+/** turn-preamble 창을 잰다. 등록이 없으면 fn 만 부른다. */
+export function measureInputLagTurnStart<T>(fn: () => T, turnId?: string): T {
+  return activeProbe ? activeProbe.measureTurnStart(fn, turnId) : fn();
+}

package/src/tui-client/dashboard-session.ts

@@ -130,6 +130,9 @@ export interface DashboardSendRequest {
    *  more per turn, provider-dependent). Shape matches
    *  `StreamWithToolsHandlers.onUsage` modulo the correlation id. */
   onUsage?(usage: DashboardSessionUsage): void;
+  /** TUI-TURN-NARRATION — `agent_thought_chunk` ⊕ `_meta.reasoning: true`(추론 요약 문단).
+   *  전에는 usage 봉투가 아니면 버려서 화면에 0줄이었다(결함 #87). */
+  onThought?(text: string): void;
 }
 
 export interface DashboardSendResult {
@@ -550,6 +553,7 @@ function buildSendInterceptor(req: DashboardSendRequest): SessionUpdateIntercept
         rawInput?: unknown;
         rawOutput?: unknown;
         status?: string;
+        _meta?: { reasoning?: unknown };
       };
     };
     const inner = n.update;
@@ -582,8 +586,13 @@ function buildSendInterceptor(req: DashboardSendRequest): SessionUpdateIntercept
         return;
       }
       case 'agent_thought_chunk': {
-        if (!req.onUsage || inner.content?.type !== 'text') return;
+        if (inner.content?.type !== 'text') return;
         const text = inner.content.text ?? '';
+        if (inner._meta?.reasoning === true) {
+          req.onThought?.(text);
+          return;
+        }
+        if (!req.onUsage) return;
         const env = parseElanousUiEnvelope(text);
         if (!env || env.method !== 'usage') return;
         const { id: _id, ...rest } = env.payload as unknown as ElanousUiUsagePayload;

package/src/tui.ts

@@ -5,6 +5,7 @@
 import chalk from 'chalk';
 import { StringDecoder } from 'node:string_decoder';
 import { perf } from './perf-counters.js';
+import { noteInputLagKey, noteInputLagPaint } from './tui/input-lag-probe.js';
 import { debug } from './debug/log.js';
 
 // ── ANSI escape sequences ──
@@ -911,6 +912,7 @@ export function readKey(source: KeyTraceSource = 'main'): Promise<Key> {
       // split across chunk boundaries need a pending buffer that belongs
       // to this stream alone.
       const keys = _stdinParser.push(data);
+      if (keys.length > 0) noteInputLagKey(keys.length);
 
       // 2026-04-30 — also drain `_keyQueue` here so an `injectKey`
       // call that happened while `readKey` was already awaiting on
@@ -963,6 +965,7 @@ export function readKey(source: KeyTraceSource = 'main'): Promise<Key> {
  *  §8.6 — "(A) auto-Enter via injectKey" approach. */
 export function injectKey(key: Key): boolean {
   if (!_raw) return false;
+  noteInputLagKey();
   _keyQueue.push(key);
   _injectedKeys.add(key);
   // Wake any in-flight readKey awaiting on stdin by emitting an empty
@@ -1109,6 +1112,7 @@ export function render(lines: string[], opts: RenderOptions = {}): void {
   }
   perf.recordStdoutWrite(buf.length, true);
   perf.markDrawEnd();
+  noteInputLagPaint();
 
   _lastFrameLines = lines.slice(0, lineCount);
   _lastFrameRows = rows;

package/src/user-config/coercion.ts

@@ -0,0 +1,36 @@
+export function clampNum(v: unknown, fallback: number, min: number, max: number): number {
+  if (typeof v !== 'number' || !Number.isFinite(v)) return fallback;
+  if (v < min) return min;
+  if (v > max) return max;
+  return v;
+}
+
+export function positiveIntOr(v: unknown, fallback: number): number {
+  return typeof v === 'number' && Number.isSafeInteger(v) && v > 0 ? v : fallback;
+}
+
+export function str(v: unknown): string | undefined {
+  return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+
+export function strArray(v: unknown, fallback: string[]): string[] {
+  if (!Array.isArray(v)) return fallback;
+  const out = v.filter((x): x is string => typeof x === 'string' && x.length > 0);
+  return out.length > 0 ? out : fallback;
+}
+
+export function stringRecord(v: unknown): Record<string, string> {
+  if (!v || typeof v !== 'object' || Array.isArray(v)) return {};
+  const out: Record<string, string> = {};
+  for (const [k, val] of Object.entries(v as Record<string, unknown>)) {
+    if (typeof k === 'string' && k.length > 0 && typeof val === 'string' && val.length > 0) {
+      out[k] = val;
+    }
+  }
+  return out;
+}
+
+export function numArray(v: unknown, fallback: number[]): number[] {
+  if (!Array.isArray(v)) return fallback;
+  return v.filter((x): x is number => typeof x === 'number' && Number.isFinite(x));
+}

package/src/user-config.ts

@@ -64,6 +64,8 @@ import {
 import { lookupLlmTierSpec } from './model-tier/llm-tier-map.js';
 import { BEDROCK_DEFAULT_MODEL } from './llm/bedrock.js';
 import { userConfigPath as nexusUserConfigPath } from './nexus/config/paths.js';
+import { getElanousConfigDirOverride } from './elanous-config-dir.js';
+import { getTestStateRoot } from './nexus/paths.js';
 import { type StreamingMode, isStreamingMode } from './session/streaming/stream-compositor.js';
 import type { DevRequestRoutingConfig } from './skills/dev-request-router.js';
 import type { UrlRoutingConfig } from './skills/url-router.js';
@@ -72,6 +74,7 @@ import { withFileLockSync } from './storage/file-lock.js';
 import { debug } from './debug/log.js';
 import { setConfigTimeZoneSource } from './time/format.js';
 import { parseGeminiServerTools } from './user-config/gemini-server-tools.js';
+import { clampNum, numArray, positiveIntOr, str, strArray, stringRecord } from './user-config/coercion.js';
 import type { FoldMode } from './log-entry.js';
 import {
   CLAUDE_PACKAGE_MISSING,
@@ -3892,7 +3895,7 @@ export interface UserConfig {
   guardian?: { mode?: 'shadow' | 'live'; /** Orphan CLI GC on the guardian tick: off = no ps collection, shadow (default) = evidence only, on = evidence then SIGTERM. */ orphanGc?: 'off' | 'shadow' | 'on' };
   /** Task-agent live move allow-list (`src/task-agent/live-moves.ts` validates its vocabulary).
    *  Absent = env ELANOUS_TASK_AGENT_LIVE_MOVES, else none (pure shadow). */
-  taskAgent?: { liveMoves?: string[]; /** TA-REJUDGE-PERIODIC — steward tick runs `tasks rejudge --all` every N minutes (absent/0 = off). */ rejudgeEveryMinutes?: number; /** 1-minute load average above which that tick is skipped (default 60). */ rejudgeMaxLoad?: number; /** TA-REPAIR-TICK-CAP — new repair launches per `tasks rejudge --all` (default 3, 0 = none). */ repairMaxPerTick?: number; /** TA-LAND-AFTER-REVIEW — opt-in external queue adapter, never a direct merge command. */ landQueue?: { command: string; remote: string }; parentHost?: { host?: string; cwd?: string; elanous?: string; configDir?: string; podPool?: string; approvalCapacity?: number } | Array<{ host?: string; cwd?: string; elanous?: string; configDir?: string; podPool?: string; approvalCapacity?: number }> };
+  taskAgent?: { liveMoves?: string[]; /** TA-REJUDGE-PERIODIC — steward tick runs `tasks rejudge --all` every N minutes (absent/0 = off). */ rejudgeEveryMinutes?: number; /** 1-minute load average above which that tick is skipped (default 60). */ rejudgeMaxLoad?: number; /** TA-REPAIR-TICK-CAP — new repair launches per `tasks rejudge --all` (default 3, 0 = none). */ repairMaxPerTick?: number; /** Old cards are skipped by periodic rejudge after this many hours (default 72). */ rejudgeMaxAgeHours?: number; /** TA-LAND-AFTER-REVIEW — opt-in external queue adapter, never a direct merge command. */ landQueue?: { command: string; remote: string }; parentHost?: { host?: string; cwd?: string; elanous?: string; configDir?: string; podPool?: string; approvalCapacity?: number } | Array<{ host?: string; cwd?: string; elanous?: string; configDir?: string; podPool?: string; approvalCapacity?: number }> };
   events?: EventsConfig;
   /** GATE-REMOTE — see GateRemoteConfig. Absent = defaults (auto on · node-b · load 20 · cap 2). */
   gateRemote?: GateRemoteConfig;
@@ -4204,7 +4207,7 @@ function parseTaskAgentConfig(raw: unknown): UserConfig['taskAgent'] {
   }
   const parentHost = parseTaskAgentParentHost((raw as Record<string, unknown>).parentHost);
   // TA-REJUDGE-PERIODIC — 음이 아닌 유한수만 산다(0 = 끔). 그 밖은 경고하고 버린다(= 끔 · 기본 부하 상한).
-  const rejudge: { rejudgeEveryMinutes?: number; rejudgeMaxLoad?: number; repairMaxPerTick?: number } = {};
+  const rejudge: { rejudgeEveryMinutes?: number; rejudgeMaxLoad?: number; repairMaxPerTick?: number; rejudgeMaxAgeHours?: number } = {};
   for (const key of ['rejudgeEveryMinutes', 'rejudgeMaxLoad'] as const) {
     const value = (raw as Record<string, unknown>)[key];
     if (value === undefined) continue;
@@ -4216,6 +4219,12 @@ function parseTaskAgentConfig(raw: unknown): UserConfig['taskAgent'] {
     if (Number.isSafeInteger(repairMaxPerTick) && (repairMaxPerTick as number) >= 0) rejudge.repairMaxPerTick = repairMaxPerTick as number;
     else warnUserConfigDrop('taskAgent.repairMaxPerTick', `음이 아닌 정수가 아니다(${JSON.stringify(repairMaxPerTick)}) — 기본 3`);
   }
+  const rejudgeMaxAgeHours = (raw as Record<string, unknown>).rejudgeMaxAgeHours;
+  if (rejudgeMaxAgeHours !== undefined) {
+    if (typeof rejudgeMaxAgeHours === 'number' && Number.isFinite(rejudgeMaxAgeHours) && rejudgeMaxAgeHours > 0)
+      rejudge.rejudgeMaxAgeHours = rejudgeMaxAgeHours;
+    else warnUserConfigDrop('taskAgent.rejudgeMaxAgeHours', `양의 유한수가 아니다(${JSON.stringify(rejudgeMaxAgeHours)}) — 기본 72`);
+  }
   const queueRaw = (raw as Record<string, unknown>).landQueue;
   let landQueue: { command: string; remote: string } | undefined;
   if (queueRaw !== undefined) {
@@ -4541,6 +4550,13 @@ function emitXdgDeprecationWarningOnce(xdgPath: string): void {
 }
 
 export function userConfigPath(): string {
+  // An explicit CLI override or an isolated root selected by --test or a
+  // parent stamp must not be shadowed by legacy XDG from a parent shell.
+  // All state roots, including bun test's isolation root, outrank legacy XDG.
+  // XDG-only callers have no selected state root (covered by a spawned CLI).
+  if (getElanousConfigDirOverride() !== undefined || process.env.ELANOUS_STATE_DIR?.trim() || getTestStateRoot() !== undefined) {
+    return nexusUserConfigPath();
+  }
   const xdg = process.env.XDG_CONFIG_HOME?.trim();
   if (xdg) {
     const xdgPath = join(xdg, 'elanous', 'config.json');
@@ -6994,45 +7010,6 @@ export function markOnboardingComplete(cfg: UserConfig): UserConfig {
 
 export function currentOnboardingVersion(): number { return ONBOARDING_VERSION; }
 
-// ── Coercion helpers ─────────────────────────────────────────────────
-
-function clampNum(v: unknown, fallback: number, min: number, max: number): number {
-  if (typeof v !== 'number' || !Number.isFinite(v)) return fallback;
-  if (v < min) return min;
-  if (v > max) return max;
-  return v;
-}
-
-function positiveIntOr(v: unknown, fallback: number): number {
-  return typeof v === 'number' && Number.isSafeInteger(v) && v > 0 ? v : fallback;
-}
-
-function str(v: unknown): string | undefined {
-  return typeof v === 'string' && v.length > 0 ? v : undefined;
-}
-
-function strArray(v: unknown, fallback: string[]): string[] {
-  if (!Array.isArray(v)) return fallback;
-  const out = v.filter((x): x is string => typeof x === 'string' && x.length > 0);
-  return out.length > 0 ? out : fallback;
-}
-
-function stringRecord(v: unknown): Record<string, string> {
-  if (!v || typeof v !== 'object' || Array.isArray(v)) return {};
-  const out: Record<string, string> = {};
-  for (const [k, val] of Object.entries(v as Record<string, unknown>)) {
-    if (typeof k === 'string' && k.length > 0 && typeof val === 'string' && val.length > 0) {
-      out[k] = val;
-    }
-  }
-  return out;
-}
-
-function numArray(v: unknown, fallback: number[]): number[] {
-  if (!Array.isArray(v)) return fallback;
-  return v.filter((x): x is number => typeof x === 'number' && Number.isFinite(x));
-}
-
 function normalizeProvider(v: unknown): LLMProviderName {
   const allowed = CONFIG_LLM_PROVIDER_NAMES;
   if (typeof v === 'string' && (allowed as readonly string[]).includes(v)) {