elanous 0.2.34 → 0.2.35

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

@@ -1,8 +1,41 @@
 export type LightCliRoute = 'msg' | 'release' | 'tasks' | 'pty' | 'logs' | 'config';
 
 const VALUE_FLAGS = new Set(['--config-dir', '--test-state-dir']);
+const HOT_ROOTS = new Set(['msg', 'pty', 'logs', 'tasks']);
+const ROOT_GLOBAL_FLAGS = new Set(['--test', '--config-dir', '--test-state-dir', '--state-dir', '--remote', '-r', '--name', '--help-all', '--version', '-V']);
+const LOG_SUBCOMMANDS = new Set([
+  'instances', 'level', 'timeline', 'durations', 'model-input', 'degenerate', 'fields', 'unclosed', 'abandoned-draft-prs',
+]);
+const LOG_VALUE_FLAGS = new Set([
+  '--level', '--surface', '--space', '--category', '--exact-category', '--axis', '--event', '--grep',
+  '--rework-recurrence-disagreement', '--since', '--until', '--before', '--session', '--limit', '--threshold', '--instance',
+]);
+const LOG_BOOLEAN_FLAGS = new Set([
+  '-h', '--help', '-f', '--follow', '--list-categories', '--list-events', '--explain', '--top-failures', '--json', '--json-data', '--test', '--all', '--include-test',
+]);
 
-/** Select only read-heavy command paths whose CLI module can stand alone. */
+function isRootGlobalFlag(arg: string): boolean {
+  return [...ROOT_GLOBAL_FLAGS].some(flag => arg === flag || arg.startsWith(`${flag}=`))
+    || (arg.startsWith('-') && !arg.startsWith('--') && (arg.startsWith('-r') && arg.length > 2 || arg.slice(1).includes('V')));
+}
+
+function isSupportedLogsShape(args: readonly string[]): boolean {
+  for (let index = 1; index < args.length; index += 1) {
+    const token = args[index]!;
+    if (token.startsWith('-')) {
+      const equals = token.indexOf('=');
+      const flag = equals < 0 ? token : token.slice(0, equals);
+      if (LOG_BOOLEAN_FLAGS.has(flag)) continue;
+      if (!LOG_VALUE_FLAGS.has(flag)) return false;
+      if (equals < 0) index += 1;
+      continue;
+    }
+    return LOG_SUBCOMMANDS.has(token);
+  }
+  return true;
+}
+
+/** Select lightweight operational paths whose CLI modules can stand alone. */
 export function selectLightCliRoute(args: readonly string[]): LightCliRoute | undefined {
   const command: string[] = [];
   let index = 0;
@@ -24,12 +57,19 @@ export function selectLightCliRoute(args: readonly string[]): LightCliRoute | un
     command.push(token);
   }
 
-  if (command[0] === 'msg' && (command[1] === 'list' || command[1] === 'ack' || command[1] === 'watch')) return 'msg';
+  // These four operational roots are the hot router. Keep all root flags and
+  // every leading-option form on the full entry so its isolation/bootstrap
+  // parser remains the sole owner of those semantics.
+  if (HOT_ROOTS.has(command[0] ?? '') && (args[0] !== command[0] || args.some(isRootGlobalFlag))) return undefined;
+
+  if (command[0] === 'msg' && ['list', 'post', 'ack', 'watch'].includes(command[1] ?? '')) return 'msg';
   // --reveal has an audit-log contract owned by the full CLI.
   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') return 'release';
-  if (command[0] === 'tasks' && command[1] === 'show') return 'tasks';
-  if (command[0] === 'pty' && (command[1] === 'list' || command[1] === 'state')) return 'pty';
-  if (command[0] === 'logs') return 'logs';
+  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';
+  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/pod-cli.ts

@@ -2,6 +2,12 @@
 // 산출 경로를 한 줄로 알리고 명령의 종료 코드로 끝난다. `--deadline` 생략 시 기존 Pod Job 상한.
 
 import type { Command } from 'commander';
+import { randomUUID } from 'node:crypto';
+import { hostname } from 'node:os';
+import { basename, join } from 'node:path';
+import { readFileSync } from 'node:fs';
+import { putPodShelfImage, listPodShelfImages, type PodShelfImage } from '../task-orchestrator/surfaces/pod-image-source.js';
+import { defaultRemoteRun } from '../task-orchestrator/surfaces/pod-pool.js';
 import { debug } from '../debug/log.js';
 import { readPodMemoryAdvice } from './pod-memory-advice.js';
 import { getUserConfig } from '../user-config.js';
@@ -28,6 +34,10 @@ export interface PodCliDeps {
   poolSpec?: (explicit?: string) => string | null;
   harnessPool?: () => string | undefined;
   memoryAdvice?: (logsDb?: string) => ReturnType<typeof readPodMemoryAdvice>;
+  shelfConfig?: () => { harness?: { imageCommit?: unknown } };
+  shelfPut?: (ref: string, pool: string) => Promise<PodShelfImage>;
+  shelfList?: (pool: string) => Promise<string[]> | string[];
+  shelfTail?: (artifactsDir: string) => string;
 }
 
 const HELP = `elanous pod run [--pool <스펙>] [--skill <이름,…>] [--llm grok] [--clone] [--deadline <초>] -- <명령…>
@@ -63,6 +73,57 @@ export function registerPodCommands(program: Command, deps: PodCliDeps = {}): vo
   };
   const run = deps.run ?? ((options: RunPodCommandOptions) => runPodCommand(options));
   const pod = program.command('pod').description('Pod 명령 Job — 하니스 없이 명령 하나를 돌리고 산출을 돌려받는다');
+  const shelf = pod.command('shelf').description('임의 PR·SHA·가지의 격리 하니스 이미지와 명령 Job');
+  const shelfPool = (explicit?: string) => {
+    const config = (deps.shelfConfig ?? getUserConfig)();
+    const spec = explicit || process.env.ELANOUS_POD_POOL || ('podPool' in (config.harness ?? {}) ? (config.harness as { podPool?: string }).podPool : undefined) || (config as { pod?: { pool?: string } }).pod?.pool;
+    if (!spec) throw new Error('pod shelf: remote pool is not configured');
+    return spec;
+  };
+  shelf.command('put <ref>').description('ref head 이미지를 빌드하거나 레지스트리 태그 재사용')
+    .option('--pool <spec>', '단일 원격 레지스트리 풀 멤버')
+    .action(async (ref: string, opts: { pool?: string }) => {
+      try {
+        const image = await (deps.shelfPut ?? putPodShelfImage)(ref, shelfPool(opts.pool));
+        io.log(`${image.image} (${image.action})`); io.exit(0);
+      } catch (err) { io.error(err instanceof Error ? err.message : String(err)); io.exit(1); }
+    });
+  shelf.command('ls').description('레지스트리의 커밋 이미지 태그 목록')
+    .option('--pool <spec>', '단일 원격 레지스트리 풀 멤버')
+    .action(async (opts: { pool?: string }) => {
+      try {
+        const images = await (deps.shelfList ?? ((pool) => listPodShelfImages(pool, defaultRemoteRun)))(shelfPool(opts.pool));
+        for (const image of images) io.log(image);
+        io.exit(0);
+      } catch (err) { io.error(err instanceof Error ? err.message : String(err)); io.exit(1); }
+    });
+  shelf.command('run <ref>').description('ref 이미지로 명령 Job 실행 · rc 와 출력 꼬리 반환')
+    .option('--pool <spec>', '단일 원격 레지스트리 풀 멤버')
+    .allowUnknownOption(true).allowExcessArguments(true)
+    .action(async (ref: string, opts: { pool?: string }) => {
+      const argv = process.argv.slice(2);
+      const sep = argv.indexOf('--');
+      const args = sep < 0 ? [] : argv.slice(sep + 1);
+      if (!args.length) { io.error('pod shelf run: `--` 뒤에 명령이 없다'); io.exit(2); return; }
+      try {
+        const pool = shelfPool(opts.pool);
+        const image = await (deps.shelfPut ?? putPodShelfImage)(ref, pool);
+        const seat = process.env.ELANOUS_SEAT?.trim();
+        const actor = seat || process.env.USER?.trim() || process.env.LOGNAME?.trim();
+        if (!actor) throw new Error('pod provenance actor missing: ELANOUS_SEAT or USER/LOGNAME required');
+        const runId = randomUUID();
+        const result = await run({ pool, image: image.image, shelfImage: image.image, imageCommit: image.commit,
+          clone: true, source: { kind: 'commit', sha: image.commit }, command: args, runId, returnLogs: true,
+          provenance: { actorKind: seat ? 'seat' : 'human', actor, character: 'command-runner', launchHost: hostname(),
+            entrance: 'pod-shelf-run', kind: 'command', run: runId, phase: 'exec', requestedAt: new Date().toISOString(), reason: 'unknown', argv: basename(args[0]!) },
+        });
+        io.error(`[pod shelf] image ${result.image ?? image.image} · rc ${result.exitCode} · job ${result.job}`);
+        io.log(result.artifactsDir);
+        const tail = (deps.shelfTail ?? ((dir) => readFileSync(join(dir, 'child.log'), 'utf8')))(result.artifactsDir);
+        io.log(tail.slice(-4096));
+        io.exit(result.exitCode);
+      } catch (err) { io.error(err instanceof Error ? err.message : String(err)); io.exit(1); }
+    });
   pod.command('memory').description('실측 기반 Pod 메모리 권고 (읽기 전용)')
     .command('advise').description('골 종류별 standard 16Gi / high 32Gi 권고와 근거')
     .option('--json', '권고와 측정 근거를 JSON 으로')
@@ -110,7 +171,9 @@ export function registerPodCommands(program: Command, deps: PodCliDeps = {}): vo
         // This explicit observation runs after the admission calculation. A slow or failed external
         // probe can never change recommended/limitedBy or slow the ordinary lease status path.
         const externalGitHub = opts.githubEgress ? Object.fromEntries(members.map((member) => {
-          try { return [member.context, (deps.externalGitHub ?? probePoolGitHub)(member.context, kubectl)]; }
+          try {
+            return [member.context, (deps.externalGitHub ?? probePoolGitHub)(member.context, kubectl)];
+          }
           catch { return [member.context, { externalDns: null, githubHttps: null, measuredAt: null, reason: 'probe failed' }]; }
         })) : undefined;
         const result = { pool: spec, ...measure, accounts, perAccount, ...decision, reserved: host.reserved, waitingJobs,
@@ -132,8 +195,10 @@ export function registerPodCommands(program: Command, deps: PodCliDeps = {}): vo
           }
           io.log(`예약(저작 중) ${host.reserved} · 대기 Job ${waitingJobs ?? '?'} · 실행 ${decision.running ?? '?'}`);
           io.log(`임대 없는 실행 ${decision.unleasedRunning ?? '?'}`);
-          if (externalGitHub) for (const [context, probe] of Object.entries(externalGitHub))
-            io.log(`GitHub 외부망 ${context}: DNS=${probe.externalDns ?? '?'} HTTPS=${probe.githubHttps ?? '?'} 측정=${probe.measuredAt ?? '?'}${probe.reason ? ` · ${probe.reason}` : ''}`);
+          if (externalGitHub) for (const [context, probe] of Object.entries(externalGitHub)) {
+            io.log(`GitHub 외부망 ${context}: DNS=${probe.externalDns ?? '?'} HTTPS=${probe.githubHttps ?? '?'} 측정=${probe.measuredAt ?? '?'}${probe.reason ? ` · ${probe.reason}` : ''}${probe.podName ? ` · Pod=${probe.podName}` : ''}`);
+            if (probe.podLog !== undefined) io.log(`GitHub 탐침 로그 ${probe.podName ?? context}: ${JSON.stringify(probe.podLog)}`);
+          }
           io.log(`capacity: ${decision.capacitySlots ?? '?'} 칸 (상한 ${members.reduce((sum, m) => sum + m.capacity, 0)} − Running ${decision.running ?? '?'} − Pending ${decision.pending ?? '?'}; 권장 수에서 건강한 멤버의 임대 없는 실행 차감)`);
           io.log(`memory: ${decision.memorySlots ?? '?'} 칸 (할당 가능 − Running 하니스 상한 합; 골당 16Gi · 모든 네임스페이스의 노드별 기존 예약을 반영해 배치 가능 ${decision.placeableSlots ?? '?'} 칸)`);
           io.log(`lite: ${decision.liteMemorySlots ?? '?'} 칸 (같은 여유를 lite 골 2Gi 로 센 값 · 관측만 — 권장 수는 위 standard 기준)`);
@@ -186,8 +251,17 @@ export function registerPodCommands(program: Command, deps: PodCliDeps = {}): vo
         debug.log('pod.run', 'clone-without-install', { argv0: commandArgs[0], argv1: commandArgs[1] });
       }
       try {
+        const seat = process.env.ELANOUS_SEAT?.trim();
+        const user = process.env.USER?.trim() || process.env.LOGNAME?.trim();
+        const actor = seat || user;
+        if (!actor) throw new Error('pod provenance actor missing: ELANOUS_SEAT or USER/LOGNAME required');
+        const runId = randomUUID();
         const result = await run({
           command: commandArgs,
+          runId,
+          provenance: { actorKind: seat ? 'seat' : 'human', actor,
+            character: 'command-runner', launchHost: hostname(), entrance: 'pod-run', kind: 'command', run: runId,
+            phase: 'exec', requestedAt: new Date().toISOString(), reason: 'unknown', argv: basename(commandArgs[0] || '') },
           returnLogs: true,
           ...(opts.pool ? { pool: opts.pool } : {}),
           ...(skills.length ? { skills } : {}),

package/src/cli/pr-cli.ts

@@ -30,6 +30,7 @@ import { queryRunningRuns, type RunningRunsResult } from '../self-implement/runn
 import { debug } from '../debug/log.js';
 import { runGitCommand } from '../git-fs/runner.js';
 import {
+  defaultCensusParallelRunner,
   defaultCmdRunner,
   makePrManager,
   resolveDeliverableBase,
@@ -71,7 +72,7 @@ import { readTaskAgentState, taskAgentStatePath, type TaskCard } from '../task-a
 import { INFLIGHT_REGISTRY_FILE, removeInflightForPr } from '../pr-tool/inflight-registry.js';
 import { PR_LABEL_NAMES } from '../github/pr-labels.js';
 import { enqueueL8ShadowQueue, runL8ShadowQueue, shadowPrNumber, statusL8ShadowQueue, type L8ShadowQueueDeps } from '../self-implement/l8-merge-queue.js';
-import { censusOpenPrs, guardNewPr, parseDiffHunks, readOpenPrs, type Seat } from '../pr-tool/census.js';
+import { censusOpenPrs, guardNewPr, parseDiffHunks, readOpenPrs, sharedCensusDiffCache, type Seat } from '../pr-tool/census.js';
 
 export { branchLineageSlug, findSiblingPrs };
 
@@ -2542,7 +2543,9 @@ export function registerPrCommands(program: Command, deps: PrLandDeps = {}, queu
       const diff = prToolRun('git', ['-C', cwd, 'diff', '--name-only', '-z', `${opts.base}...HEAD`]);
       const files = diff.ok ? diff.out.split('\0').filter(Boolean) : null;
       const patch = prToolRun('git', ['-C', cwd, 'diff', '--unified=0', `${opts.base}...HEAD`]);
-      const inventory = readOpenPrs(prToolRun, { cwd, ...(files ? { candidateFiles: files } : {}) });
+      // PR-CENSUS-PARALLEL: the real runner fans `gh pr diff` out (cap 6); an injected runner stays one by one.
+      const inventory = readOpenPrs(prToolRun, { cwd, ...(files ? { candidateFiles: files } : {}),
+        ...(deps.run ? {} : { runParallel: defaultCensusParallelRunner, diffCache: sharedCensusDiffCache }) });
       const result = guardNewPr({ files: patch.ok ? files : null, seat: opts.seat as Seat | undefined, seatCap: Number(opts.seatCap), cellId: opts.cell, hunks: patch.ok ? parseDiffHunks(patch.out) : undefined }, inventory);
       // Inspection never spends the three-creation unmeasured allowance.
       // Only pr-manager records an actual new-PR attempt in that ledger.

package/src/cli/pr-land-pod-shadow-job.ts

@@ -63,6 +63,9 @@ export async function runLandingPodShadowJob(input: LandingPodShadowInput, deps:
     // Wait for the runner to observe abort and finish Job/Secret/lease cleanup before landing continues.
     job = await (deps.runPod ?? runPodCommand)({
       command: ['bash', '-lc', script], clone: true, source: { kind: 'commit', sha: input.head },
+      provenance: { actorKind: 'loop', actor: 'pr-land-shadow', kind: 'land-shadow',
+        run: input.head, phase: 'land-shadow', requestedAt: new Date().toISOString(),
+        entrance: 'pr-land', commit: input.head, reason: 'landing typecheck and changed gate shadow' },
       returnLogs: true, deadlineSeconds: 45 * 60,
       statusUnreadableMs: LANDING_POD_SHADOW_STATUS_UNREADABLE_MS,
       hostDeadlineAtMs: Date.now() + LANDING_POD_SHADOW_HOST_TIMEOUT_MS,

package/src/cli/release-checklist-read-cli.ts

@@ -0,0 +1,79 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import type { Command } from 'commander';
+import { debug } from '../debug/log.js';
+import { getElanousConfigDirOverride } from '../elanous-config-dir.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { devVersion, listChecklist, ownerMatches, parseOwner, parityGap, summarizeChecklist } from '../release-loop/checklist.js';
+import { userConfigPath } from '../user-config.js';
+import { CliUserError } from './cli-user-error.js';
+import { writeStdoutJson } from './stdout-json.js';
+
+const SEMVER = /^\d+\.\d+\.\d+(?:-(?:rc|alpha|beta)\.\d+)?$/;
+export function isReleaseVersion(version: string): boolean { return SEMVER.test(version); }
+
+export function checklistCodenames(): Record<string, string> {
+  const path = getElanousConfigDirOverride() ? join(effectiveInstanceRoot(), 'config.json') : userConfigPath();
+  if (!existsSync(path)) return {};
+  const raw = JSON.parse(readFileSync(path, 'utf8')) as { release?: { codenames?: Record<string, string> } };
+  return raw.release?.codenames ?? {};
+}
+
+export function checklistVersion(input: string | undefined, codenames: Record<string, string>): string {
+  const v = input ?? devVersion().replace(/-dev\.\d+$/, '');
+  const resolved = isReleaseVersion(v) ? v : Object.entries(codenames).find(([, name]) => name === v)?.[0] ?? v;
+  if (!isReleaseVersion(resolved)) throw new CliUserError(`체크리스트 판 또는 별칭이 아니다: ${v}`);
+  return resolved;
+}
+
+export function readChecklistContext(cmd: Command): { version: string; codenames: Record<string, string>; json?: boolean } {
+  const opts = { ...(cmd.parent?.parent?.opts() as { version?: string; json?: boolean }), ...(cmd.parent?.opts() as { version?: string; json?: boolean }), ...(cmd.opts() as { version?: string; json?: boolean }) };
+  const codenames = checklistCodenames();
+  return { version: checklistVersion(opts.version, codenames), codenames, json: opts.json };
+}
+
+export async function checklistOutput(v: string, codenames: Record<string, string>, mode: 'list' | 'status', json?: boolean, owner?: string): Promise<void> {
+  if (owner !== undefined) parseOwner(owner);
+  const snapshot = listChecklist(v);
+  const data = owner === undefined ? snapshot : { ...snapshot, items: snapshot.items.filter((item) => ownerMatches(item.owner, owner)) };
+  const summary = summarizeChecklist(data);
+  const parity = data.items.flatMap((item) => {
+    const why = item.kind === 'screen' ? parityGap(item.evidence) : null;
+    return why ? [{ id: item.id, why }] : [];
+  });
+  const result = { ...data, codename: codenames[v] ?? '', ...summary, parity };
+  for (const { id, why } of parity) debug.log('release.checklist', 'parity-warning', { version: v, id, why });
+  if (json) { await writeStdoutJson(`${JSON.stringify(result)}\n`); return; }
+  console.log(`⚠ 짝 경고 ${parity.length}: ${parity.map(({ id }) => id).join(', ') || '없음'}`);
+  console.log(`${v}${result.codename ? ` (${result.codename})` : ''} · 공개 ${data.released || '없음'} · 개발 ${data.dev}`);
+  if (mode === 'list') {
+    for (const item of data.items) console.log(`${({ green: '🟢', yellow: '🟡', red: '🔴', done: '✅' } as const)[item.status]} ${item.id} ${item.title}${item.owner ? ` · ${item.owner}` : ''}${item.ceoMinutes !== undefined ? ` · 대표 손 ${item.ceoMinutes}분${item.ceoDate ? ` (${item.ceoDate})` : ''}` : ''}`);
+  } else {
+    console.log(`🟢 ${summary.green} · 🟡 ${summary.yellow} · 🔴 ${summary.red} · ✅ ${summary.done}`);
+    console.log(`🔴 칸: ${summary.blocked.join(', ') || '없음'}`);
+    console.log(`담당별: ${Object.entries(summary.byOwner).map(([owner, count]) => `${owner} ${count}`).join(' · ') || '없음'}`);
+  }
+}
+
+/** Register the same read commands on the full and lightweight release roots. */
+export function registerChecklistReadCommands(checklist: Command): void {
+  const withContext = (cmd: Command) => cmd.option('--version <v>', '판 또는 별칭').option('--json', '결과 JSON').option('--hq-override', '본부 임대 거부를 관측하며 수동 우회');
+  withContext(checklist.command('list').description('모든 칸')).option('--owner <owner>', '자리 또는 하위 자리로 거르기').action(async (opts: { owner?: string }, cmd: Command) => {
+    const { version, codenames, json } = readChecklistContext(cmd);
+    await checklistOutput(version, codenames, 'list', json, opts.owner);
+  });
+  withContext(checklist.command('status').description('상태 요약')).option('--owner <owner>', '자리 또는 하위 자리로 거르기').action(async (opts: { owner?: string }, cmd: Command) => {
+    const { version, codenames, json } = readChecklistContext(cmd);
+    await checklistOutput(version, codenames, 'status', json, opts.owner);
+  });
+}
+
+/** The light router enters only list/status, so no publishing modules are loaded. */
+export function registerReleaseChecklistReadCommands(program: Command): void {
+  const release = program.command('release').description('공개 배포 한 판 — prepare(로컬) → publish(--yes) → verify (docs/manual/MANUAL-versioning-and-release-2026-09-25.md)');
+  const checklist = release.command('checklist').description('판별 확인표 조회·갱신')
+    .option('--version <v>', '판 또는 별칭(기본: package.json 의 개발판에서 -dev.N 제거)')
+    .option('--json', '결과 JSON')
+    .option('--hq-override', '본부 임대 거부를 관측하며 수동 우회');
+  registerChecklistReadCommands(checklist);
+}

package/src/cli/release-cli.ts

@@ -8,7 +8,7 @@
 //   elanous release run     --version <x.y.z> [--prerelease rc] [--main-cut | --cut-commit <sha>] [--publish-at <iso>] [--gate-executor <pod|host> [--gate-host <ssh-host>]] [--dry-run] [--json] [--if-ready] [--force-new]
 //   elanous release resume  --run <runId> --from <node> [--waive <node> --reason <text>] [--accepted-regressions <json>] [--gate-executor <pod|host> [--gate-host <ssh-host>]] [--gate-pod-pool <pool>] [--json]
 //   elanous release auto-start [--window-minutes <n>] [--apply] [--json]
-//   elanous release rehearsal tick [--apply] [--checkout <dir>] [--shards <n>] [--remote <host>] [--json]
+//   elanous release rehearsal tick [--apply] [--checkout <dir>] [--shards <n>] [--remote <host>] [--recovery-run <id>] [--json]
 //   elanous release preflight --version <x.y.z> [--publish-at <iso>] [--json]   (컷 − 60분 main export 포함 사전 점검 · 읽기 전용 · ⛔ 있으면 exit 1)
 //   elanous release cut-branch --version <x.y.z> --base <sha> --pick <sha>... [--dry-run]
 //
@@ -17,7 +17,7 @@
 // ⛔ prepare 는 «네트워크에 아무것도 쓰지 않는다»(공개 저장소를 «읽기»로 clone 만 한다) — 쓰는 것은 publish 뿐이고 `--yes` 가 있어야 한다.
 //    공개는 되돌릴 수 없다(그 판은 영구히 공개 라이선스).
 // ⛔ 공개본은 «원본 매니페스트»(`release/public-export.yaml`)대로만 만든다 — 매매 실행 코드는 그 매니페스트가 이미 뺀다(🅢 #20529).
-import { spawnSync } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
@@ -27,10 +27,10 @@ import { debug } from '../debug/log.js';
 import { effectiveInstanceRoot, releaseLedgerRoot } from '../instance/resolve.js';
 import { getElanousConfigDirOverride } from '../elanous-config-dir.js';
 import { envLiteral } from '../platform/env-literal.js';
-import { getUserConfig, userConfigPath } from '../user-config.js';
-import { addItem, cellsReferencingDoc, claimItem, decodeClaimHistoryEntry, devVersion, inspectChecklistTargetPaths, lintDocRefs, listChecklist, normalizeRefs, noteDispatchSkip, ownerMatches, parseOwner, parityGap, refRoots, removeItem, renderRefsStatus, seedFromRoadmap, setItem, summarizeChecklist, type ChecklistStatus, type ChecklistDisposition, type ChecklistKind, type ChecklistDispatchKind } from '../release-loop/checklist.js';
+import { getUserConfig } from '../user-config.js';
+import { addItem, cellsReferencingDoc, claimItem, decodeClaimHistoryEntry, inspectChecklistTargetPaths, lintDocRefs, listChecklist, normalizeRefs, noteDispatchSkip, ownerMatches, parseOwner, parityGap, refRoots, removeItem, renderRefsStatus, seedFromRoadmap, setItem, type ChecklistStatus, type ChecklistDisposition, type ChecklistKind, type ChecklistDispatchKind } from '../release-loop/checklist.js';
 import * as features from '../release-loop/feature-store.js';
-import { evidencePlan, landedButYellow, type MergedChecklistPr } from '../release-loop/landed-but-yellow.js';
+import { evidencePlan, fetchMergedChecklistPrs, landedButYellow, type MergedPrRunner } from '../release-loop/landed-but-yellow.js';
 import { formatSchedule, getSchedule, listSchedules, setSchedule } from '../release-loop/release-schedule.js';
 import { mergedPrsLast24h, placeCell, planPullForward, pullForwardPlacementConfig, rebalance, seatMove, type PlacementPriority } from '../release-loop/placement.js';
 import { readTrafficSignal } from '../seat-loop/traffic-signal.js';
@@ -43,7 +43,7 @@ import { isIsolatedLedgerWriteRoot } from '../hq/ledger-write-target.js';
 import { runUnattendedRelease, type UnattendedReleaseDeps } from '../../scripts/release-loop/unattended-release.js';
 import { publishAtError } from '../../scripts/release-loop/publish-at.js';
 import { cutReleaseBranch } from '../../scripts/release-loop/cut-branch.js';
-import { planResumeReleaseRun, resumeReleaseRun } from '../../scripts/release-loop/resume-release.js';
+import { planResumeReleaseRun, resumeReleaseRun, type ResumeReleaseDeps } from '../../scripts/release-loop/resume-release.js';
 import type { AcceptedRegression } from '../../scripts/release-loop/resume.js';
 import type { PrereleaseKind } from '../../scripts/release-loop/release-version.js';
 import { releaseReadiness } from '../../scripts/release-loop/release-readiness.js';
@@ -57,9 +57,11 @@ import { landingFreezeMessage, LandingFrozenError, readLandingFreeze } from '../
 import { formatLightRc, runLightRc, type LightRcDeps } from '../release-loop/light-rc.js';
 import { applyWatchList, formatGateHistory, gateHistory, ghMergedPrs } from '../../scripts/release-loop/gate-history.js';
 import { registerRfcCommands } from './rfc-cli.js';
+import { checklistCodenames, checklistVersion, isReleaseVersion, readChecklistContext, registerChecklistReadCommands } from './release-checklist-read-cli.js';
+
+export { isReleaseVersion } from './release-checklist-read-cli.js';
 
 export const DEFAULT_PUBLIC_REPO = 'ElanvitalAI/elanous';
-const SEMVER = /^\d+\.\d+\.\d+(?:-(?:rc|alpha|beta)\.\d+)?$/;
 
 export interface RunResult { status: number | null; stdout: string; stderr: string }
 export type Runner = (command: string, args: readonly string[], cwd: string, opts?: { env?: NodeJS.ProcessEnv; input?: string }) => RunResult;
@@ -69,7 +71,6 @@ export const defaultRunner: Runner = (command, args, cwd, opts = {}) => {
   return { status: r.status, stdout: r.stdout ?? '', stderr: r.error ? String(r.error) : (r.stderr ?? '') };
 };
 
-export function isReleaseVersion(version: string): boolean { return SEMVER.test(version); }
 export function isPrerelease(version: string): boolean { return version.includes('-'); }
 
 export interface ReleaseManifest {
@@ -535,45 +536,12 @@ function warnChecklistTargetPaths(input: { title: string; evidence?: string; ref
   }
 }
 
-function checklistCodenames(): Record<string, string> {
-  const path = getElanousConfigDirOverride() ? join(effectiveInstanceRoot(), 'config.json') : userConfigPath();
-  if (!existsSync(path)) return {};
-  const raw = JSON.parse(readFileSync(path, 'utf8')) as { release?: { codenames?: Record<string, string> } };
-  return raw.release?.codenames ?? {};
-}
-
-function checklistVersion(input: string | undefined, codenames: Record<string, string>): string {
-  const v = input ?? devVersion().replace(/-dev\.\d+$/, '');
-  const resolved = isReleaseVersion(v) ? v : Object.entries(codenames).find(([, name]) => name === v)?.[0] ?? v;
-  if (!isReleaseVersion(resolved)) throw new CliUserError(`체크리스트 판 또는 별칭이 아니다: ${v}`);
-  return resolved;
-}
-
-async function checklistOutput(v: string, codenames: Record<string, string>, mode: 'list' | 'status', json?: boolean, owner?: string): Promise<void> {
-  if (owner !== undefined) parseOwner(owner);
-  const snapshot = listChecklist(v);
-  const data = owner === undefined ? snapshot : { ...snapshot, items: snapshot.items.filter((item) => ownerMatches(item.owner, owner)) };
-  const summary = summarizeChecklist(data);
-  const parity = data.items.flatMap((item) => {
-    const why = item.kind === 'screen' ? parityGap(item.evidence) : null;
-    return why ? [{ id: item.id, why }] : [];
-  });
-  const result = { ...data, codename: codenames[v] ?? '', ...summary, parity };
-  for (const { id, why } of parity) debug.log('release.checklist', 'parity-warning', { version: v, id, why });
-  if (json) { await writeStdoutJson(`${JSON.stringify(result)}\n`); return; }
-  console.log(`⚠ 짝 경고 ${parity.length}: ${parity.map(({ id }) => id).join(', ') || '없음'}`);
-  console.log(`${v}${result.codename ? ` (${result.codename})` : ''} · 공개 ${data.released || '없음'} · 개발 ${data.dev}`);
-  if (mode === 'list') {
-    for (const item of data.items) console.log(`${({ green: '🟢', yellow: '🟡', red: '🔴', done: '✅' } as const)[item.status]} ${item.id} ${item.title}${item.owner ? ` · ${item.owner}` : ''}${item.ceoMinutes !== undefined ? ` · 대표 손 ${item.ceoMinutes}분${item.ceoDate ? ` (${item.ceoDate})` : ''}` : ''}`);
-  } else {
-    console.log(`🟢 ${summary.green} · 🟡 ${summary.yellow} · 🔴 ${summary.red} · ✅ ${summary.done}`);
-    console.log(`🔴 칸: ${summary.blocked.join(', ') || '없음'}`);
-    console.log(`담당별: ${Object.entries(summary.byOwner).map(([owner, count]) => `${owner} ${count}`).join(' · ') || '없음'}`);
-  }
-}
-
 export interface LandedButYellowDeps {
   run?: Runner;
+  /** Async gh for the merged-PR windows; wins over `run` (tests inject delay). */
+  runAsync?: MergedPrRunner;
+  /** logs.db sink for the stage timings; the default registers only on the real (uninjected) gh path. */
+  registerLogSink?: () => Promise<unknown>;
   checklist?: typeof listChecklist;
   now?: () => Date;
   evidenceAdd?: typeof features.evidenceAdd;
@@ -581,45 +549,18 @@ export interface LandedButYellowDeps {
   released?: typeof features.releasedVersion;
 }
 
-const MERGED_PR_LIMIT = 400;
-
-function mergedChecklistPrs(since: string, now: Date, run: Runner): { prs: MergedChecklistPr[]; truncated: boolean } {
-  const cwd = process.cwd();
-  const fetch = (lower: string, upper?: string, limit = MERGED_PR_LIMIT): MergedChecklistPr[] => {
-    const search = `merged:>=${lower}${upper ? ` merged:<${upper}` : ''}`;
-    const raw = must(run('gh', ['pr', 'list', '--state', 'merged', '--search', search, '--limit', String(limit), '--json', 'number,title,body,mergedAt'], cwd), '병합 PR 조회(gh)');
-    const page = JSON.parse(raw) as MergedChecklistPr[];
-    if (!Array.isArray(page)) throw new Error('병합 PR 조회(gh): 배열이 아니다');
-    return page;
-  };
-  const unique = new Map<number, MergedChecklistPr>();
-  let truncated = false;
-  const collect = (page: MergedChecklistPr[]) => {
-    for (const pr of page) if (!unique.has(pr.number)) unique.set(pr.number, pr);
-  };
-  const first = fetch(since);
-  if (first.length < MERGED_PR_LIMIT) return { prs: first, truncated: false };
-  const lower = Date.parse(`${since}T00:00:00Z`);
-  const upper = Math.max(lower + 1000, Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + 1));
-  const visit = (start: number, end: number): void => {
-    const from = new Date(start).toISOString();
-    const to = new Date(end).toISOString();
-    const page = fetch(from, to);
-    if (page.length < MERGED_PR_LIMIT) { collect(page); return; }
-    if (end - start <= 1000) {
-      // The second-precision search cannot be subdivided; probe one extra row to distinguish exactly 400 from a real truncation.
-      const probe = fetch(from, to, MERGED_PR_LIMIT + 1);
-      collect(probe.slice(0, MERGED_PR_LIMIT));
-      if (probe.length > MERGED_PR_LIMIT) truncated = true;
-      return;
-    }
-    const middle = start + Math.floor((end - start) / 2000) * 1000;
-    visit(start, middle);
-    visit(middle, end);
-  };
-  visit(lower, upper);
-  return { prs: [...unique.values()], truncated };
-}
+/** A spawn failure (gh missing from PATH) resolves `status: null` with the error text — the shape the sync runner gave. */
+const defaultMergedPrRunner: MergedPrRunner = (command, args, cwd) => new Promise((resolve) => {
+  const out: Buffer[] = [], err: Buffer[] = [];
+  const failed = (error: unknown) => resolve({ status: null, stdout: Buffer.concat(out).toString('utf8'), stderr: String(error) });
+  let child: ReturnType<typeof spawn>;
+  try { child = spawn(command, [...args], { cwd, env: process.env, stdio: ['ignore', 'pipe', 'pipe'] }); }
+  catch (error) { failed(error); return; }
+  child.stdout?.on('data', (chunk: Buffer) => out.push(chunk));
+  child.stderr?.on('data', (chunk: Buffer) => err.push(chunk));
+  child.on('error', failed);
+  child.on('close', (code) => resolve({ status: code, stdout: Buffer.concat(out).toString('utf8'), stderr: Buffer.concat(err).toString('utf8') }));
+});
 
 function printLandedRows(rows: ReturnType<typeof landedButYellow>, items: ReturnType<typeof listChecklist>['items']): void {
   const updatedAtById = new Map(items.map((item) => [item.id, item.updatedAt]));
@@ -647,7 +588,7 @@ function compareReleaseVersions(a: string, b: string): number {
   return 0;
 }
 
-export function registerReleaseCommands(program: Command, releaseRunDeps: UnattendedReleaseDeps = {}, landedDeps: LandedButYellowDeps = {}, hqDeps: HqDeps = {}, lightRcDeps: LightRcDeps = {}, rehearsalDeps: RehearsalDeps = {}): void {
+export function registerReleaseCommands(program: Command, releaseRunDeps: UnattendedReleaseDeps = {}, landedDeps: LandedButYellowDeps = {}, hqDeps: HqDeps = {}, lightRcDeps: LightRcDeps = {}, rehearsalDeps: RehearsalDeps = {}, resumeDeps: ResumeReleaseDeps = {}): void {
   registerRfcCommands(program);
   const release = program.command('release').description('공개 배포 한 판 — prepare(로컬) → publish(--yes) → verify (docs/manual/MANUAL-versioning-and-release-2026-09-25.md)');
   const schedule = release.command('schedule').description('판별 컷·착지 마감 조회·갱신');
@@ -789,11 +730,7 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
     .option('--json', '결과 JSON')
     .option('--hq-override', '본부 임대 거부를 관측하며 수동 우회');
   const mayWrite = (cmd: Command) => mayWriteLedger(`release checklist ${cmd.name()}`, Boolean(cmd.optsWithGlobals().hqOverride), releaseLedgerRoot());
-  const context = (cmd: Command) => {
-    const opts = { ...(cmd.parent?.parent?.opts() as { version?: string; json?: boolean }), ...(cmd.parent?.opts() as { version?: string; json?: boolean }), ...(cmd.opts() as { version?: string; json?: boolean }) };
-    const codenames = checklistCodenames();
-    return { version: checklistVersion(opts.version, codenames), codenames, json: opts.json };
-  };
+  const context = readChecklistContext;
   const withContext = (cmd: Command) => cmd.option('--version <v>', '판 또는 별칭').option('--json', '결과 JSON').option('--hq-override', '본부 임대 거부를 관측하며 수동 우회');
   const actor = () => process.env.ELANOUS_TRACK || 'cli';
   withContext(checklist.command('rubric').description('루브릭 채점(읽기 전용)'))
@@ -843,20 +780,30 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
       console.log(renderRefsStatus(rows));
       console.log(`칸 ${rows.length} · 🟢 ${byStatus.green} · 🟡 ${byStatus.yellow} · 🔴 ${byStatus.red} · ✅ ${byStatus.done}`);
     });
-  withContext(checklist.command('list').description('모든 칸')).option('--owner <owner>', '자리 또는 하위 자리로 거르기').action(async (opts: { owner?: string }, cmd: Command) => {
-    const { version, codenames, json } = context(cmd);
-    await checklistOutput(version, codenames, 'list', json, opts.owner);
-  });
-  withContext(checklist.command('status').description('상태 요약')).option('--owner <owner>', '자리 또는 하위 자리로 거르기').action(async (opts: { owner?: string }, cmd: Command) => {
-    const { version, codenames, json } = context(cmd);
-    await checklistOutput(version, codenames, 'status', json, opts.owner);
-  });
+  registerChecklistReadCommands(checklist);
   withContext(checklist.command('landed-but-yellow').description('병합 PR 이 있지만 노랑·빨강인 칸(기본 읽기 전용)'))
     .option('--owner <owner>', '자리 또는 하위 자리로 거르기')
     .option('--open', '미발행 일정 판 중 칸이 있는 판 전부')
     .option('--apply-evidence', '확실한 PR 짝의 근거를 붙인다(상태는 그대로)')
     .option('--dry-run', '근거 추가 없이 계획만 출력')
     .action(async (opts: { owner?: string; open?: boolean; applyEvidence?: boolean; dryRun?: boolean }, cmd: Command) => {
+      // Stage timings (LANDED-YELLOW-FAST): which step ate the time — `elanous logs --category release.landed-yellow`.
+      let stageAt = performance.now();
+      const stage = (name: string, data: Record<string, unknown>) => {
+        const at = performance.now();
+        debug.log('release.landed-yellow', 'stage', { stage: name, ms: Math.round(at - stageAt), ...data });
+        stageAt = at;
+      };
+      // A standalone CLI's debug.log reaches logs.db only through a registered sink (pr land #6701 lesson). Fail-open, 1s cap.
+      const registerLogSink = landedDeps.registerLogSink ?? (landedDeps.run || landedDeps.runAsync ? undefined
+        : async () => (await import('../domains/standalone-log-sink.js')).registerStandaloneLogSink('release-landed-yellow'));
+      if (registerLogSink) {
+        let sinkTimer: ReturnType<typeof setTimeout> | undefined;
+        try {
+          await Promise.race([registerLogSink(), new Promise<void>((resolve) => { sinkTimer = setTimeout(resolve, 1000); })]);
+        } catch { /* observability is fail-open */ } finally { clearTimeout(sinkTimer); }
+      }
+      stageAt = performance.now();
       try {
         const inherited = cmd.parent?.opts() as { version?: string; json?: boolean } | undefined;
         const local = cmd.opts() as { version?: string; json?: boolean };
@@ -873,6 +820,7 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
           .filter(({ version }) => isReleaseVersion(version) && (!released || compareReleaseVersions(version, released) > 0))
           .sort((a, b) => compareReleaseVersions(a.version, b.version))
           .map(({ version }) => (landedDeps.checklist ?? listChecklist)(version)).filter((snapshot) => snapshot.items.length > 0);
+        stage('snapshots', { n: openSnapshots.length, schedules: schedules.length });
         if (opts.open && !openSnapshots.length) {
           if (json) await writeStdoutJson('[]\n'); else console.log('열린 판 없음');
           return;
@@ -887,7 +835,10 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
           .map((item) => Date.parse(item.updatedAt)).filter((at) => Number.isFinite(at)));
         const since = updated.length ? new Date(updated.reduce((earliest, at) => Math.min(earliest, at))).toISOString().slice(0, 10)
           : new Date(now.getTime() - 7 * 86_400_000).toISOString().slice(0, 10);
-        const { prs, truncated } = mergedChecklistPrs(since, now, landedDeps.run ?? defaultRunner);
+        const syncRun = landedDeps.run;
+        const runAsync: MergedPrRunner = landedDeps.runAsync ?? (syncRun ? async (command, args, cwd) => syncRun(command, args, cwd) : defaultMergedPrRunner);
+        const { prs, truncated, calls } = await fetchMergedChecklistPrs(since, now, runAsync, process.cwd());
+        stage('merged-prs', { n: prs.length, calls, since, truncated });
         const results: Array<{ version: string; rows?: ReturnType<typeof landedButYellow>; plan?: ReturnType<typeof evidencePlan> }> = [];
         let totalAdded = 0, totalSkipped = 0;
         for (const snapshot of snapshots) {
@@ -914,6 +865,7 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
             results.push({ version, rows });
           }
         }
+        stage('match', { n: results.reduce((sum, result) => sum + (result.rows?.length ?? result.plan?.length ?? 0), 0), versions: snapshots.length, prs: prs.length });
         if (opts.open) {
           if (opts.applyEvidence && !opts.dryRun) debug.log('release.checklist', 'evidence-synced', { versions: snapshots.map(({ version }) => version), added: totalAdded, skippedMention: totalSkipped });
           if (!json) console.log(`판 ${snapshots.length} · 붙임 합 ${totalAdded} · 건너뜀(언급만) 합 ${totalSkipped}`);
@@ -1389,16 +1341,34 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
     .option('--checkout <dir>', '깨끗한 git 체크아웃(기본 ELANOUS_REHEARSAL_GIT_CWD)')
     .option('--shards <n>', '시험 분할 수')
     .option('--remote <host>', '게이트 호스트')
+    .option('--recovery-run <id>', '기존 실패 release-loop 런을 gate에서 명시적으로 재개(기본 예약 틱과 분리)')
     .option('--json', '결과 한 줄 JSON(stdout)')
-    .action(async (o: { apply?: boolean; checkout?: string; shards?: string; remote?: string; json?: boolean }) => {
+    .action(async (o: { apply?: boolean; checkout?: string; shards?: string; remote?: string; recoveryRun?: string; json?: boolean }) => {
       await jsonAction(o.json, async (log) => {
         const ledgerRoot = scheduleLedgerRoot();
+        if (o.recoveryRun !== undefined) {
+          if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/.test(o.recoveryRun)) throw new Error('release rehearsal recovery: invalid run id');
+          if (o.shards !== undefined || o.remote !== undefined) throw new Error('release rehearsal recovery: --shards and --remote are unsupported; use the saved gate settings');
+          const resumeOptions = { runId: o.recoveryRun, from: 'gate', commandRoot: o.checkout ?? process.cwd() };
+          if (!o.apply) {
+            const plan = await planResumeReleaseRun(resumeOptions, resumeDeps);
+            log(`· 리허설 복구 사전점검 ${plan.preflight} · run ${plan.runId} · ${plan.version} · from ${plan.fromNode} · gate ${plan.gatePlan.mode}`);
+            return { recovery: 'planned', ...plan };
+          }
+          if (!mayWriteLedger('release rehearsal recovery', false, ledgerRoot)) throw new Error('release rehearsal recovery: ledger write denied');
+          const result = await resumeReleaseRun(resumeOptions, resumeDeps);
+          log(`· 리허설 복구 완료 · run ${o.recoveryRun} · ${result.state.status} · gate에서 재개`);
+          return { recovery: 'resumed', runId: o.recoveryRun, status: result.state.status, ...result };
+        }
         if (o.apply && !mayWriteLedger('release rehearsal tick', false, ledgerRoot)) throw new Error('release rehearsal tick: ledger write denied');
-        // The tick reports a preflight shard shortage as an unmeasured attempt; its released stage can be claimed on the next CLI tick.
         const result = await runRehearsalTick({ apply: o.apply, checkout: o.checkout, shards: o.shards === undefined ? undefined : Number(o.shards), remote: o.remote, ledgerRoot }, rehearsalDeps);
         log(`· 리허설 ${result.status}${'version' in result ? ` ${result.version}` : ''}${result.status === 'due' ? ` · 실행 ${result.run ?? '-'} · 건너뜀 ${result.supersede.join(', ') || '-'}` : ''}`);
+        for (const stamp of result.stamps ?? []) {
+          if (stamp.outcome === 'unmeasured' && !stamp.result && stamp.shardPlan && (stamp.shardPlan.testFiles === 0 || stamp.shardPlan.gatePlanShards === null))
+            log(`· 리허설 ${stamp.version} ${stamp.step} · ${stamp.summary} · stage claim 해제 · 다음 tick 재시도`);
+        }
         return result;
-      }, (result) => !result.notificationFailures && !result.stamps?.some((stamp) => !['ok', 'superseded'].includes(stamp.outcome)));
+      }, (result) => result.status !== 'failed' && !result.notificationFailures && !result.stamps?.some((stamp) => !['ok', 'superseded'].includes(stamp.outcome)));
     });
   release.command('auto-start')
     .description('판 일정의 컷 창에서 릴리스 시작을 미리 본다 · --apply 로 release run --if-ready 실행')

package/src/cli/remote-resolve.ts

@@ -203,7 +203,7 @@ function hasFlag(args: readonly string[], name: string): boolean {
  *  읽어 `<값>` 을 받는 것이 전부 여기 있는지 확인한다(`root value-taking flags are enumerated`).
  *  ⇒ 루트에 값 받는 플래그를 더하면 그 시험이 «먼저» 깨진다. */
 // ⭐ `--name <name>` = 대시보드 TUI 별명(dashboard-name-flag.ts) — 값이 다음 토큰이라 `elanous --name op -r` 의 `-r` 이 루트로 남게 센다.
-export const ROOT_FLAGS_TAKING_VALUE = new Set(['--remote', '--config-dir', '--name']);
+export const ROOT_FLAGS_TAKING_VALUE = new Set(['--remote', '--config-dir', '--name', '--tui']);
 
 /** 이 토큰이 루트 «선행 플래그 구간» 안에 있나 — 즉 전역 선처리가 소유하나.
  *  ⛔ 없으면 다른 명령의 `-r` 을 «탈취»한다(`autopilot link … -r friend`).