elanous 0.2.35 → 0.2.36

package/src/chat/turn-typeahead.ts

@@ -8,6 +8,8 @@
 // elanous: 스트리밍 키 사다리에서 printable/backspace/enter 를 이 버퍼로 보존
 // (에코는 호출측이 composer zone 에 직접 페인트), 턴 종료 시 FIFO로 넘긴다.
 
+import { pasteFoldToken, shouldFoldPaste } from './paste-fold.js';
+
 export interface TurnTypeaheadState {
   /** 아직 Enter 하지 않은 현재 작성 중 입력. */
   buffer: string;
@@ -23,6 +25,32 @@ export interface TurnTypeaheadState {
   steerPriority?: boolean;
   /** 이번 턴에 도구 경계로 들어간 수 — 큐가 비었을 때 «✓ 넣음» 줄로 보인다. 턴이 끝나면 지운다. */
   injectedCount?: number;
+  /**
+   * 턴 중 긴 붙여넣기 — 버퍼엔 `[붙여넣음 #k · N줄 · M자]` 토큰, 원문은 여기(TUI-PASTE-WHILE-STREAMING · 10-22).
+   * 제출·넘김 때 토큰을 원문으로 되돌린다. 짝이 없으면 칸을 두지 않는다.
+   */
+  pastes?: Array<[token: string, raw: string]>;
+  /** 토큰 번호 — 한 버퍼 안에서 겹치지 않게. */
+  pasteSeq?: number;
+}
+
+/** 버퍼 속 붙여넣기 토큰을 원문으로 되돌린다(한 번에 훑는다). 순수. */
+export function expandTurnTypeaheadPastes(text: string, pastes: TurnTypeaheadState['pastes']): { text: string; used: number } {
+  const held = (pastes ?? []).filter(([token]) => text.includes(token));
+  if (held.length === 0) return { text, used: 0 };
+  const map = new Map(held);
+  const re = new RegExp(held.map(([t]) => t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|'), 'g');
+  return { text: text.replace(re, (m) => map.get(m) ?? m), used: held.length };
+}
+
+/** 버퍼(와 남길 글)에 더는 없는 붙여넣기 짝을 놓는다. 비면 칸을 뗀다. 순수. */
+function prunePastes(state: TurnTypeaheadState): TurnTypeaheadState {
+  if (!state.pastes) return state;
+  const live = state.pastes.filter(([token]) => state.buffer.includes(token));
+  if (live.length === state.pastes.length) return state;
+  if (live.length > 0) return { ...state, pastes: live };
+  const { pastes: _p, pasteSeq: _s, ...rest } = state;
+  return rest;
 }
 
 /** 큐 길이에 맞춘 id 짝(모자라면 null 로 채운다). 순수. */
@@ -95,6 +123,8 @@ export type TurnTypeaheadKeyResult = {
   releasedPendingIds?: string[];
   /** 빈 입력에서 Enter(대기 항목이 있을 때) = «지금 밀어 넣기» 요청. 판정·실행은 호출측의 책임이다. */
   pushNowRequested?: boolean;
+  /** 붙여넣기를 버퍼에 받았다 — 관측(`tui.paste`)은 호출측이 남긴다. */
+  pasted?: { folded: boolean; lines: number; chars: number };
 };
 
 /** 등록소 소유의 관측용 표시 조회. 이름·문법·실행 정책은 이 순수 판정기에 두지 않는다. */
@@ -123,17 +153,41 @@ export function applyTurnTypeaheadKey(
   state: TurnTypeaheadState,
   // ⭐ `shift`·`meta` 도 선언한다 — 상류 대시보드가 실제로 싣는 필드다. 구조적 타이핑이라
   //    선언이 없어도 런타임엔 들어오므로, 빠뜨리면 정확한 조합 판정을 타입으로 못 쓴다.
-  key: { name: string; ctrl?: boolean; alt?: boolean; shift?: boolean; meta?: boolean; mouse?: unknown; kind?: string },
+  key: { name: string; ctrl?: boolean; alt?: boolean; shift?: boolean; meta?: boolean; mouse?: unknown; kind?: string; paste?: string },
   isImmediateSubmission?: TurnTypeaheadImmediateSubmissionLookup,
 ): TurnTypeaheadKeyResult {
   if (key.mouse) return { state, consumed: false, changed: false };
   if (key.kind && key.kind !== 'press') return { state, consumed: false, changed: false };
 
+  // ⭐ 턴 중 붙여넣기 — 종전엔 소유하지 않아 스트리밍 사다리에서 조용히 버려졌다(10-22 설치본 99edcfa 재현).
+  //    짧은 글은 버퍼에 그대로 · 긴 글은 자리표시 토큰(원문은 `pastes`) · 제출하면 원문 전부가 FIFO 로 간다.
+  if (key.name === 'paste') {
+    // 원문(끝 줄바꿈 포함)은 그대로 쥐고 제출한다 — 줄 수·글자 수 표시만 끝 줄바꿈 하나를 빼고 센다(r1 must-fix · paste-fold 와 같은 규칙).
+    const raw = typeof key.paste === 'string' ? key.paste.replace(/\r\n?/g, '\n') : '';
+    const shown = raw.replace(/\n$/, '');
+    if (!raw) return { state, consumed: true, changed: false };
+    const lines = shown.split('\n').length;
+    if (!shouldFoldPaste(shown)) {
+      return { state: { ...state, buffer: state.buffer + raw }, consumed: true, changed: true, pasted: { folded: false, lines, chars: shown.length } };
+    }
+    const seq = (state.pasteSeq ?? 0) + 1;
+    const token = pasteFoldToken(seq, shown);
+    return {
+      state: { ...state, buffer: state.buffer + token, pastes: [...(state.pastes ?? []), [token, raw]], pasteSeq: seq },
+      consumed: true,
+      changed: true,
+      pasted: { folded: true, lines, chars: shown.length },
+    };
+  }
+
   if (key.name === 'backspace' && !key.ctrl && !key.alt) {
     if (!state.buffer) return { state, consumed: false, changed: false };
+    // 토큰 끝에서 지우면 토큰 «통째로»(반쯤 지운 토큰은 원문도 글도 아니다).
+    const tail = state.pastes?.find(([token]) => state.buffer.endsWith(token));
+    if (tail) return { state: prunePastes({ ...state, buffer: state.buffer.slice(0, -tail[0].length) }), consumed: true, changed: true };
     const cps = [...state.buffer];
     cps.pop();
-    return { state: { ...state, buffer: cps.join('') }, consumed: true, changed: true };
+    return { state: prunePastes({ ...state, buffer: cps.join('') }), consumed: true, changed: true };
   }
 
   // ⭐ 턴 중에도 Shift+Enter(⊕ Alt+Enter · Ctrl+J)는 «줄바꿈»이다 — 유휴 입력창과 같은 계약.
@@ -150,13 +204,15 @@ export function applyTurnTypeaheadKey(
       if (state.queuedSubmissions.length === 0) return { state, consumed: false, changed: false };
       return { state, consumed: true, changed: false, pushNowRequested: true };
     }
+    const submitted = expandTurnTypeaheadPastes(state.buffer, state.pastes).text;
+    const cleared = prunePastes({ ...state, buffer: '' });
     try {
       if (state.buffer.startsWith('/') && isImmediateSubmission?.(state.buffer)) {
         return {
-          state: { ...state, buffer: '' },
+          state: cleared,
           consumed: true,
           changed: true,
-          immediateSubmission: state.buffer,
+          immediateSubmission: submitted,
           submissionDisposition: 'immediate',
         };
       }
@@ -166,7 +222,7 @@ export function applyTurnTypeaheadKey(
     return {
       state: {
         buffer: '',
-        queuedSubmissions: [...state.queuedSubmissions, state.buffer],
+        queuedSubmissions: [...state.queuedSubmissions, submitted],
         ...idsField([...turnTypeaheadPendingIds(state), null]),
       },
       consumed: true,
@@ -213,7 +269,7 @@ export function restoreTurnTypeaheadSubmission(
 
 export type TurnTypeaheadHandoff =
   | { kind: 'none' }
-  | { kind: 'prefill'; text: string }
+  | { kind: 'prefill'; text: string; pastes?: Array<[token: string, raw: string]> }
   | { kind: 'submit'; text: string; pendingId?: string };
 
 /** 턴 종료 때 FIFO의 다음 항목 하나를 꺼낸다. 큐가 비면 미제출 buffer는 prefill한다. */
@@ -229,7 +285,9 @@ export function dequeueTurnTypeaheadHandoff(
     };
   }
   if (!state.buffer) return { handoff: { kind: 'none' }, state };
-  return { handoff: { kind: 'prefill', text: state.buffer }, state: createTurnTypeaheadState() };
+  // 토큰째 넘기고 짝도 같이 넘긴다 — 받는 입력창이 짝을 넘겨받아(`initialPastes`) 토큰으로 보이고 제출 때 편다.
+  const pastes = state.pastes?.filter(([token]) => state.buffer.includes(token));
+  return { handoff: { kind: 'prefill', text: state.buffer, ...(pastes?.length ? { pastes } : {}) }, state: createTurnTypeaheadState() };
 }
 
 /** 턴 범위 표시(최우선·넣음 수)를 지운다 — 다음 턴으로 넘기지 않는다. 순수. */
@@ -263,15 +321,19 @@ export function drainTurnTypeaheadOnce(
    *   composer 로 돌아간 글이 고치기 전 문면으로 모델에 들어간다(중단 복원).
    */
   releasedPendingIds: string[];
+  /** `nextInitial` 속 붙여넣기 토큰의 원문 — 받는 입력창에 `initialPastes` 로 넘긴다. */
+  initialPastes?: Array<[token: string, raw: string]>;
 } {
   state = clearTurnScopedMarks(state);
   if (opts?.interrupted && state.queuedSubmissions.length > 0) {
     const restored = [...state.queuedSubmissions, ...(state.buffer ? [state.buffer] : [])].join('\n');
+    const pastes = state.pastes?.filter(([token]) => state.buffer.includes(token));
     return {
       state: createTurnTypeaheadState(),
       nextInitial: carriedInitial ? `${carriedInitial}\n${restored}` : restored,
       injectEnter: false,
       releasedPendingIds: presentIds(turnTypeaheadPendingIds(state)),
+      ...(pastes?.length ? { initialPastes: pastes } : {}),
     };
   }
   const { handoff, state: remaining } = dequeueTurnTypeaheadHandoff(state);
@@ -283,6 +345,7 @@ export function drainTurnTypeaheadOnce(
     nextInitial: carriedInitial ? `${carriedInitial}${handoff.text}` : handoff.text,
     injectEnter: handoff.kind === 'submit',
     releasedPendingIds: handoff.kind === 'submit' && handoff.pendingId ? [handoff.pendingId] : [],
+    ...(handoff.kind === 'prefill' && handoff.pastes ? { initialPastes: handoff.pastes } : {}),
   };
 }
 

package/src/cli/config-audit.ts

@@ -110,6 +110,13 @@ export function recordConfigChange(change: ConfigChange, dbPath?: string): Confi
   }
 }
 
+/** 화면 표시용 값 — 원장과 «같은 가림 자»(비밀 경로 ⊕ 비밀 모양 값 → MASK). set/unset 되읽기 줄이 쓴다. */
+export function maskConfigDisplayValue(key: string, value: unknown): unknown {
+  if (value === undefined) return undefined;
+  if (isSecretPath(key) || isSecretValue(value)) return MASK;
+  return maskDeep(value);
+}
+
 /** 한 키의 감사 이력 — 시간 오름차순. db 파일이 없으면 빈 배열(읽기가 파일을 만들지 않는다). */
 export function readConfigHistory(key: string, dbPath?: string): ConfigChangeRow[] {
   const path = configAuditDbPath(dbPath);
@@ -121,3 +128,115 @@ export function readConfigHistory(key: string, dbPath?: string): ConfigChangeRow
     if (path !== ':memory:') db.close();
   }
 }
+
+// ── CFG-STORE2-HISTORY-REVERT · 조회·되돌림 (0.2.36 · 2026-10-22) ──
+//
+// CFG-STORE2 가 남긴 원장(위)을 «읽어서» 되돌린다. 원장은 append 전용이다 — 되돌림도 UPDATE/DELETE 없이
+// 새 행 하나(prev=지금 값 · next=복원 값 · why='config revert')로만 남는다. 그래서 이력은 «왜 그 값인가» 의
+// 사슬로 남고, 되돌린 되돌림도 다시 한 행이다.
+//
+// ⛔ 불변식
+//   • 되돌릴 «이전 값» 이 MASK 면 복원하지 않는다(원문을 원장에 남기지 않았으므로 복원할 원문이 없다) —
+//     가린 값을 값으로 되쓰는 조용한 오염 대신 «거부» 한다. 그 키는 사람이 다시 set 한다.
+//   • 출력은 언제나 가림을 거친다(maskDeep 재적용) — 화면·JSON 어디에도 비밀 원문이 없다.
+//   • 도메인 합성(아래 configDomainOf)은 «같은 원장 경로» 만 쓴다 — 특수 도메인용 별도 저장소를 만들지 않는다.
+
+/** config 도메인 — 한 키가 어느 특수 도메인의 합성 경계에 속하는가. */
+export type ConfigDomain =
+  | 'llm-policy'
+  | 'account-limits'
+  | 'fallback-chain'
+  | 'pod-pool'
+  | 'author-on-pod'
+  | 'config';
+
+/** 도메인 경계 — 구체 접두가 먼저다(넓은 'llm.' 이 좁은 'llm.limits' 를 삼키지 않게). */
+const CONFIG_DOMAIN_PREFIXES: readonly (readonly [ConfigDomain, readonly string[]])[] = [
+  ['pod-pool', ['podPool', 'harness.podPool']],
+  ['author-on-pod', ['authorOnPod', 'harness.authorOnPod']],
+  ['fallback-chain', ['llm.fallback', 'llm.fallbackChain', 'llm.rotation.fallback', 'llm.providerFallback']],
+  ['account-limits', ['llm.limits', 'llm.accountLimits', 'llm.accountLimit', 'account.']],
+  ['llm-policy', ['llm.']],
+];
+
+/** 한 키의 도메인 — 어느 특수 도메인 접두에도 안 맞으면 'config'(일반 키). */
+export function configDomainOf(key: string): ConfigDomain {
+  const normalized = key.trim();
+  for (const [domain, prefixes] of CONFIG_DOMAIN_PREFIXES) {
+    for (const prefix of prefixes) {
+      if (normalized === prefix) return domain;
+      if (prefix.endsWith('.')) {
+        if (normalized.startsWith(prefix)) return domain;
+      } else if (normalized.startsWith(`${prefix}.`)) {
+        return domain;
+      }
+    }
+  }
+  return 'config';
+}
+
+/** 원장 값 → 실제 값. null = 그 자리에 값이 없었다(undefined) · MASK = 가려서 모른다. */
+export function decodeConfigChangeValue(raw: string | null): unknown {
+  if (raw === null) return undefined;
+  if (raw === MASK) return MASK;
+  try {
+    return JSON.parse(raw) as unknown;
+  } catch {
+    return raw;
+  }
+}
+
+/** 되돌림 계획 — 원장만 보고 정한다(값을 쓰지는 않는다). */
+export type ConfigRevertPlan =
+  | { status: 'no-history' }
+  | { status: 'masked'; last: ConfigChangeRow }
+  | { status: 'already'; last: ConfigChangeRow }
+  | { status: 'restore'; last: ConfigChangeRow; value: unknown };
+
+/**
+ * 값 «전체» 에 가림 자(MASK)가 있는가 — 원시·배열·객체를 깊이 순회한다.
+ * 최상위 문자열 비교만 하면 `["***MASK***"]` 처럼 배열·객체 «속» 에 남은 가림 자를 놓친다.
+ */
+export function containsMaskValue(value: unknown): boolean {
+  if (value === MASK) return true;
+  if (Array.isArray(value)) return value.some((item) => containsMaskValue(item));
+  if (value !== null && typeof value === 'object') {
+    return Object.values(value as Record<string, unknown>).some((item) => containsMaskValue(item));
+  }
+  return false;
+}
+
+/** 그 키의 «마지막 변경» 을 되돌릴 계획. value===undefined 면 그 자리를 지우는 복원이다. */
+export function planConfigRevert(key: string, dbPath?: string): ConfigRevertPlan {
+  const last = readConfigHistory(key, dbPath).at(-1);
+  if (!last) return { status: 'no-history' };
+  // 이전 값이 «어디든» 가려져 있으면 원문 복원 불가 — 가린 값을 값으로 되쓰지 않는다.
+  // 깊이 탐색인 이유: llm.fallbackChain 같은 배열·객체 값은 원장에 ["***MASK***"] 로 남아
+  // 최상위 비교(prev === MASK)로는 안 걸리고, 그대로 되쓰면 MASK 리터럴이 실제 config 값이 된다.
+  if (containsMaskValue(decodeConfigChangeValue(last.prev))) return { status: 'masked', last };
+  if (last.prev === last.next) return { status: 'already', last };
+  return { status: 'restore', last, value: decodeConfigChangeValue(last.prev) };
+}
+
+/** 화면용 값 — 가림을 «한 번 더» 거친다(원장이 이미 가렸어도 표시 자에서 재적용). */
+function renderConfigChangeValue(raw: string | null): string {
+  if (raw === null) return '∅';
+  const decoded = decodeConfigChangeValue(raw);
+  if (decoded === MASK) return MASK;
+  return JSON.stringify(maskDeep(decoded)) ?? 'null';
+}
+
+/** `config history <key>` 출력 — 도메인 ⊕ 행 수 ⊕ (시각 · prev → next · by · why). */
+export function formatConfigHistory(key: string, rows: readonly ConfigChangeRow[]): string {
+  const header = `config history ${key} [${configDomainOf(key)}] — ${rows.length}행`;
+  const lines = rows.map((row) => {
+    const why = row.why ? ` why=${row.why}` : '';
+    return `${row.at}  ${renderConfigChangeValue(row.prev)} → ${renderConfigChangeValue(row.next)}  by=${row.by}${why}`;
+  });
+  return [header, ...lines].join('\n');
+}
+
+/** 되돌림 감사 행 — 같은 원장에 append 만 한다(why 기본값 'config revert'). */
+export function recordConfigRevert(change: ConfigChange, dbPath?: string): ConfigChangeRow {
+  return recordConfigChange({ ...change, why: change.why?.trim() ? change.why.trim() : 'config revert' }, dbPath);
+}

package/src/cli/doctor-cli.ts

@@ -47,6 +47,7 @@ import {
   isDoctorSymptom,
   isDoctorVisitSource,
   readDoctorVisits,
+  recordAutoLongRunVisit,
   recordDoctorVisit,
   type DoctorSymptom,
 } from '../self-implement/doctor-visit.js';
@@ -224,6 +225,8 @@ export interface DoctorCliDeps extends DoctorOptions, Pick<DoctorFixDeps, 'home'
   doctorVisitLedgerDir?: string;
   /** `doctor visit` 사고 선례 연결 루트(시험 seam) — 기본 = `doctorVisitIncidentRoot()` · `null` 이면 건너뛴다. */
   doctorVisitIncidentRoot?: string | null;
+  /** Deterministic clock for `doctor auto-long-run` isolated CLI tests. */
+  doctorAutoLongRunNow?: () => string;
 }
 
 const repositoryRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../..');
@@ -1350,6 +1353,25 @@ export function registerDoctorCommand(program: Command, deps: DoctorCliDeps = {}
       out.log(json ? JSON.stringify(report, null, 2) : formatHostDoctorLines(report).join('\n'));
       if (!report.ok) setExitCode(1);
     });
+  doctor.command('auto-long-run')
+    .description('Record one automatic doctor visit when a running Pod crosses 60 minutes')
+    .argument('<runId>', 'run id whose ledger receives the visit')
+    .requiredOption('--started-at <iso>', 'Pod status.startTime as an ISO timestamp')
+    .option('--json', 'structured output')
+    .action((runId: string, opts: { startedAt: string; json?: boolean }, command: Command) => {
+      const json = opts.json === true || command.parent?.opts().json === true;
+      try {
+        const result = recordAutoLongRunVisit({ runId, startedAt: opts.startedAt,
+          ...(deps.doctorAutoLongRunNow ? { now: deps.doctorAutoLongRunNow() } : {}),
+          ...(deps.doctorVisitLedgerDir !== undefined ? { dir: deps.doctorVisitLedgerDir } : {}) });
+        out.log(json ? JSON.stringify(result) : `doctor auto-long-run: runId=${runId} status=${result.status}`);
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        if (json) out.log(JSON.stringify({ status: 'rejected', reason }));
+        else err.error(reason);
+        setExitCode(1);
+      }
+    });
   doctor.command('visit')
     .description('Record a doctor visit (triage symptom) in the run ledger of that run')
     .argument('<runId>', 'run id whose ledger receives the visit')

package/src/cli/guardian-cli.ts

@@ -19,6 +19,16 @@ async function guardianPlan(): Promise<{ db: Database; plan: GuardianPlan }> {
 
 export function registerGuardianCommands(program: Command): void {
   const guardian = program.command('guardian').description('크론 수호자 그림자 관측(기존 크론·알림 무변경)');
+  guardian.command('doctor-shadow')
+    .description('기록된 admit-starved 진료 요청을 재평가 처방으로 기록(집행 없음)')
+    .requiredOption('--run <runId>', '진료 요청이 기록된 런')
+    .option('--json', 'JSON 출력')
+    .action(async (opts: { run: string; json?: boolean }) => {
+      const { recordShadowDoctorReevaluation } = await import('../self-implement/doctor-visit.js');
+      const result = recordShadowDoctorReevaluation(opts.run);
+      if (opts.json) await writeStdoutJson(JSON.stringify(result) + '\n');
+      else console.log(`doctor shadow: runId=${opts.run} status=${result.status} rx=${result.rx ?? 'none'} outcome=${result.outcome ?? 'none'} executed=0`);
+    });
   guardian.command('grok-expiry').description('현재 호스트 Grok 구독 만료 시각과 4시간 경보 상태 출력')
     .action(async () => {
       const { readGrokSubscriptionExpiry } = await import('../grok/credential.js');

package/src/cli/herdr-cli.ts

@@ -0,0 +1,34 @@
+import type { Command } from 'commander';
+
+import { CliUserError } from './cli-user-error.js';
+import { herdrPrompt, type HerdrPromptDeps } from '../pty-shell/herdr-prompt.js';
+
+/**
+ * `eln herdr prompt <대상> <문장> [--wait] [--timeout MS]` — herdr pane 의 elanous TUI 에 한 턴을 넣는다.
+ * herdr `agent prompt` 는 custom 신고 agent 를 거부하므로(herdr-prompt.ts 머리말) 같은 의미를 여기서 낸다.
+ * 출력 = 결과 JSON 한 줄(stdout) · 성공 rc0 · 실패 rc1 · 인자 오류 rc2(CliUserError).
+ */
+export function registerHerdrCommands(program: Command, deps: HerdrPromptDeps = {}): void {
+  const herdr = program.command('herdr').description('herdr 연동 — herdr pane 의 elanous TUI 를 밖에서 다룬다');
+  herdr.command('prompt <target> <text>')
+    .description('herdr pane 의 elanous TUI 에 문장 하나를 턴으로 넣는다(herdr agent prompt 의 elanous 판)')
+    .option('--wait', '제출 뒤 working 관측 → idle/done/blocked 정착까지 기다린다')
+    .option('--timeout <ms>', '호출자 timeout(제출 포함 · ms)')
+    .action(async (target: string, text: string, opts: { wait?: boolean; timeout?: string }) => {
+      let timeoutMs: number | undefined;
+      if (opts.timeout !== undefined) {
+        const n = Number(opts.timeout);
+        if (!/^\d+$/.test(opts.timeout.trim()) || !Number.isSafeInteger(n) || n <= 0) {
+          throw new CliUserError(`잘못된 --timeout: ${opts.timeout}`, '1 이상의 정수 ms');
+        }
+        timeoutMs = n;
+      }
+      // 한 번 도는 CLI 는 debug.log 를 logs.db 에 잇는 싱크가 없다 — `pty.herdr prompt` 관측이 조회되게 연다(fail-soft).
+      if (deps.log === undefined) {
+        try { await (await import('../domains/standalone-log-sink.js')).registerStandaloneLogSink('herdr'); } catch { /* 관측은 fail-soft */ }
+      }
+      const result = await herdrPrompt({ target, text, wait: opts.wait === true, ...(timeoutMs !== undefined ? { timeoutMs } : {}) }, deps);
+      console.log(JSON.stringify(result));
+      if (!result.ok) process.exitCode = 1;
+    });
+}

package/src/cli/light-entry-route.ts

@@ -1,4 +1,4 @@
-export type LightCliRoute = 'msg' | 'release' | 'tasks' | 'pty' | 'logs' | 'config';
+export type LightCliRoute = 'msg' | 'release' | 'tasks' | 'tasks-read' | 'pty' | 'logs' | 'config';
 
 const VALUE_FLAGS = new Set(['--config-dir', '--test-state-dir']);
 const HOT_ROOTS = new Set(['msg', 'pty', 'logs', 'tasks']);
@@ -67,8 +67,11 @@ export function selectLightCliRoute(args: readonly string[]): LightCliRoute | un
   if (command[0] === 'config' && command[1] === 'get' && !args.some(arg => arg === '--reveal' || arg.startsWith('--reveal='))) return 'config';
   if (command[0] === 'release' && command[1] === 'checklist'
     && (command[2] === 'status' || command[2] === 'list')) return 'release';
-  if (command[0] === 'tasks' && (command[1] === 'list' || command[1] === 'show'
-    || (command[1] === 'hand' && args.includes('--help')))) return 'tasks';
+  // CLI-ENTRY-LAZY — list·show 는 그 둘만 등록한다(tasks-read-cli.ts · board·shadow·mission 클러스터 0).
+  if (command[0] === 'tasks' && (command[1] === 'list' || command[1] === 'show')) return 'tasks-read';
+  // 하위 목록 도움말은 전체 등록부가 그린다 — 무거운 모듈은 그 등록부 안에서 실행 때만 싣는다.
+  if (command[0] === 'tasks' && ((command[1] === 'hand' && args.includes('--help'))
+    || (command.length === 1 && args.length === 2 && (args[1] === '--help' || args[1] === '-h')))) return 'tasks';
   if (command[0] === 'pty' && ['list', 'snapshot', 'text', 'state'].includes(command[1] ?? '')) return 'pty';
   if (command[0] === 'logs' && isSupportedLogsShape(args)) return 'logs';
   return undefined;

package/src/cli/log-event-names.ts

@@ -1475,6 +1475,7 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "tool-gate-evaluated",
   "tool-heartbeat",
   "tool-hydrated",
+  "tool-tier-split",
   "tool-loop.anchor-grep-blocked",
   "tool-loop.anchor-read-blocked",
   "tool-loop.broad-spot-blocked",
@@ -1578,6 +1579,7 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "unsafe-root",
   "unsupported",
   "url-route",
+  "url-route-guarded",
   "url-without-transport",
   "usage",
   "user /cancel — tool loop stop",