elanous 0.2.21 → 0.2.22

package/src/away/release-watch.ts

@@ -1,5 +1,6 @@
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
+import { parse as parseYaml } from 'yaml';
 import { debug } from '../debug/log.js';
 import { deliver, inQuietHours, sendOutbound } from '../domains/outbound-alert.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
@@ -53,6 +54,39 @@ function endedNodes(run: ReleaseRunView): ReleaseRunNodeView[] {
   return run.nodes.filter((node) => node.ok !== null && !TERMINAL.has(node.nodeId));
 }
 
+/** 분모는 원장 path(지나온 자리)가 아니라 이 런에 확인된 그래프 선언의 전체 노드 수다. */
+function graphTotal(file: string, run: ReleaseRunView): number | undefined {
+  try {
+    const raw: unknown = parseYaml(readFileSync(file, 'utf8'));
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return undefined;
+    const graph = raw as Record<string, unknown>;
+    if (graph.graph_id !== 'release-loop' || !Array.isArray(graph.nodes) || !Array.isArray(graph.terminal_nodes)) return undefined;
+    const terminal = graph.terminal_nodes;
+    if (!terminal.length || !terminal.every((id): id is string => typeof id === 'string')) return undefined;
+    const ids = graph.nodes.map((node: unknown) => node && typeof node === 'object' && !Array.isArray(node)
+      ? (node as Record<string, unknown>).node_id : undefined);
+    if (!ids.length || !ids.every((id): id is string => typeof id === 'string') || new Set(ids).size !== ids.length
+      || !terminal.every((id) => ids.includes(id)) || !run.nodes.every((node) => ids.includes(node.nodeId))) return undefined;
+    // 분자(endedNodes)가 종결 자리표를 빼므로 분모도 뺀다 — 끝난 판이 «23/25» 로 영영 덜 끝나 보이지 않게.
+    return ids.filter((id) => !terminal.includes(id)).length;
+  } catch { return undefined; }
+}
+
+/**
+ * 이 런이 실제로 쓴 그래프 정의 — 그래프 실행기가 런마다 떠 두는 스냅샷 `<런>.json.graph/graph.yaml`.
+ * 없거나 runId 가 경로로 못 쓰는 모양이면 undefined(분모 생략) — 현재 선언 파일로 추측하지 않는다.
+ */
+export function releaseGraphFile(run: ReleaseRunView, root: string = effectiveInstanceRoot()): string | undefined {
+  if (!/^[A-Za-z0-9-]+$/.test(run.runId)) return undefined;
+  return join(root, 'graph-runs', 'release-loop', `${run.runId}.json.graph`, 'graph.yaml');
+}
+
+function completedCount(run: ReleaseRunView, graphFile?: string): string {
+  const ended = endedNodes(run).length;
+  const total = graphFile ? graphTotal(graphFile, run) : undefined;
+  return `끝난 노드 ${ended}${total !== undefined ? `/${total}` : ''}`;
+}
+
 function runningNode(run: ReleaseRunView): ReleaseRunNodeView | undefined {
   return run.status === 'running' ? run.nodes.find((node) => node.ok === null) : undefined;
 }
@@ -88,7 +122,7 @@ function blockedLine(run: ReleaseRunView): string {
 }
 
 /** 직전 표지와 지금 런을 견주어 보낼 줄을 만든다. 순수 함수 — 시험이 이것을 문다. */
-export function diffRun(prev: RunMark | undefined, run: ReleaseRunView, now: number): { lines: string[]; urgent: boolean; changed: boolean } {
+export function diffRun(prev: RunMark | undefined, run: ReleaseRunView, now: number, graphFile?: string): { lines: string[]; urgent: boolean; changed: boolean } {
   const ended = endedNodes(run);
   const running = runningNode(run);
   const lines: string[] = [];
@@ -97,11 +131,10 @@ export function diffRun(prev: RunMark | undefined, run: ReleaseRunView, now: num
     // 이미 끝난 판은 조용히 기준만 잡는다 — 외출을 켤 때 지난 판이 쏟아지지 않게.
     if (run.status === 'done') return { lines, urgent, changed: true };
     // 처음 보는 런 — 지난 노드를 다시 쏟지 않고 «지금 어디인가» 한 줄로 시작한다.
-    const total = run.path.filter((step) => !TERMINAL.has(step)).length || run.nodes.length;
     const where = run.status === 'running'
       ? `지금 ${running?.nodeId ?? '다음 노드 준비'}${running?.startedAt ? `(${minutesSince(running.startedAt, now)}분째)` : ''}`
       : `상태 ${run.status}`;
-    lines.push(`📦 ${label(run)} 발행 따라가기 시작 · 끝난 노드 ${ended.length}${total ? `/${total}` : ''} · ${where}`);
+    lines.push(`📦 ${label(run)} 발행 따라가기 시작 · ${completedCount(run, graphFile)} · ${where}`);
     if (BLOCKED.has(run.status)) { lines.push(blockedLine(run)); urgent = true; }
     return { lines, urgent, changed: true };
   }
@@ -129,7 +162,7 @@ export function diffRun(prev: RunMark | undefined, run: ReleaseRunView, now: num
   }
   if (!lines.length && run.status === 'running' && now - Date.parse(prev.sentAt) >= ALIVE_EVERY_MS) {
     const mins = minutesSince(running?.startedAt, now);
-    lines.push(`💓 ${label(run)} 발행 진행 중 · 지금 ${running?.nodeId ?? '다음 노드 준비'}${mins !== null ? `(${mins}분째)` : ''} · 끝난 노드 ${ended.length}/${run.path.filter((step) => !TERMINAL.has(step)).length || ended.length}`
+    lines.push(`💓 ${label(run)} 발행 진행 중 · 지금 ${running?.nodeId ?? '다음 노드 준비'}${mins !== null ? `(${mins}분째)` : ''} · ${completedCount(run, graphFile)}`
       + (run.gateShards ? `\n   ${shardsLine(run.gateShards.summary)}` : ''));
   }
   const changed = lines.length > 0 || prev.ended !== ended.length || prev.status !== run.status || prev.running !== running?.nodeId
@@ -182,6 +215,8 @@ export interface TickDeps {
   /** 막힘·실패 — 야간 무음을 뚫는다. */
   sendUrgent?: (text: string) => boolean;
   now?: () => number;
+  /** 이 런이 쓴 그래프 정의 파일 — 기본은 런 원장 옆 스냅샷(`releaseGraphFile`). */
+  graphFile?: (run: ReleaseRunView) => string | undefined;
 }
 
 export type TickOutcome =
@@ -228,7 +263,8 @@ export function releaseWatchTick(deps: TickDeps = {}): TickOutcome {
   let changed = false;
   for (const run of [...runs].reverse()) {
     const prev = state.runs[run.runId];
-    const diff = diffRun(prev, run, now);
+    const graphFile = (deps.graphFile ?? releaseGraphFile)(run);
+    const diff = diffRun(prev, run, now, graphFile);
     lines.push(...diff.lines);
     urgent ||= diff.urgent;
     changed ||= diff.changed;
@@ -248,14 +284,17 @@ export function releaseWatchTick(deps: TickDeps = {}): TickOutcome {
 }
 
 /** /release · away status 가 쓰는 «지금» 요약 — 가장 최근 런 하나. */
-export function releaseNowText(runs: ReleaseRunView[] | 'unavailable', now: number = Date.now()): string {
+export function releaseNowText(
+  runs: ReleaseRunView[] | 'unavailable',
+  now: number = Date.now(),
+  graphFileOf: (run: ReleaseRunView) => string | undefined = releaseGraphFile,
+): string {
   if (runs === 'unavailable') return '발행 런 원장을 못 읽었다(권한·디스크) — 「없다」가 아니다';
   const run = runs[0];
   if (!run) return `발행 런 기록 없음\n↗ ${RELEASE_SCREEN_URL}`;
   const ended = endedNodes(run);
   const running = runningNode(run);
-  const total = run.path.filter((step) => !TERMINAL.has(step)).length || run.nodes.length;
-  const head = `📦 ${label(run)} · ${run.status} · 끝난 노드 ${ended.length}${total ? `/${total}` : ''}`;
+  const head = `📦 ${label(run)} · ${run.status} · ${completedCount(run, graphFileOf(run))}`;
   const lines = [head];
   if (running) {
     const mins = minutesSince(running.startedAt, now);

package/src/briefing/brief-items.ts

@@ -9,6 +9,13 @@ import { readRequirementFunnel, type RequirementFunnelResult } from '../intake-p
 export const BRIEF_DOMAINS = ['운영', '판', '흡수', '시장', '행정', '코나투스'] as const;
 export const BRIEF_PRIORITIES = ['P0', 'P1', 'P2'] as const;
 export const BRIEF_SLOTS = ['08:30', 'after-release', '22:00'] as const;
+export const BRIEF_REACTIONS = ['열람', '버튼', '답장', '정정', '무시'] as const;
+
+export type BriefReaction = (typeof BRIEF_REACTIONS)[number];
+export interface BriefActionCount { acted: number; total: number; rate: number }
+export interface BriefWeeklyActions extends BriefActionCount {
+  byKind: Record<BriefDomain, BriefActionCount>;
+}
 
 export type BriefDomain = (typeof BRIEF_DOMAINS)[number];
 export type BriefPriority = (typeof BRIEF_PRIORITIES)[number];
@@ -36,6 +43,9 @@ export interface AddBriefItem {
   evidence?: string | null;
   source: string;
   createdAt?: string;
+  /** Optional normalized claim identity and time window for repeat observations. */
+  dedupeKey?: string;
+  dedupeWithinMs?: number;
 }
 
 export interface BriefItemsOptions {
@@ -98,8 +108,10 @@ export function composeBriefMarkdown(items: readonly BriefItem[], slot: BriefSlo
 export function composeBriefPage(items: readonly BriefItem[], slot: BriefSlot, now: Date): { markdown: string; ids: number[] } {
   const today = dateKey(now, { timeZone: KST });
   // A duplicate left out of a delivered page stays unsent in the ledger, but must not reappear on a later page.
+  // A new undeliverable observation after a sent page is a new occurrence, not an old duplicate.
   const deliveredClaims = new Set(items.filter(item => item.sent_at !== null).map(item => normalizeClaim(item.text)));
-  const eligible = items.filter(item => item.sent_at === null && beforeSlot(item.created_at, slot, now) && !deliveredClaims.has(normalizeClaim(item.text)));
+  const eligible = items.filter(item => item.sent_at === null && beforeSlot(item.created_at, slot, now)
+    && (item.source === 'outbound.undeliverable' || !deliveredClaims.has(normalizeClaim(item.text))));
   // Duplicate claims keep the copy that needs a decision today (P0 or due today), then the higher priority, then the earliest (ACP must-fix).
   const rank = (item: BriefItem) => [needsDecision(item, today) ? 0 : 1, BRIEF_PRIORITIES.indexOf(item.priority), item.id];
   const better = (a: BriefItem, b: BriefItem) => { const x = rank(a), y = rank(b); return x[0]! - y[0]! || x[1]! - y[1]! || x[2]! - y[2]!; };
@@ -210,7 +222,19 @@ export class BriefItemsLedger {
         item_id INTEGER NOT NULL REFERENCES items(id),
         slot TEXT NOT NULL,
         sent_at TEXT NOT NULL
-      );`);
+      );
+      CREATE TABLE IF NOT EXISTS reactions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        item_id INTEGER NOT NULL REFERENCES items(id),
+        reaction TEXT NOT NULL CHECK(reaction IN ('열람', '버튼', '답장', '정정', '무시')),
+        reacted_at TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS reactions_item_time ON reactions(item_id, reacted_at);
+      CREATE INDEX IF NOT EXISTS sends_time ON sends(sent_at);`);
+      if (!(db.query("SELECT name FROM pragma_table_info('items')").all() as { name: string }[]).some(column => column.name === 'dedupe_key')) {
+        db.exec('ALTER TABLE items ADD COLUMN dedupe_key TEXT');
+      }
+      db.exec('CREATE INDEX IF NOT EXISTS items_dedupe ON items(source, dedupe_key, created_at)');
       return work(db);
     } finally {
       db.close();
@@ -236,16 +260,85 @@ export class BriefItemsLedger {
     const evidence = optional(input.evidence, 'evidence');
     const createdAt = input.createdAt ?? this.now().toISOString();
     if (!Number.isFinite(Date.parse(createdAt))) throw new BriefItemsInputError('invalid createdAt');
-    const item = this.using(db => {
-      const result = db.query(
-        'INSERT INTO items (text, domain, priority, deadline, evidence, source, created_at, sent_at) VALUES (?, ?, ?, ?, ?, ?, ?, NULL)',
-      ).run(text, input.domain, input.priority, deadline, evidence, source, createdAt);
-      return db.query(
-        'SELECT id, text, domain, priority, deadline, evidence, source, created_at, (SELECT MIN(sent_at) FROM sends WHERE sends.item_id = items.id) AS sent_at FROM items WHERE id = ?',
-      ).get(result.lastInsertRowid) as BriefItem;
+    const dedupeKey = input.dedupeKey === undefined ? null : normalizeClaim(required(input.dedupeKey, 'dedupeKey'));
+    const windowMs = input.dedupeWithinMs;
+    if (windowMs !== undefined && (!Number.isFinite(windowMs) || windowMs <= 0 || dedupeKey === null)) {
+      throw new BriefItemsInputError('invalid dedupe window');
+    }
+    const selected = this.using(db => {
+      const select = 'SELECT id, text, domain, priority, deadline, evidence, source, created_at, (SELECT MIN(sent_at) FROM sends WHERE sends.item_id = items.id) AS sent_at FROM items WHERE id = ?';
+      db.exec('BEGIN IMMEDIATE');
+      try {
+        if (dedupeKey !== null && windowMs !== undefined) {
+          const existing = db.query(`SELECT id FROM items WHERE source = ? AND dedupe_key = ?
+            AND NOT EXISTS (SELECT 1 FROM sends WHERE sends.item_id = items.id)
+            AND julianday(created_at) >= julianday(?) - ? / 86400000.0
+            AND julianday(created_at) <= julianday(?) ORDER BY id DESC LIMIT 1`)
+            .get(source, dedupeKey, createdAt, windowMs, createdAt) as { id: number } | null;
+          if (existing) {
+            const item = db.query(select).get(existing.id) as BriefItem;
+            db.exec('COMMIT');
+            return { item, added: false };
+          }
+        }
+        const result = db.query(
+          'INSERT INTO items (text, domain, priority, deadline, evidence, source, created_at, sent_at, dedupe_key) VALUES (?, ?, ?, ?, ?, ?, ?, NULL, ?)',
+        ).run(text, input.domain, input.priority, deadline, evidence, source, createdAt, dedupeKey);
+        const item = db.query(select).get(result.lastInsertRowid) as BriefItem;
+        db.exec('COMMIT');
+        return { item, added: true };
+      } catch (cause) {
+        db.exec('ROLLBACK');
+        throw cause;
+      }
+    });
+    if (selected.added) this.log('briefing.items', 'added', { id: selected.item.id, domain: selected.item.domain, priority: selected.item.priority, source: selected.item.source });
+    return selected.item;
+  }
+
+  /** Append a reaction without changing the original item or its send history. */
+  recordReaction(itemId: number, reaction: BriefReaction): void {
+    if (!Number.isSafeInteger(itemId) || itemId < 1) throw new BriefItemsInputError('invalid item id');
+    if (!(BRIEF_REACTIONS as readonly string[]).includes(reaction)) throw new BriefItemsInputError('invalid reaction');
+    this.using(db => {
+      const at = this.now().toISOString();
+      if (!db.query('SELECT 1 FROM sends WHERE item_id = ? AND sent_at <= ? LIMIT 1').get(itemId, at)) {
+        throw new BriefItemsInputError('item was not sent');
+      }
+      db.query('INSERT INTO reactions (item_id, reaction, reacted_at) VALUES (?, ?, ?)')
+        .run(itemId, reaction, at);
+    });
+    this.log('briefing.items', 'reaction-recorded', { itemId, reaction });
+  }
+
+  /** KST Monday through now: distinct sent items acted on (button/reply/correction), grouped by domain. */
+  weeklyActions(): BriefWeeklyActions {
+    const now = this.now();
+    const today = dateKey(now, { timeZone: KST });
+    const day = new Date(`${today}T00:00:00Z`);
+    day.setUTCDate(day.getUTCDate() - ((day.getUTCDay() + 6) % 7));
+    const since = new Date(`${day.toISOString().slice(0, 10)}T00:00:00+09:00`).toISOString();
+    const until = now.toISOString();
+    return this.using(db => {
+      const rows = db.query(`SELECT items.domain AS kind,
+        COUNT(*) AS total,
+        SUM(CASE WHEN EXISTS (
+          SELECT 1 FROM reactions r WHERE r.item_id = items.id
+            AND r.reaction IN ('버튼', '답장', '정정') AND r.reacted_at >= ? AND r.reacted_at <= ?
+        ) THEN 1 ELSE 0 END) AS acted
+        FROM items WHERE EXISTS (
+          SELECT 1 FROM sends s WHERE s.item_id = items.id AND s.sent_at >= ? AND s.sent_at <= ?
+        ) GROUP BY items.domain`).all(since, until, since, until) as Array<{ kind: BriefDomain; total: number; acted: number }>;
+      const byKind = Object.fromEntries(BRIEF_DOMAINS.map(kind => [kind, { acted: 0, total: 0, rate: 0 }])) as Record<BriefDomain, BriefActionCount>;
+      let acted = 0;
+      let total = 0;
+      for (const row of rows) {
+        byKind[row.kind] = { acted: row.acted, total: row.total, rate: row.acted / row.total };
+        acted += row.acted;
+        total += row.total;
+      }
+      return { acted, total, rate: total === 0 ? 0 : acted / total, byKind };
     });
-    this.log('briefing.items', 'added', { id: item.id, domain: item.domain, priority: item.priority, source: item.source });
-    return item;
   }
 
   /** Insertion order. Optional domain filter. Item text is the stored original. */

package/src/chat/index.ts

@@ -466,6 +466,7 @@ export const SLASH_COMMANDS: SlashCommand[] = [
   { name: 'widget', aliases: ['widgets'], description: 'Manage widgets', subcommands: ['list', 'reload', 'instances'] },
   { name: 'log',   aliases: [],             description: 'Chat Log controls — size / clear / filter / search / freeze / solo / turn / fold / help', subcommands: ['size', 'clear', 'filter', 'search', 'freeze', 'solo', 'turn', 'fold', 'help'] },
   { name: 'loops', aliases: [], description: '루프와 크론 상태 표 — /loops [owner]' },
+  { name: 'board', aliases: [], description: '판 체크리스트 — /board [판]' },
   { name: 'memory', aliases: ['mem'], description: 'Memory ops — list / show / search / add / delete (see `elanous memory --help`)', subcommands: ['list', 'show', 'search', 'add', 'delete', 'index'] },
   { name: 'export', aliases: [], description: 'Export this conversation transcript to a markdown file — /export [path] (default ~/temp/elanous-transcript-<stamp>.md)' },
   { name: 'delta', aliases: ['diffs'], description: 'Source delta browser — open the latest turn-scoped file diff popup', subcommands: ['open', 'help'] },

package/src/cli/brief-cli.ts

@@ -1,5 +1,5 @@
 import type { Command } from 'commander';
-import { BRIEF_DOMAINS, BRIEF_PRIORITIES, BRIEF_SLOTS, BriefItemsInputError, BriefItemsLedger, type BriefDomain, type BriefPriority, type BriefSlot } from '../briefing/brief-items.js';
+import { BRIEF_DOMAINS, BRIEF_PRIORITIES, BRIEF_REACTIONS, BRIEF_SLOTS, BriefItemsInputError, BriefItemsLedger, type BriefDomain, type BriefPriority, type BriefReaction, type BriefSlot } from '../briefing/brief-items.js';
 import { kindRouteTarget } from '../domains/telegram-kind-route.js';
 import { sendTelegramReturningId } from '../autopilot/mission-notify.js';
 import { getUserConfig } from '../user-config.js';
@@ -24,7 +24,13 @@ export function registerBriefCommands(program: Command, deps: BriefCliDeps = {})
     error(`brief ${verb}: ${cause instanceof Error ? cause.message : String(cause)}`);
     process.exitCode = cause instanceof BriefItemsInputError ? 2 : 1;
   };
-  const brief = program.command('brief').description('대표 브리핑 항목 원장과 슬롯 발송');
+  const brief = program.command('brief').description('대표 브리핑 항목 원장과 슬롯 발송')
+    .action(() => {
+      try {
+        const { acted, total } = ledger().weeklyActions();
+        output(`이번 주 브리핑 중 대표가 움직인 것 ${acted}/${total}`);
+      } catch (cause) { fail('', cause); }
+    });
 
   brief.command('add')
     .description('주장 한 줄을 원장에 추가한다 (원문 그대로)')
@@ -51,6 +57,18 @@ export function registerBriefCommands(program: Command, deps: BriefCliDeps = {})
       } catch (cause) { fail('add', cause); }
     });
 
+  brief.command('react')
+    .description('발송된 브리핑 항목에 대한 대표 반응을 기록한다')
+    .requiredOption('--item-id <id>', '발송 항목 id')
+    .requiredOption('--reaction <reaction>', `반응 (${BRIEF_REACTIONS.join('|')})`)
+    .action((opts: { itemId: string; reaction: string }) => {
+      try {
+        const id = Number(opts.itemId);
+        ledger().recordReaction(id, opts.reaction as BriefReaction);
+        output(`reacted ${id} ${opts.reaction}`);
+      } catch (cause) { fail('react', cause); }
+    });
+
   brief.command('list')
     .description('원장 항목을 추가 순으로 본다')
     .option('--domain <domain>', `도메인 필터 (${BRIEF_DOMAINS.join('|')})`)

package/src/cli/config-classify.ts

@@ -0,0 +1,83 @@
+// CFG-CLASSIFY — 파일의 잎만 분류한다. 운영 config 변경·시험 우주 동기화 없음.
+import { isAbsolute } from 'node:path';
+import { isDeepStrictEqual } from 'node:util';
+import { flattenConfig, isSecretPath, isSecretValue, MASK } from './config-drift.js';
+
+export type ConfigClass = 'secret' | 'product-default' | 'machine-fact' | 'operational';
+export interface ClassifiedConfigLeaf {
+  key: string;
+  class: ConfigClass;
+  rule: string;
+  overridesDefault: boolean;
+}
+
+export interface ConfigClassifyReport {
+  totalLeaves: number;
+  overridesDefault: number;
+  counts: Record<ConfigClass, number>;
+  leaves: ClassifiedConfigLeaf[];
+}
+
+interface RuleInput {
+  key: string;
+  value: unknown;
+  matchesDefault: boolean;
+}
+
+// 순서가 우선순위다. 비밀은 기본값·경로보다 먼저, 기본값 복사는 기계 사실보다 먼저 판정한다.
+export const CLASSIFY_RULES: ReadonlyArray<{
+  class: ConfigClass;
+  rule: string;
+  matches: (input: RuleInput) => boolean;
+}> = [
+  { class: 'secret', rule: '비밀 경로 또는 비밀 값', matches: ({ key, value }) => isSecretPath(key) || isSecretValue(value) },
+  { class: 'product-default', rule: '코드 기본값 복사', matches: ({ matchesDefault }) => matchesDefault },
+  {
+    class: 'machine-fact', rule: '기계 경로·주소·포트',
+    matches: ({ key, value }) => key.split('.').some((part) => /(?:^|[_-])(?:paths?|dirs?|directories|roots?|ports?|hosts?|urls?|bins?|sockets?|cwd)(?:$|[_-])/i.test(part)
+      || /(?:Path|Dir|Directory|Root|Port|Host|URL|Url|Bin|Socket|Cwd)$/.test(part))
+      || (typeof value === 'string' && (isAbsolute(value) || /^[a-z][a-z0-9+.-]*:\/\//i.test(value))),
+  },
+  { class: 'operational', rule: '나머지 운영 정책·상태', matches: () => true },
+];
+
+/** raw 파일의 잎 수를 분모로 한다. 기본값에 키가 없으면 (값이 undefined 여도) 덮어쓰기다. */
+export function classifyConfig(raw: Record<string, unknown>, codeDefaults: Record<string, unknown>): ConfigClassifyReport {
+  const defaults = flattenConfig(codeDefaults);
+  const leaves = [...flattenConfig(raw)].sort(([a], [b]) => a.localeCompare(b)).map(([key, value]) => {
+    const matchesDefault = defaults.has(key) && isDeepStrictEqual(value, defaults.get(key));
+    const rule = CLASSIFY_RULES.find((candidate) => candidate.matches({ key, value, matchesDefault }))!;
+    return { key, class: rule.class, rule: rule.rule, overridesDefault: !matchesDefault };
+  });
+  const counts: ConfigClassifyReport['counts'] = {
+    secret: 0, 'product-default': 0, 'machine-fact': 0, operational: 0,
+  };
+  for (const leaf of leaves) counts[leaf.class]++;
+  return {
+    totalLeaves: leaves.length,
+    overridesDefault: leaves.filter((leaf) => leaf.overridesDefault).length,
+    counts, leaves,
+  };
+}
+
+export function renderClassify(report: ConfigClassifyReport): string {
+  const labels: Record<ConfigClass, string> = {
+    secret: '③ 비밀', 'product-default': '① 제품 기본값',
+    'machine-fact': '② 기계 사실', operational: '④ 운영 정책·상태',
+  };
+  const lines = [`config classify — 잎 ${report.totalLeaves} · 운영 덮어쓰기 ${report.overridesDefault}`];
+  for (const { class: kind } of CLASSIFY_RULES) {
+    const leaves = report.leaves.filter((leaf) => leaf.class === kind);
+    lines.push(`  ${labels[kind]} ${report.counts[kind]}`);
+    const topKeys = new Map<string, number>();
+    for (const leaf of leaves) {
+      const top = leaf.key.split('.')[0]!;
+      topKeys.set(top, (topKeys.get(top) ?? 0) + 1);
+    }
+    const leaders = [...topKeys].sort(([a, ac], [b, bc]) => bc - ac || a.localeCompare(b)).slice(0, 10);
+    if (leaders.length) lines.push(`    상위 키: ${leaders.map(([key, count]) => `${key} × ${count}`).join(' · ')}`);
+    for (const leaf of leaves.slice(0, 10)) lines.push(`    ${leaf.key}${kind === 'secret' ? ` = ${MASK}` : ''}`);
+    if (leaves.length > 10) lines.push(`    … ${leaves.length - 10}개 더 (--json)`);
+  }
+  return lines.join('\n');
+}

package/src/cli/control-cli.ts

@@ -13,6 +13,7 @@ import { RESOURCE_KINDS, type ResourceKind } from '../control-plane/ledger.js';
 import { runControlJoin, type ControlJoinOptions } from './control-join-cli.js';
 import type { ResourceView } from '../control-plane/ledger.js';
 import { issueMemberToken, revokeMemberToken, listMemberTokens } from '../control-plane/member-tokens.js';
+import { collectControlStatus } from '../control/control-status.js';
 
 function controlPort(flag?: string): number {
   const raw = flag ?? (process.env.ELANOUS_CONTROL_PORT?.trim() || undefined);
@@ -152,6 +153,19 @@ export async function runControlMember(options: { resource?: string[]; interval?
 
 export function registerControlCommands(program: Command): void {
   const control = program.command('control').description('독립 관제부');
+  control.command('status').description('집 하나의 읽기 전용 관제 현황')
+    .option('--json', '일곱 줄을 JSON으로 출력')
+    .action(async (options: { json?: boolean }) => {
+      const rows = await collectControlStatus();
+      if (options.json) console.log(JSON.stringify({ rows }));
+      else for (const { row, state, text, reason } of rows) {
+        const label = state === 'ok' ? '정상' : state === 'warn' ? '주의' : '못 쟀다';
+        console.log(`${row} · ${label} · ${text}${reason ? ` — ${reason}` : ''}`
+          .replace(/\r/g, '\\r').replace(/\n/g, '\\n')
+          // Other C0/C1 controls (ESC, backspace, ...) and line separators must not repaint the terminal table.
+          .replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029]/g, (ch) => `\\u${ch.charCodeAt(0).toString(16).padStart(4, '0')}`));
+      }
+    });
   control.command('serve').description('관제부를 포그라운드에서 실행')
     .option('--port <n>', '리스닝 포트(0=임시 포트)')
     .option('--host <addr>', '루프백 또는 tailnet 바인드 주소')

package/src/cli/decisions-cli.ts

@@ -11,6 +11,7 @@ import { getUserConfig } from '../user-config.js';
 import { projectDecisionsToLinear } from '../decisions/decision-linear-projection.js';
 import { DecisionLedger, importDecisionMarkdown, type DecisionCategory, type DecisionLedgerOptions, type DecisionOption, type DecisionTrack, type DecisionEntry, type Seat, type SeatDecisionRecord } from '../decisions/decision-ledger.js';
 import { formatProactMeter, readProactMeter } from '../decisions/proact-meter.js';
+import { writeStdoutFully } from './stdout-flush.js';
 
 const repeat = (value: string, values: string[]) => [...values, value];
 function date(raw?: string): string | undefined {
@@ -75,14 +76,24 @@ export function registerDecisionsCommands(program: Command, config: DecisionLedg
     return hqCliWriteAllowed(`decisions ${command}`, Boolean(override || root.opts().hqOverride),
       (getElanousConfigDirOverride() || config.stateDir) && !hqDeps.store && !getUserConfig().hq?.arbiter ? { ...hqDeps, store: fileLeaseStore(join(config.stateDir ?? effectiveInstanceRoot(), 'hq', 'lease.json')), seenPath: join(config.stateDir ?? effectiveInstanceRoot(), 'hq', 'seen-generation'), localPath: join(config.stateDir ?? effectiveInstanceRoot(), 'hq', 'local.json') } : hqDeps);
   };
-  const emit = (value: unknown, json?: boolean, text?: string) => out.log(json ? JSON.stringify(value) : text ?? JSON.stringify(value));
-  const fail = (action: () => void) => { try { action(); } catch (e) { throw new Error(`decisions: ${e instanceof Error ? e.message : String(e)}`); } };
+  const emit = (value: unknown, json?: boolean, text?: string): void | Promise<void> => {
+    const line = json ? JSON.stringify(value) : text ?? JSON.stringify(value);
+    if (json && out === console) return writeStdoutFully(line);
+    out.log(line);
+  };
+  const fail = (action: () => void | Promise<void>): void | Promise<void> => {
+    const wrap = (e: unknown) => new Error(`decisions: ${e instanceof Error ? e.message : String(e)}`);
+    try {
+      const result = action();
+      return result instanceof Promise ? result.catch(e => { throw wrap(e); }) : result;
+    } catch (e) { throw wrap(e); }
+  };
   root.command('linear-sync').description('열린 결정을 COO Linear 프로젝트에 투영하고 닫힌 결정을 동기화한다')
     .option('--dry-run').option('--json').option('--hq-override')
     .action(async (o: { dryRun?: boolean; json?: boolean; hqOverride?: boolean }) => {
       if (!o.dryRun && !mayWrite('linear-sync', o.hqOverride)) return;
       const result = await projectDecisionsToLinear({ stateDir: config.stateDir, dryRun: o.dryRun });
-      emit(result, o.json, result.reason ?? `생성 ${result.created} · 닫음 ${result.closed} · 건너뜀 ${result.skipped} · 실패 ${result.failed}${result.plan?.length ? `\n${result.plan.map(p => `${p.action} ${p.decisionId}${p.issue ? ` ${p.issue}` : ''}`).join('\n')}` : ''}`);
+      await emit(result, o.json, result.reason ?? `생성 ${result.created} · 닫음 ${result.closed} · 건너뜀 ${result.skipped} · 실패 ${result.failed}${result.plan?.length ? `\n${result.plan.map(p => `${p.action} ${p.decisionId}${p.issue ? ` ${p.issue}` : ''}`).join('\n')}` : ''}`);
     });
   root.command('raise').description('SCQA·선택지와 권고로 결정 항목을 올린다')
     .requiredOption('--title <text>').requiredOption('--category <category>')
@@ -121,7 +132,7 @@ export function registerDecisionsCommands(program: Command, config: DecisionLedg
         ...(o.resumeQuestion !== undefined ? { resume: { questionId: o.resumeQuestion, ...(o.run !== undefined ? { runId: o.run } : {}) } } : {}),
         ...(o.due ? { dueAt: dueAt(o.due) } : {}) });
       if (entry.crossCheckSkipped === 'missing') console.error('교차 확인 없음 — --xcheck SEAT:메모 또는 --no-xcheck 이유');
-      emit(entry, o.json, `올림: ${formatDecisionRow(entry)}`);
+      return emit(entry, o.json, `올림: ${formatDecisionRow(entry)}`);
     }));
   root.command('record-seat').description('위임 범위에서 이미 내린 자리 결정을 사후 보고로 원장에 기록 (대표 카드 아님)')
     .requiredOption('--seat <OP|MK|TC|UX>').requiredOption('--title <text>')
@@ -133,13 +144,13 @@ export function registerDecisionsCommands(program: Command, config: DecisionLedg
       if (!mayWrite('record-seat', o.hqOverride)) return;
       const entry = new DecisionLedger(config).recordSeatDecision({ seat: o.seat, title: o.title, decision: o.decision,
         delegation: o.delegation, ...(o.at ? { decidedAt: o.at } : {}), ...(o.ref.length ? { refs: o.ref } : {}) });
-      emit(entry, o.json, formatSeatDecisionRow(entry));
+      return emit(entry, o.json, formatSeatDecisionRow(entry));
     }));
   root.command('seat-report').description('밤사이 자리들의 사후 결정을 한 번에 조회 (기본 최근 24시간)')
     .option('--since <date>', '조회 시작 UTC ISO 또는 Nd', '1d').option('--seat <OP|MK|TC|UX>').option('--json')
     .action((o: { since: string; seat?: Seat; json?: boolean }) => fail(() => {
       const rows = new DecisionLedger(config).seatReport({ since: date(o.since), seat: o.seat });
-      emit(rows, o.json, rows.length ? rows.map(formatSeatDecisionRow).join('\n') : '자리 결정 0건');
+      return emit(rows, o.json, rows.length ? rows.map(formatSeatDecisionRow).join('\n') : '자리 결정 0건');
     }));
   root.command('proact').description('선제성 기준선 — 지난 7일, 먼저 낸 수·채택 수·물어서야 드러난 수')
     .option('--days <n>', 'KST 일수 (기본 7)', '7').option('--json')
@@ -147,17 +158,17 @@ export function registerDecisionsCommands(program: Command, config: DecisionLedg
       const days = Number(o.days);
       if (!Number.isInteger(days) || days < 1) throw new Error('invalid days');
       const meter = readProactMeter({ ...(config.stateDir ? { stateDir: config.stateDir, instanceRoot: config.stateDir } : {}), ...(config.now ? { now: config.now() } : {}), days });
-      emit(meter, o.json, formatProactMeter(meter));
+      return emit(meter, o.json, formatProactMeter(meter));
     }));
   root.command('list').description('결정 목록 (기본 열린 것)')
     .option('--status <open|decided|all>', '기본 open', 'open').option('--since <date>').option('--version <version>')
     .option('--decided-by <human|auto>').option('--category <category>').option('--json')
     .action((o: { status: 'open' | 'decided' | 'all'; since?: string; version?: string; decidedBy?: 'human' | 'auto'; category?: DecisionCategory; json?: boolean }) => fail(() => {
       const rows = new DecisionLedger(config).list({ status: o.status, since: date(o.since), version: o.version, decidedBy: o.decidedBy, category: o.category });
-      emit(rows, o.json, rows.length ? rows.map(formatDecisionRow).join('\n') : '결정 0건');
+      return emit(rows, o.json, rows.length ? rows.map(formatDecisionRow).join('\n') : '결정 0건');
     }));
   root.command('show <id>').description('SCQA · 선택지 · 권고 · 이력 · 판').option('--json')
-    .action((id: string, o: { json?: boolean }) => fail(() => { const entry = new DecisionLedger(config).show(id); emit(entry, o.json, formatDecisionDetail(entry)); }));
+    .action((id: string, o: { json?: boolean }) => fail(() => { const entry = new DecisionLedger(config).show(id); return emit(entry, o.json, formatDecisionDetail(entry)); }));
   root.command('decide <id> <option>').description('사람 또는 AUTO 위임 결정 기록')
     .option('--note <text>').option('--auto').option('--delegation <reason>').option('--track <track>').option('--agent <agent>').option('--json').option('--hq-override')
     .action((id: string, choice: string, o: { note?: string; auto?: boolean; delegation?: string; track?: DecisionTrack; agent?: string; json?: boolean; hqOverride?: boolean }) => fail(() => {
@@ -169,17 +180,16 @@ export function registerDecisionsCommands(program: Command, config: DecisionLedg
       if (delivery && !delivery.ok) {
         // The decision is recorded; only the answer to the waiting run failed — say so and how to retry, never «success».
         const hint = `⚠ 답 전달 실패(${delivery.questionId} · ${delivery.reason}) — 결정은 기록됐다 · 다시: elanous decisions retry-answer ${entry.id}`;
-        emit({ ...entry, delivery }, o.json, `결정: ${formatDecisionDetail(entry)}\n${hint}`);
         process.exitCode = 3;
-        return;
+        return emit({ ...entry, delivery }, o.json, `결정: ${formatDecisionDetail(entry)}\n${hint}`);
       }
-      emit(delivery ? { ...entry, delivery } : entry, o.json, `결정: ${formatDecisionDetail(entry)}`);
+      return emit(delivery ? { ...entry, delivery } : entry, o.json, `결정: ${formatDecisionDetail(entry)}`);
     }));
   root.command('retry-answer <id>').description('기록된 결정의 대기 질문 답 전달만 재시도한다').option('--json').option('--hq-override')
     .action((id: string, o: { json?: boolean; hqOverride?: boolean }) => fail(() => {
       if (!mayWrite('retry-answer', o.hqOverride)) return;
       const entry = new DecisionLedger(config).retryAnswer(id);
-      emit(entry, o.json, `답 전달: ${entry.id} → ${entry.resume?.questionId}`);
+      return emit(entry, o.json, `답 전달: ${entry.id} → ${entry.resume?.questionId}`);
     }));
   root.command('add-options <id>').description('선택지가 미기재된 과거 항목에 확인된 선택지를 추가')
     .requiredOption('--option <key=label:consequence>', '선택지 (두 번 이상)', repeat, [] as string[])
@@ -188,15 +198,15 @@ export function registerDecisionsCommands(program: Command, config: DecisionLedg
       const who = agent(o.agent);
       if (!mayWrite('add-options', o.hqOverride)) return;
       const entry = new DecisionLedger(config).addOptions(id, o.option.map(parseOption), who);
-      emit(entry, o.json, formatDecisionDetail(entry));
+      return emit(entry, o.json, formatDecisionDetail(entry));
     }));
   root.command('withdraw <id>').description('결정 철회도 원장에 남긴다').requiredOption('--reason <reason>').option('--json').option('--hq-override')
-    .action((id: string, o: { reason: string; json?: boolean; hqOverride?: boolean }) => fail(() => { if (!mayWrite('withdraw', o.hqOverride)) return; const entry = new DecisionLedger(config).withdraw(id, o.reason); emit(entry, o.json, `철회: ${formatDecisionDetail(entry)}`); }));
+    .action((id: string, o: { reason: string; json?: boolean; hqOverride?: boolean }) => fail(() => { if (!mayWrite('withdraw', o.hqOverride)) return; const entry = new DecisionLedger(config).withdraw(id, o.reason); return emit(entry, o.json, `철회: ${formatDecisionDetail(entry)}`); }));
   root.command('import-markdown <file>').description('기존 대표 결정 문서 씨앗을 가져온다 (재실행 안전)').option('--json').option('--hq-override')
     .action((file: string, o: { json?: boolean; hqOverride?: boolean }) => fail(() => {
       if (!mayWrite('import-markdown', o.hqOverride)) return;
       const result = importDecisionMarkdown(new DecisionLedger(config), file);
-      emit(result, o.json, `가져옴 ${result.imported.length} · 기존 ${result.existing.length} · 불완전 ${result.incomplete.length} · 못 읽음 ${result.unread.length}${result.incomplete.length ? `\n${result.incomplete.join('\n')}` : ''}${result.unread.length ? `\n${result.unread.join('\n')}` : ''}`);
       if (result.unread.length) process.exitCode = 1;
+      return emit(result, o.json, `가져옴 ${result.imported.length} · 기존 ${result.existing.length} · 불완전 ${result.incomplete.length} · 못 읽음 ${result.unread.length}${result.incomplete.length ? `\n${result.incomplete.join('\n')}` : ''}${result.unread.length ? `\n${result.unread.join('\n')}` : ''}`);
     }));
 }

package/src/cli/logs-model-input.ts

@@ -79,7 +79,7 @@ export function renderModelInput(report: ModelInputReport): string {
     `model input tokens · ${report.since} ~ ${report.until} · stores=${report.stores.join(', ') || '(없음)'} · records=${report.records}`,
     'scope\tnodeKind\tmeasured\tmedian\tp90\t못 잼',
     ...(report.baselines.length === 0 ? ['(관측 표본 없음)'] : report.baselines.map((item) =>
-      `${item.scope}\t${item.nodeKind}\t${item.measured}\t${item.median ?? '—'}\t${item.p90 ?? '—'}\t${item.unmeasured}`)),
+      `${item.scope}\t${item.nodeKind}\t${item.measured}\t${item.median ?? '못 잼'}\t${item.p90 ?? '못 잼'}\t${item.unmeasured}`)),
   ].join('\n');
 }