elanous 0.2.20 → 0.2.22

package/src/autopilot/pr-manager.ts

@@ -156,8 +156,8 @@ type MergeStateReading =
   | { status: 'not-merged'; state: string }
   | { status: 'unreadable' };
 
-function readPrMergeState(run: CmdRunner, prNumber: number): MergeStateReading {
-  const state = run('gh', ['pr', 'view', String(prNumber), '--json', 'state']);
+function readPrMergeState(run: CmdRunner, prNumber: number, cwd?: string): MergeStateReading {
+  const state = run('gh', ['pr', 'view', String(prNumber), '--json', 'state'], cwd ? { cwd } : undefined);
   if (!state.ok) return { status: 'unreadable' };
   try {
     const parsed = JSON.parse(state.out) as { state?: unknown };
@@ -189,7 +189,7 @@ export interface PrManager {
   /** PR squash 머지(+브랜치 삭제). 완료 리뷰 후 clean PR 반영. */
   mergePr(prUrl: string): boolean;
   /** 머지 exit 실패 시 GH 상태를 재조회한 구조화 판정. */
-  mergePrOutcome(prUrl: string): MergePrOutcome;
+  mergePrOutcome(prUrl: string, expectedHead?: string, cwd?: string): MergePrOutcome;
 }
 
 /** "이미 커밋된 산출이 있나"를 판정할 비교 base 를 해석한다(순수 아님 — run 주입).
@@ -553,11 +553,21 @@ export function makePrManager(runner: CmdRunner = defaultCmdRunner): PrManager {
     mergePr(prUrl) {
       return this.mergePrOutcome(prUrl).ok;
     },
-    mergePrOutcome(prUrl) {
+    mergePrOutcome(prUrl, expectedHead, cwd) {
       const n = extractPrNumber(prUrl);
       if (n === null) return { ok: false, kind: 'state-read-failed' };
+      if (expectedHead !== undefined) {
+        const pinned = run('gh', ['pr', 'view', String(n), '--json', 'headRefOid,state,isDraft'], cwd ? { cwd } : undefined);
+        try {
+          if (!pinned.ok) return { ok: false, kind: 'state-read-failed' };
+          const view = JSON.parse(pinned.out) as { headRefOid?: unknown; state?: unknown; isDraft?: unknown };
+          if (view.headRefOid !== expectedHead || view.state !== 'OPEN' || view.isDraft !== false) {
+            return { ok: false, kind: 'state-read-failed' };
+          }
+        } catch { return { ok: false, kind: 'state-read-failed' }; }
+      }
       const deleteRemoteHead = (kind: 'merge-exit-0' | 'merged-after-nonzero'): MergePrOutcome => {
-        const head = run('gh', ['pr', 'view', String(n), '--json', 'headRefName,headRepository']);
+        const head = run('gh', ['pr', 'view', String(n), '--json', 'headRefName,headRepository'], cwd ? { cwd } : undefined);
         if (!head.ok) return { ok: true, kind, remoteBranchDeletion: { detail: head.err || head.out || 'PR head branch 조회 실패' } };
         try {
           const { headRefName, headRepository } = JSON.parse(head.out) as {
@@ -568,7 +578,7 @@ export function makePrManager(runner: CmdRunner = defaultCmdRunner): PrManager {
           if (typeof headRefName !== 'string' || !headRefName || typeof repository !== 'string' || !repository) {
             return { ok: true, kind, remoteBranchDeletion: { detail: 'PR head branch 또는 저장소를 읽지 못했습니다' } };
           }
-          const deleted = run('gh', ['api', '--method', 'DELETE', `repos/${repository}/git/refs/heads/${encodeURIComponent(headRefName)}`]);
+          const deleted = run('gh', ['api', '--method', 'DELETE', `repos/${repository}/git/refs/heads/${encodeURIComponent(headRefName)}`], cwd ? { cwd } : undefined);
           return deleted.ok
             ? { ok: true, kind }
             : { ok: true, kind, remoteBranchDeletion: { detail: deleted.err || deleted.out || `원격 브랜치 ${headRefName} 삭제 실패` } };
@@ -576,13 +586,13 @@ export function makePrManager(runner: CmdRunner = defaultCmdRunner): PrManager {
           return { ok: true, kind, remoteBranchDeletion: { detail: 'PR head branch 응답을 읽지 못했습니다' } };
         }
       };
-      const merged = run('gh', ['pr', 'merge', String(n), '--squash']);
+      const merged = run('gh', ['pr', 'merge', String(n), '--squash', ...(expectedHead ? ['--match-head-commit', expectedHead] : [])], cwd ? { cwd } : undefined);
       if (merged.ok) return deleteRemoteHead('merge-exit-0');
       let lastNotMerged: string | undefined;
       let notMergedCount = 0;
       let sawUnreadable = false;
       for (let i = 0; i < MERGE_UNMERGED_CONFIRMATIONS; i++) {
-        const reading = readPrMergeState(run, n);
+        const reading = readPrMergeState(run, n, cwd);
         if (reading.status === 'merged') return deleteRemoteHead('merged-after-nonzero');
         if (reading.status === 'unreadable') {
           sawUnreadable = true;

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/browser-cdp/client.ts

@@ -7,11 +7,9 @@
 // `{id, method, params}` messages, receive `{id, result}` or
 // `{id, error}`.
 //
-// Scope kept narrow: navigate + screenshot + evaluate + close.
-// The MVP targets "open a page for the user to see + capture a
-// PNG" which covers the display-plus-screenshot flow the plan
-// describes. Full Puppeteer feature parity is explicitly out of
-// scope.
+// Scope kept narrow: navigation, capture, evaluation and CDP input.
+// Approval of mutating actions belongs to the caller, not this transport.
+// Full Puppeteer feature parity is explicitly out of scope.
 
 import { CHROME_NO_KEYCHAIN_FLAGS } from './chrome-flags.js';
 import { spawn, type ChildProcess } from 'node:child_process';
@@ -126,6 +124,8 @@ export interface CdpClient {
   setScriptExecutionDisabled(value: boolean): Promise<void>;
   /** Dispatch one primary-button click at viewport coordinates. */
   click?(coordinates: { x: number; y: number }): Promise<void>;
+  /** Insert text at the focused element (approval is the caller's responsibility). */
+  input?(text: string): Promise<void>;
   /** Dispose — closes Chrome + WebSocket. */
   close(): Promise<void>;
   readonly isAlive: boolean;
@@ -513,6 +513,11 @@ async function buildClientFromTransport(
       await runOnPage('Input.dispatchMouseEvent', { type: 'mousePressed', ...params });
       await runOnPage('Input.dispatchMouseEvent', { type: 'mouseReleased', ...params });
     },
+    async input(text) {
+      // Newlines can submit a form even without an Enter key event.
+      if (/[\r\n]/.test(text)) throw new Error('CDP input refuses newlines');
+      await runOnPage('Input.insertText', { text });
+    },
     async close() {
       if (!alive) return;
       alive = false;

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 바인드 주소')