elanous 0.2.22 → 0.2.24

package/scripts/fleet/zai-pod-secret.ts

@@ -0,0 +1,86 @@
+#!/usr/bin/env bun
+/**
+ * ZAI-POD-CHILD (0.2.24) — 호스트 ZAI 키(키 캐시 `~/.cache/zai_api_key` → env `ZAI_API_KEY`) → 풀 클러스터의 glm Pod 전용 Secret(`elanous-zai-coding-plan`).
+ *
+ * ⛔ 값은 터미널·로그·파일 어디에도 안 낸다 — 키는 메모리에서 바로 `kubectl apply -f -` 의 stdin 으로만 간다. 출력은 «키 이름 · 대상» 뿐이다.
+ * ⛔ 기본은 «계획만»(dry-run · 클러스터 접촉 0). 실제로 만들려면 `--apply` — 승인 뒤에만 친다.
+ * 본보기 = scripts/fleet/bedrock-pod-secret.ts
+ *
+ * 사용:
+ *   bun scripts/fleet/zai-pod-secret.ts --context k3d-elanous-pool            # 계획만(키 이름)
+ *   bun scripts/fleet/zai-pod-secret.ts --context k3d-elanous-pool --apply    # 만든다/갱신한다
+ *   옵션: --namespace <ns>(기본 elanous-test)
+ * 짝: docker/h1/policy-zai.yaml(이그레스) · src/task-orchestrator/surfaces/pod-zai-child.ts(발사 전 판정 · 동시 상한)
+ */
+import { spawnSync } from 'node:child_process';
+import { ZAI_POD_SECRET_KEY, ZAI_POD_SECRET_NAME } from '../../src/task-orchestrator/surfaces/pod-zai-child.js';
+
+export interface ZaiSecretArgs { context?: string; namespace: string; apply: boolean }
+
+export function parseArgs(argv: readonly string[]): ZaiSecretArgs | { error: string } {
+  const out: ZaiSecretArgs = { namespace: 'elanous-test', apply: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]!;
+    const value = () => { const v = argv[++i]; if (!v || v.startsWith('--')) throw new Error(`${a} 에 값이 없다`); return v; };
+    try {
+      if (a === '--context') out.context = value();
+      else if (a === '--namespace') out.namespace = value();
+      else if (a === '--apply') out.apply = true;
+      else return { error: `모르는 인자: ${a}` };
+    } catch (e) { return { error: (e as Error).message }; }
+  }
+  if (!out.context) return { error: '--context <풀 문맥> 이 필요하다 — 어느 클러스터에 둘지 명시한다(기본 문맥에 조용히 쓰지 않는다)' };
+  return out;
+}
+
+/** Secret 매니페스트 — 값은 이 객체 안에만 있고, 호출자는 stdin 으로만 넘긴다. */
+export function zaiPodSecretManifest(input: { namespace: string; key: string; name?: string }): Record<string, unknown> {
+  return {
+    apiVersion: 'v1', kind: 'Secret', type: 'Opaque',
+    metadata: { name: input.name ?? ZAI_POD_SECRET_NAME, namespace: input.namespace, labels: { 'elanous.secret': 'zai-coding-plan' } },
+    stringData: { [ZAI_POD_SECRET_KEY]: input.key },
+  };
+}
+
+/** 사람에게 보이는 계획 — 키 «이름»만. */
+export function describePlan(args: ZaiSecretArgs): string {
+  return [
+    `대상: --context ${args.context} · ${args.namespace}/${ZAI_POD_SECRET_NAME}`,
+    '출처: 호스트 키 캐시 ~/.cache/zai_api_key → env ZAI_API_KEY',
+    `키: ${ZAI_POD_SECRET_KEY} (값은 출력하지 않는다)`,
+  ].join('\n');
+}
+
+export interface Deps {
+  key: () => string | undefined;
+  kubectl: (args: string[], stdin: string) => { status: number | null; stdout: string; stderr: string };
+  print: (line: string) => void;
+}
+
+const defaultDeps: Deps = {
+  key: () => undefined,
+  kubectl: (args, stdin) => {
+    const r = spawnSync('kubectl', args, { input: stdin, encoding: 'utf8', timeout: 60_000 });
+    return { status: r.status, stdout: r.stdout ?? '', stderr: r.stderr ?? '' };
+  },
+  print: (line) => console.log(line),
+};
+
+export async function run(argv: readonly string[], deps: Deps = defaultDeps): Promise<number> {
+  const args = parseArgs(argv);
+  if ('error' in args) { deps.print(`⛔ ${args.error}`); return 2; }
+  const key = deps.key()?.trim();
+  if (!key) { deps.print('⛔ 호스트에 ZAI 키가 없다 — ~/.cache/zai_api_key 또는 env ZAI_API_KEY'); return 2; }
+  deps.print(describePlan(args));
+  if (!args.apply) { deps.print('계획만(dry-run) — 클러스터에 쓰지 않았다. 만들려면 --apply(승인 뒤)'); return 0; }
+  const r = deps.kubectl(['--context', args.context!, 'apply', '-f', '-'], JSON.stringify(zaiPodSecretManifest({ namespace: args.namespace, key })));
+  // kubectl apply 의 출력은 «secret/<이름> created|configured» 뿐이다 — stderr 는 원문 대신 rc 만.
+  if (r.status !== 0) { deps.print(`⛔ kubectl apply 실패 rc=${r.status}`); return 1; }
+  deps.print(`✅ ${r.stdout.trim().split('\n')[0] ?? 'applied'}`);
+  return 0;
+}
+
+if (import.meta.main) {
+  const { getZaiApiKey } = await import('../../src/llm/zai-coding-plan.js');
+  process.exit(await run(process.argv.slice(2), { ...defaultDeps, key: () => getZaiApiKey() }));
+}

package/scripts/hq/hq-fence-wrapper.sh

@@ -0,0 +1,148 @@
+#!/bin/sh
+# FENCE-LIGHT (0.2.23) — sourced by the installed hq-fence wrapper (src/hq/fence-wrapper.ts renderHqFenceWrapper),
+# from the installed package root, only when "$CONFIG_DIR/hq/lease-cache" exists. Inherits ROLE, "$@", BUN, ENTRY,
+# CONFIG_DIR, LOG, log_line, alert. Always exits.
+#
+# Cache line (written only by a successful holder renewal in hqHeartbeat; removed at every heartbeat start,
+# by every successful lease action and by every CLI «do not run»):
+#   <holder> <generation> <expiresAt> <host> <machine> <confirmedAt>
+#
+# Fast path (no bun, no network) ONLY when every check below holds; anything else is DECISION=cli, i.e. the
+# same installed CLI decision as before (`hq fence --role`), under the role's time limit.
+#   holder = cache host = ~/.elanous-hq/host · machine = `hostname` · confirmedAt <= now < confirmedAt+660
+#   now < expiresAt <= confirmedAt+660 · local.json starts {"holder":<it>,"generation":<it> · seen-generation <= it
+#   Every file one line; numbers without leading zeros (an arithmetic error must never abort before the CLI).
+# There is no fast «skip»: a cache that names another holder goes to the CLI.
+#
+# Time limit per role (seconds). The watchdog is GNU timeout: it puts the fenced command in its own process
+# group and signals only that group (TERM, then KILL after 5s) — never anything by name.
+case "$ROLE" in
+  telegram-poller|release-run) LIMIT=3600 ;;
+  seat-loop) LIMIT=1800 ;;
+  cron|conatus) LIMIT=900 ;;
+  git-push|ledger-cli) LIMIT=120 ;;
+  *) LIMIT= ;;
+esac
+
+# Watchdog: PATH first (cron PATH is /usr/bin:/bin), then Homebrew coreutils. HQ_FENCE_WATCHDOGS overrides the
+# absolute candidates (tests). None found = the legacy CLI command without a limit, with one evidence line.
+TIMEOUT=
+for t in timeout gtimeout ${HQ_FENCE_WATCHDOGS-/opt/homebrew/bin/timeout /opt/homebrew/bin/gtimeout /usr/local/bin/timeout /usr/local/bin/gtimeout}; do
+  case "$t" in
+    /*) if [ -x "$t" ]; then TIMEOUT=$t; break; fi ;;
+    *) p=$(command -v "$t" 2>/dev/null) && [ -n "$p" ] && { TIMEOUT=$p; break; } ;;
+  esac
+done
+
+DECISION=cli
+WHY=
+FL_CACHE="$CONFIG_DIR/hq/lease-cache"
+FL_HOST_FILE="$HOME/.elanous-hq/host"
+FL_LOCAL="$CONFIG_DIR/hq/local.json"
+FL_SEEN="$HOME/.elanous-hq/seen-generation"
+if [ -z "$LIMIT" ]; then WHY=unknown-role
+elif [ $# -eq 0 ] || [ -z "$*" ]; then WHY=no-command
+elif [ -z "$TIMEOUT" ]; then WHY=no-watchdog
+elif [ -L "$FL_CACHE" ] || [ ! -f "$FL_CACHE" ] || [ ! -r "$FL_CACHE" ]; then WHY=cache-unreadable
+elif [ -L "$FL_HOST_FILE" ] || [ ! -f "$FL_HOST_FILE" ] || [ ! -r "$FL_HOST_FILE" ]; then WHY=no-host-file
+elif [ ! -f "$FL_LOCAL" ] || [ ! -r "$FL_LOCAL" ]; then WHY=no-local-state
+else
+  HOLDER= GENERATION= EXPIRES= CACHE_HOST= CACHE_MACHINE= CONFIRMED= EXTRA= THIS_HOST= LOCAL_LINE= SEEN=
+  CACHE_MORE=0 LOCAL_MORE=0
+  # Each file must be exactly one newline-terminated line: a second read that succeeds, or that hits EOF
+  # with unterminated text, means more content.
+  { IFS=' ' read -r HOLDER GENERATION EXPIRES CACHE_HOST CACHE_MACHINE CONFIRMED EXTRA || CACHE_MORE=1
+    _FL_REST=; if IFS= read -r _FL_REST || [ -n "$_FL_REST" ]; then CACHE_MORE=1; fi; } < "$FL_CACHE"
+  IFS= read -r THIS_HOST < "$FL_HOST_FILE" || true
+  { IFS= read -r LOCAL_LINE || LOCAL_MORE=1
+    _FL_REST=; if IFS= read -r _FL_REST || [ -n "$_FL_REST" ]; then LOCAL_MORE=1; fi; } < "$FL_LOCAL"
+  WHY=malformed
+  case "$HOLDER" in ''|*[!A-Za-z0-9_.-]*) ;; *)
+  case "$CACHE_MACHINE" in ''|*[!A-Za-z0-9_.-]*) ;; *)
+  case "$GENERATION" in ''|0*|*[!0-9]*) ;; *)
+  case "$EXPIRES" in ''|0*|*[!0-9]*) ;; *)
+  case "$CONFIRMED" in ''|0*|*[!0-9]*) ;; *)
+    if [ "$CACHE_MORE" = 1 ] || [ -n "$EXTRA" ] || [ "${#GENERATION}" -gt 15 ] || [ "${#EXPIRES}" -gt 12 ] || [ "${#CONFIRMED}" -gt 12 ]; then WHY=malformed
+    elif [ "$HOLDER" != "$THIS_HOST" ] || [ "$CACHE_HOST" != "$THIS_HOST" ]; then WHY=not-this-host
+    else
+      THIS_MACHINE=$(hostname)
+      THIS_MACHINE=${THIS_MACHINE%.local}
+      NOW=$(date +%s)
+      if [ "$CACHE_MACHINE" != "$THIS_MACHINE" ]; then WHY=other-machine
+      elif [ "$CONFIRMED" -gt "$NOW" ] || [ "$NOW" -ge "$((CONFIRMED + 660))" ] \
+        || [ "$EXPIRES" -le "$NOW" ] || [ "$EXPIRES" -gt "$((CONFIRMED + 660))" ]; then WHY=stale
+      else
+        # The CLI's own host-local view must name the same holder and generation as its leading top-level
+        # fields — hq.ts writeLocal is JSON.stringify({ holder, generation, ... }) on one line. Anchored at «{»,
+        # so a nested or later «holder» never matches; any other shape goes to the CLI.
+        if [ "$LOCAL_MORE" = 1 ]; then WHY=local-malformed
+        else
+          case "$LOCAL_LINE" in
+            '{"holder":"'"$HOLDER"'","generation":'"$GENERATION"[,}]*) WHY= ;;
+            *) WHY=local-mismatch ;;
+          esac
+        fi
+        if [ -z "$WHY" ] && [ -f "$FL_SEEN" ]; then
+          IFS= read -r SEEN < "$FL_SEEN" || true
+          case "$SEEN" in
+            ''|0*|*[!0-9]*) WHY=seen-unreadable ;;
+            *) if [ "${#SEEN}" -gt 15 ] || [ "$SEEN" -gt "$GENERATION" ]; then WHY=seen-newer-generation; fi ;;
+          esac
+        fi
+        if [ -z "$WHY" ]; then DECISION=run; WHY=fresh-holder; fi
+      fi
+    fi
+  ;; esac ;; esac ;; esac ;; esac ;; esac
+fi
+
+if [ "$DECISION" = run ]; then
+  export ELANOUS_HQ_GENERATION="$GENERATION"
+  "$TIMEOUT" -k 5 "$LIMIT" /bin/sh -c "$*"
+  rc=$?
+elif [ -n "$TIMEOUT" ] && [ -n "$LIMIT" ]; then
+  # Same installed CLI decision as the legacy wrapper, bounded by the role limit.
+  "$TIMEOUT" -k 5 "$LIMIT" "$BUN" "$ENTRY" --config-dir "$CONFIG_DIR" hq fence --role "$ROLE" -- /bin/sh -c "$*"
+  rc=$?
+else
+  # Unknown role (the CLI rejects it) or no watchdog binary: exactly the legacy command, unbounded.
+  if [ "$WHY" = no-watchdog ]; then log_line "fence watchdog unavailable (role=$ROLE) - CLI fence without time limit"; fi
+  "$BUN" "$ENTRY" --config-dir "$CONFIG_DIR" hq fence --role "$ROLE" -- /bin/sh -c "$*"
+  rc=$?
+fi
+
+TIMED_OUT=0
+if [ -n "$TIMEOUT" ] && [ -n "$LIMIT" ] && { [ "$rc" -eq 124 ] || [ "$rc" -eq 137 ]; }; then
+  TIMED_OUT=1
+  log_line "fence timeout role=$ROLE limit=${LIMIT}s rc=$rc decision=$DECISION reason=$WHY"
+  echo "hq-fence: timeout role=$ROLE limit=${LIMIT}s rc=$rc" >&2
+fi
+
+# LOOPCHECK-FENCE streak: the CLI records it on its own path; the fast path (and a CLI killed by the watchdog)
+# records through bun only when it matters — a failure, or a success that must reset a nonzero streak.
+if [ "$DECISION" = run ] || [ "$TIMED_OUT" = 1 ]; then
+  RECORD=0
+  if [ "$rc" -ne 0 ]; then RECORD=1
+  else
+    FL_OUTCOME="$CONFIG_DIR/hq/fence-outcomes/$ROLE.json"
+    if [ -f "$FL_OUTCOME" ]; then
+      OUTCOME_LINE=
+      IFS= read -r OUTCOME_LINE < "$FL_OUTCOME" || true
+      case "$OUTCOME_LINE" in '{"consecutiveFailures":0,'*) ;; *) RECORD=1 ;; esac
+    fi
+  fi
+  if [ "$RECORD" = 1 ]; then
+    "$TIMEOUT" -k 5 20 "$BUN" "$ENTRY" --config-dir "$CONFIG_DIR" hq fence-wrapper record "$ROLE" "$rc" \
+      || log_line "fence outcome record failed (role=$ROLE rc=$rc)"
+  fi
+fi
+
+if [ "$rc" -ne 0 ]; then
+  if [ -n "$TIMEOUT" ]; then
+    # Bounded: an unavailable owner channel must not strand a cron fence.
+    "$TIMEOUT" -k 5 20 "$BUN" "$ENTRY" --config-dir "$CONFIG_DIR" hq fence-wrapper alert "hq-fence: fence failed (rc=$rc, role=$ROLE)" \
+      || { echo "hq-fence: owner alert failed: fence failed (rc=$rc, role=$ROLE)" >&2; log_line "owner alert failed: fence failed (rc=$rc, role=$ROLE)"; }
+  else
+    alert "hq-fence: fence failed (rc=$rc, role=$ROLE)"
+  fi
+fi
+exit "$rc"

package/scripts/land-global-checks.ts

@@ -25,6 +25,9 @@ export const LAND_GLOBAL_CHECKS: readonly LandGlobalCheck[] = [
   { pattern: /^docs\/ops\/machines\.yaml$/, test: 'test/machines-ledger-data.test.ts', why: '기계 원장 데이터 ↔ 생성 Markdown(#24729)' },
   // 새 CLI 하위 명령은 `src/index.ts` 또는 `src/cli/` 의 등록 모듈에서 생긴다 — 입구 목록 시험(#24661).
   { pattern: /^src\/(?:index|cli\/(?:[^/]+\/)*[^/]+)(?<!\.test)\.ts$/, test: 'src/index.test.ts', why: 'CLI 입구·하위 명령 목록(#24661)' },
+  // src/cli/ 밖의 명령 등록 모듈(`*-cli.ts` · `*-cli-command.ts`)도 하위 명령을 더한다 — 10-11 #26232 가
+  //   src/harness/harness-cli-command.ts 에 `harness progress` 를 더해 index.test 목록 스냅샷을 깨고 main 을 붉혔다.
+  { pattern: /^src\/(?:[^/]+\/)+[^/]+-cli(?:-command)?(?<!\.test)\.ts$/, test: 'src/index.test.ts', why: 'src/cli 밖 명령 등록 모듈의 하위 명령 목록(10-11 #26232)' },
 ];
 
 /** 바뀐 파일 → 끌려오는 전역 시험(표 순서 · 중복 없음). */

package/scripts/lib/typecheck-ratchet.ts

@@ -0,0 +1,51 @@
+import { resolve } from 'node:path';
+import ts from 'typescript';
+
+/** Select root files affected by changed TypeScript files through the resolved reverse-import graph.
+ * Paths in rootNames are preserved for the compiler; changed paths may be relative to cwd.
+ * This is selection only: the caller owns project scope, hub policy and compiler execution.
+ */
+export function selectAffectedRootNames(
+  rootNames: readonly string[],
+  changedFiles: ReadonlySet<string>,
+  compilerOptions: ts.CompilerOptions,
+  host: ts.ModuleResolutionHost = ts.sys,
+  cwd = process.cwd(),
+): string[] {
+  const absolute = (file: string) => resolve(cwd, file);
+  const roots = new Set(rootNames.map(absolute));
+  const queue = [...changedFiles].filter((file) => /\.[cm]?tsx?$/.test(file)).map(absolute);
+  // No changed TypeScript file: nothing can be affected, so the dependency graph is never read.
+  if (queue.length === 0) return [];
+  const reverse = new Map<string, Set<string>>();
+  const pending = [...roots];
+  const visited = new Set<string>();
+
+  while (pending.length > 0) {
+    const file = pending.pop()!;
+    if (visited.has(file)) continue;
+    visited.add(file);
+    const source = host.readFile?.(file);
+    if (source === undefined) throw new Error(`Cannot read typecheck root dependency: ${file}`);
+    for (const imported of ts.preProcessFile(source, true, true).importedFiles) {
+      const dependency = ts.resolveModuleName(imported.fileName, file, compilerOptions, host).resolvedModule?.resolvedFileName;
+      if (!dependency) continue;
+      const path = absolute(dependency);
+      if (!reverse.has(path)) reverse.set(path, new Set());
+      reverse.get(path)!.add(file);
+      if (!visited.has(path)) pending.push(path);
+    }
+  }
+
+  // A deleted module cannot be resolved from the current tree. Without a previous
+  // dependency graph, an empty reverse edge is not evidence that no root imports it.
+  if (queue.some((file) => !host.fileExists(file))) return [...rootNames];
+  const affected = new Set<string>();
+  while (queue.length > 0) {
+    const file = queue.pop()!;
+    if (affected.has(file)) continue;
+    affected.add(file);
+    for (const importer of reverse.get(file) ?? []) queue.push(importer);
+  }
+  return rootNames.filter((file) => affected.has(absolute(file)));
+}

package/scripts/measure-log-diet-2.ts

@@ -0,0 +1,213 @@
+#!/usr/bin/env bun
+/**
+ * LOG-DIET-2 (0.2.24) — «같은 부하»에서 관측 «행 수»가 얼마나 줄었나를 재생(replay)으로 잰다.
+ *
+ * 왜 재생인가: 판정선은 «같은 부하에서 시간당 행 −60%»인데 72분 실물 런은 이 칸의 창에 들어가지
+ * 않는다. 그래서 칸 문면이 «측정값»으로 준 부하를 기록열로 재구성하고, 그 «같은» 기록열을
+ * 0.2.23 정책과 현재 정책 두 가드에 흘려 내보낸 행을 센다. 측정은 «정책 차이»이지 실물 재현이
+ * 아니다 — 이 한계를 출력에도 적는다.
+ *
+ * 실행: bun scripts/measure-log-diet-2.ts [--json]
+ * 계약: bun test scripts/measure-log-diet-2.test.ts
+ */
+import { LOG_DIET_KEYS, LogDietGuard } from '../src/debug/log-diet.js';
+import type { DebugEvent } from '../src/debug/log.js';
+
+/** 0.2.23 절식 정책 — A/B «기준선»으로 얼려 둔 사본(현재 `LOG_DIET_KEYS` 와 의도적으로 다르다). */
+export const LOG_DIET_KEYS_0_2_23: Readonly<Record<string, 'repeat' | 'consecutive'>> = {
+  'watchdog/activity': 'consecutive',
+  'user-config.llm/provider-resolved': 'repeat',
+  'hitl.card-bridge/skipped': 'repeat',
+  'input.cursor.claim/chat-main': 'repeat',
+  'tox.loop/waiting-capacity': 'repeat',
+  'tox.loop/tick': 'repeat',
+};
+
+/** 관측된 `log.diet/suppressed` 4,313행(72분) ≈ 초당 1회 flush — 그 주기를 기준선으로 쓴다. */
+export const REPLAY_FLUSH_EVERY_MS = 1_000;
+export const REPLAY_WINDOW_MS = 72 * 60_000;
+
+export type ReplayRecord = Pick<DebugEvent, 'category' | 'event' | 'data' | 'level'> & { atMs: number };
+
+export type LoadGroup = {
+  /** `category/event` */
+  key: string;
+  level?: DebugEvent['level'];
+  /** 창(72분) 동안 관측된 행 수 */
+  rows: number;
+  /** 서로 다른 payload 수 — 1 이면 전부 한 스트림으로 접힌다 */
+  distinctValues: number;
+  source: 'measured' | 'assumed';
+  note: string;
+};
+
+/** 판정 부하: 칸 문면이 수로 준 군 ⊕ 판정 경로(미등록 키) 0-손실 대조군. */
+export const LOG_DIET_2_LOAD: readonly LoadGroup[] = [
+  {
+    key: 'llm.credential/provider-key-missing', level: 'warn', rows: 5_207, distinctValues: 1,
+    source: 'measured', note: '칸 문면 측정값 — 72분 5,207행, 같은 (provider, source, context)',
+  },
+  {
+    key: 'log-diet.replay/judgment-path', rows: 300, distinctValues: 300,
+    source: 'assumed', note: '합성 대조군 — 미등록(판정 경로) 키는 100% 통과해야 한다',
+  },
+];
+
+export type ReplayResult = {
+  rowsIn: number;
+  /** 통과한 원본 행 + `log.diet/suppressed` 요약 행 */
+  rowsOut: number;
+  originalRows: number;
+  summaryRows: number;
+  /** 요약 행이 실어 나른 접힌 기록의 총수 — `originalRows + suppressedTotal === rowsIn` 이어야 한다 */
+  suppressedTotal: number;
+  judgmentRowsIn: number;
+  judgmentRowsOut: number;
+  judgmentLoss: number;
+  /** 1 − rowsOut/rowsIn */
+  reductionRatio: number;
+  /** 참고값 — 내보낸 행 중 `log.diet` 요약 행의 비중(0~1). 판정 ② «총/목록 밖 비»가 «아니다» — 그 비는 재생으로 못 잰다. */
+  summaryShare: number;
+};
+
+export function isJudgmentPath(rec: Pick<DebugEvent, 'category' | 'event'>): boolean {
+  return rec.category !== 'log.diet' && !LOG_DIET_KEYS[`${rec.category}/${rec.event}`];
+}
+
+/** 같은 기록열을 두 정책(기준선/현재)에 흘릴 수 있게 군을 시간순 기록열로 펼친다. */
+export function buildReplayRecords(
+  groups: readonly LoadGroup[],
+  windowMs = REPLAY_WINDOW_MS,
+): ReplayRecord[] {
+  const records: ReplayRecord[] = [];
+  for (const group of groups) {
+    const [category, event] = group.key.split('/');
+    if (!category || !event) throw new Error(`잘못된 부하 키: ${group.key}`);
+    const step = group.rows > 0 ? windowMs / group.rows : windowMs;
+    for (let i = 0; i < group.rows; i++) {
+      const seq = group.distinctValues > 1 ? i % group.distinctValues : 0;
+      records.push({
+        atMs: Math.round(i * step),
+        category,
+        event,
+        data: { key: group.key, seq },
+        ...(group.level ? { level: group.level } : {}),
+      });
+    }
+  }
+  return records.sort((a, b) => a.atMs - b.atMs);
+}
+
+export function replayDiet(
+  records: readonly ReplayRecord[],
+  makeGuard: (now: () => number) => LogDietGuard,
+  flushEveryMs = REPLAY_FLUSH_EVERY_MS,
+): ReplayResult {
+  let clock = 0;
+  const guard = makeGuard(() => clock);
+  let originalRows = 0;
+  let summaryRows = 0;
+  let suppressedTotal = 0;
+  let judgmentRowsIn = 0;
+  let judgmentRowsOut = 0;
+  let nextFlush = flushEveryMs;
+  for (const rec of records) {
+    while (nextFlush <= rec.atMs) {
+      clock = nextFlush;
+      const released = guard.flushPending();
+      summaryRows += released.length;
+      suppressedTotal += released.reduce((sum, s) => sum + s.count, 0);
+      nextFlush += flushEveryMs;
+    }
+    clock = rec.atMs;
+    const judgment = isJudgmentPath(rec);
+    if (judgment) judgmentRowsIn++;
+    const decision = guard.admit(rec);
+    if (decision.pass) {
+      originalRows++;
+      if (judgment) judgmentRowsOut++;
+    }
+    summaryRows += decision.summaries.length;
+    suppressedTotal += decision.summaries.reduce((sum, s) => sum + s.count, 0);
+  }
+  clock = (records.at(-1)?.atMs ?? 0) + flushEveryMs;
+  const drained = guard.drain();
+  summaryRows += drained.length;
+  suppressedTotal += drained.reduce((sum, s) => sum + s.count, 0);
+  const rowsOut = originalRows + summaryRows;
+  return {
+    rowsIn: records.length,
+    rowsOut,
+    originalRows,
+    summaryRows,
+    suppressedTotal,
+    judgmentRowsIn,
+    judgmentRowsOut,
+    judgmentLoss: judgmentRowsIn - judgmentRowsOut,
+    reductionRatio: records.length === 0 ? 0 : 1 - rowsOut / records.length,
+    summaryShare: rowsOut === 0 ? 0 : summaryRows / rowsOut,
+  };
+}
+
+export type Diet2Measurement = {
+  windowMinutes: number;
+  flushEveryMs: number;
+  records: number;
+  groups: readonly LoadGroup[];
+  /** 0.2.23 정책(기준선) */
+  before: ReplayResult;
+  /** 현재 정책(LOG-DIET-2) */
+  after: ReplayResult;
+  /** 1 − after.rowsOut / before.rowsOut — 판정선 −60% 가 무는 값 */
+  reduction: number;
+};
+
+export function measureLogDiet2(
+  groups: readonly LoadGroup[] = LOG_DIET_2_LOAD,
+  windowMs = REPLAY_WINDOW_MS,
+): Diet2Measurement {
+  const records = buildReplayRecords(groups, windowMs);
+  const before = replayDiet(records, now => new LogDietGuard({
+    now,
+    keys: LOG_DIET_KEYS_0_2_23,
+    summaryMinIntervalMs: 0,
+    summaryMaxPending: 1,
+  }));
+  const after = replayDiet(records, now => new LogDietGuard({ now }));
+  return {
+    windowMinutes: Math.round(windowMs / 60_000),
+    flushEveryMs: REPLAY_FLUSH_EVERY_MS,
+    records: records.length,
+    groups,
+    before,
+    after,
+    reduction: before.rowsOut === 0 ? 0 : 1 - after.rowsOut / before.rowsOut,
+  };
+}
+
+const pct = (ratio: number): string => `${(ratio * 100).toFixed(1)}%`;
+
+function report(m: Diet2Measurement): string {
+  const lines: string[] = [
+    `LOG-DIET-2 재생 측정 — 창 ${m.windowMinutes}분 · flush ${m.flushEveryMs}ms · 기록 ${m.records}행`,
+    '⚠ 정책 차이의 재생 측정이다(72분 실물 런 아님). 부하 군:',
+    ...m.groups.map(g => `   - ${g.key} ${g.rows}행/${g.distinctValues}값 [${g.source}] ${g.note}`),
+    '',
+    `기준선(0.2.23)  행 ${m.before.rowsOut} (원본 ${m.before.originalRows} + 요약 ${m.before.summaryRows} · 접힌 기록 ${m.before.suppressedTotal})`,
+    `현재(LOG-DIET-2) 행 ${m.after.rowsOut} (원본 ${m.after.originalRows} + 요약 ${m.after.summaryRows} · 접힌 기록 ${m.after.suppressedTotal})`,
+    `보존            : 원본+접힌 기록 = 입력  → ${m.after.originalRows}+${m.after.suppressedTotal}=${m.records}  ${m.after.originalRows + m.after.suppressedTotal === m.records ? 'PASS' : 'FAIL'}`,
+    '',
+    `판정 ① 같은 부하 시간당 행 −60%      : ${pct(m.reduction)} 감소  → ${m.reduction >= 0.6 ? 'PASS' : 'FAIL'}`,
+    `판정 ② 총/목록 밖 비 ≤ 1.03          : 재생으로 못 잰다(unmeasured · 실물 logs 목록 대비 필요) — 참고: 요약 행 비중 ${m.after.summaryShare.toFixed(3)}`,
+    `판정 ③ 판정 경로 이벤트 0 손실       : ${m.after.judgmentRowsOut}/${m.after.judgmentRowsIn} 통과 (손실 ${m.after.judgmentLoss})  → ${m.after.judgmentLoss === 0 ? 'PASS' : 'FAIL'}`,
+  ];
+  return lines.join('\n');
+}
+
+if (import.meta.main) {
+  const m = measureLogDiet2();
+  if (process.argv.includes('--json')) console.log(JSON.stringify(m, null, 2));
+  else console.log(report(m));
+  const ok = m.reduction >= 0.6 && m.after.judgmentLoss === 0; // 판정 ② 는 여기서 판정하지 않는다(unmeasured)
+  process.exit(ok ? 0 : 1);
+}