elanous 0.2.21 → 0.2.23

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 주입).
@@ -209,8 +209,16 @@ export function resolveDeliverableBase(
   explicit?: string,
 ): string | undefined {
   const e = explicit?.trim();
-  if (e) return e;
   const opts = { cwd };
+  if (e) {
+    if (e.startsWith('origin/') || run('git', ['-C', cwd, 'rev-parse', '--verify', '--quiet', e], opts).ok) return e;
+    const resolved = `origin/${e}`;
+    if (run('git', ['-C', cwd, 'rev-parse', '--verify', '--quiet', resolved], opts).ok) {
+      debug.log('autopilot.pr-manager', 'base-resolved-remote', { explicit: e, resolved });
+      return resolved;
+    }
+    return e;
+  }
   const head = run('git', ['-C', cwd, 'rev-parse', '--abbrev-ref', 'origin/HEAD'], opts);
   const headRef = head.ok ? head.out.trim() : '';
   // `origin/HEAD` 미설정 리포는 "origin/HEAD" 를 그대로 되돌려주기도 한다 → 해소 실패로 취급.
@@ -359,8 +367,9 @@ export function makePrManager(runner: CmdRunner = defaultCmdRunner): PrManager {
       //   (node_modules·apps/pwa/out 심링크)를 이미 자동 skip 하는데, `:(exclude)<ignored>` 로 명시 지목하면
       //   git 이 "paths ignored by .gitignore … use -f" 로 exit 1 을 뱉는다(staging 은 성공하지만 exit≠0).
       //   그간 이게 add 실패로 오판돼 makePr null→pr-failed→budget 오힐 교착. gitignore 안 된 것만 exclude.
-      // ★ 최초 base 해석을 일반 경로의 판정과 PR 생성에 그대로 공유한다. self-base 인수 발사만
-      //   `branch..HEAD`의 구조적 0을 피하려 upstream 비교 ref와 기본 PR base를 추가 해석한다.
+      // ★ 최초 base 해석을 일반 경로의 판정과 PR 생성에 그대로 공유한다. 명시 base가 원격 추적으로만
+      //   존재하면 여기서 해석한 ref로 rev-list·diff를 비교하고 PR 생성에는 브랜치명만 전달한다.
+      //   self-base 인수 발사만 `branch..HEAD`의 구조적 0을 피하려 upstream 비교 ref와 기본 PR base를 추가 해석한다.
       const resolvedBase = resolveDeliverableBase(run, cwd, input.base);
       const selfBase = Boolean(resolvedBase && isBranchSelfRef(resolvedBase, input.branch));
       let comparisonBase = resolvedBase;
@@ -553,11 +562,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 +587,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 +595,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/boot/acp-server.ts

@@ -25,8 +25,8 @@
 // test.
 
 import { mkdirSync } from 'node:fs';
-import { getElanousConfigDir } from '../elanous-config-dir.js';
-import { dirname, join as joinPath } from 'node:path';
+import { defaultUnixSocketPath } from './acp-socket-path.js';
+import { dirname } from 'node:path';
 import { ensureAuthToken } from '../auth/acp-token.js';
 
 import {
@@ -38,6 +38,8 @@ import { runAcpServer, type AcpServerOptions } from '../acp/server.js';
 import type { LlmBrand } from '../llm-vision-capability.js';
 import { DEFAULT_NEXUS_HTTP_PORT } from '../nexus/default-port.js';
 
+export { defaultUnixSocketPath } from './acp-socket-path.js';
+
 export type AcpBootTransport = 'stdio' | 'unix-socket' | 'websocket';
 
 export interface AcpBootOptions {
@@ -56,11 +58,6 @@ export interface AcpBootOptions {
   toolCwd?: string;
 }
 
-/** Default socket path — XDG-ish; `~/.elanous/elanous.sock`. */
-export function defaultUnixSocketPath(): string {
-  return joinPath(getElanousConfigDir(), 'elanous.sock');
-}
-
 /** Default websocket bind port. Mnemonic: π × 10⁴. */
 export const DEFAULT_WEBSOCKET_PORT = DEFAULT_NEXUS_HTTP_PORT;
 

package/src/boot/acp-socket-path.ts

@@ -0,0 +1,7 @@
+import { join as joinPath } from 'node:path';
+import { getElanousConfigDir } from '../elanous-config-dir.js';
+
+/** Default socket path — XDG-ish; `~/.elanous/elanous.sock`. */
+export function defaultUnixSocketPath(): string {
+  return joinPath(getElanousConfigDir(), 'elanous.sock');
+}

package/src/briefing/brief-items.ts

@@ -9,10 +9,18 @@ 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];
 export type BriefSlot = (typeof BRIEF_SLOTS)[number];
+export type BriefSendSlot = BriefSlot | 'realtime';
 
 const KST = 'Asia/Seoul';
 
@@ -36,6 +44,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 {
@@ -85,6 +96,12 @@ function needsDecision(item: BriefItem, today: string): boolean {
   return item.priority === 'P0' || (item.deadline !== null && deadlineDate(item.deadline) === today);
 }
 
+/** Unsent decisions needing immediate delivery, using the same KST deadline rule as slot pages. */
+export function pendingRealtime(items: readonly BriefItem[], now: Date): BriefItem[] {
+  const today = dateKey(now, { timeZone: KST });
+  return items.filter(item => item.sent_at === null && needsDecision(item, today));
+}
+
 /**
  * One briefing page. Item text is copied verbatim.
  * Order: decisions due (P0, then a deadline of today) → domain groups →
@@ -95,11 +112,13 @@ export function composeBriefMarkdown(items: readonly BriefItem[], slot: BriefSlo
 }
 
 /** The ids are exactly the rows represented by the composed page, after deduplication. */
-export function composeBriefPage(items: readonly BriefItem[], slot: BriefSlot, now: Date): { markdown: string; ids: number[] } {
+export function composeBriefPage(items: readonly BriefItem[], slot: BriefSendSlot, 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 candidates = slot === 'realtime' ? pendingRealtime(items, now) : items.filter(item => item.sent_at === null && beforeSlot(item.created_at, slot, now));
+  const eligible = candidates.filter(item => 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 +229,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 +267,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. */
@@ -261,6 +361,7 @@ export class BriefItemsLedger {
    * requirement funnel contributes ephemeral lines without adding ledger rows.
    */
   compose(slot: string): string {
+    if (!(BRIEF_SLOTS as readonly string[]).includes(slot)) throw new BriefItemsInputError('invalid slot');
     return this.composeWithIds(slot).markdown;
   }
 
@@ -268,7 +369,7 @@ export class BriefItemsLedger {
     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 ORDER BY id').all() as BriefItem[];
   }
 
-  private pageFromDb(db: Database, slot: BriefSlot): { markdown: string; ids: number[] } {
+  private pageFromDb(db: Database, slot: BriefSendSlot): { markdown: string; ids: number[] } {
     const items = this.itemsFromDb(db);
     const now = this.now();
     const morningCutoff = Date.parse(`${dateKey(now, { timeZone: KST })}T08:30:00+09:00`);
@@ -290,26 +391,26 @@ export class BriefItemsLedger {
     const composed = composeBriefPage([...items, ...funnelItems], slot, now);
     // Ephemeral funnel lines appear on the page but have no ledger row to mark sent.
     const page = { markdown: composed.markdown, ids: composed.ids.filter(id => id > 0) };
-    const candidates = items.filter(item => item.sent_at === null && beforeSlot(item.created_at, slot, now)).length;
+    const candidates = (slot === 'realtime' ? pendingRealtime(items, now) : items.filter(item => item.sent_at === null && beforeSlot(item.created_at, slot, now))).length;
     this.log('briefing.items', 'composed', { slot, candidates, bytes: Buffer.byteLength(page.markdown) });
     return page;
   }
 
   /** Read-only page and the exact ledger item ids printed on it (after deduplication). */
   composeWithIds(slot: string): { markdown: string; ids: number[] } {
-    if (!(BRIEF_SLOTS as readonly string[]).includes(slot)) throw new BriefItemsInputError('invalid slot');
-    return this.using(db => this.pageFromDb(db, slot as BriefSlot));
+    if (slot !== 'realtime' && !(BRIEF_SLOTS as readonly string[]).includes(slot)) throw new BriefItemsInputError('invalid slot');
+    return this.using(db => this.pageFromDb(db, slot as BriefSendSlot));
   }
 
   /** Hold the ledger's SQLite writer lock from selecting unsent rows through delivery and marking.
    * A failed delivery rolls back and releases the lock; the next sender can retry.
    */
-  withSendLock<T>(slot: string, work: (page: { markdown: string; ids: number[] }, markSent: (ids: readonly number[], slot: BriefSlot) => number) => T): T {
-    if (!(BRIEF_SLOTS as readonly string[]).includes(slot)) throw new BriefItemsInputError('invalid slot');
+  withSendLock<T>(slot: string, work: (page: { markdown: string; ids: number[] }, markSent: (ids: readonly number[], slot: BriefSendSlot) => number) => T): T {
+    if (slot !== 'realtime' && !(BRIEF_SLOTS as readonly string[]).includes(slot)) throw new BriefItemsInputError('invalid slot');
     return this.using(db => {
       db.exec('BEGIN IMMEDIATE');
       try {
-        const page = this.pageFromDb(db, slot as BriefSlot);
+        const page = this.pageFromDb(db, slot as BriefSendSlot);
         const result = work(page, (ids, sentSlot) => {
           if (sentSlot !== slot || ids.length !== page.ids.length || ids.some((id, index) => id !== page.ids[index])) {
             throw new BriefItemsInputError('marked ids must match composed page');
@@ -325,7 +426,7 @@ export class BriefItemsLedger {
     });
   }
 
-  private markSentInDb(db: Database, ids: readonly number[], slot: BriefSlot): number {
+  private markSentInDb(db: Database, ids: readonly number[], slot: BriefSendSlot): number {
     const at = this.now().toISOString();
     const insert = db.query('INSERT INTO sends (item_id, slot, sent_at) VALUES (?, ?, ?)');
     let count = 0;
@@ -338,8 +439,8 @@ export class BriefItemsLedger {
    * Records that these items went out in a slot (append-only); later composes leave them out (ACP must-fix).
    * Only an actual sender calls this — compose itself stays read-only (no flag marks items it did not send).
    */
-  markSent(ids: readonly number[], slot: BriefSlot): number {
-    if (!(BRIEF_SLOTS as readonly string[]).includes(slot)) throw new BriefItemsInputError('invalid slot');
+  markSent(ids: readonly number[], slot: BriefSendSlot): number {
+    if (slot !== 'realtime' && !(BRIEF_SLOTS as readonly string[]).includes(slot)) throw new BriefItemsInputError('invalid slot');
     return this.using(db => db.transaction(() => this.markSentInDb(db, ids, slot))());
   }
 }

package/src/chat/index.ts

@@ -55,7 +55,8 @@ export interface CursorSink {
  *  tests can inject a fake. */
 export interface ModalSink {
   pushModal(surface: ModalSurface): { id: string; dispose: () => void };
-  /** F-E2 — force the coordinator to repaint the modal overlay. Chat
+  /** F-E2 — ask the coordinator to repaint the modal overlay (a plain
+   *  dirty frame — NOT force; see TUI-SLASH-FLICKER). Chat
    *  calls this after every keystroke so the picker's paint closure
    *  re-evaluates `getFiltered()` / `getItems()` — without it, the
    *  picker handle stays mounted but its filter output doesn't flow
@@ -345,11 +346,19 @@ export function createTextInputRenderActions(opts: {
     if (opts.shouldRequestModalRender?.() === false) return;
     if (debug.enabled) {
       debug.log('chat.modal.requestRender', 'user-mutation', {
-        force: true,
+        force: false,
         painted,
       });
     }
-    opts.modalSink?.requestRender?.({ force: true });
+    // TUI-SLASH-FLICKER (2026-10-09) — ⛔ NOT `force: true`. A forced
+    // frame reaches tui.ts::render as `\x1b[1;1H\x1b[J` + every row, so
+    // each keystroke / ↑↓ in the picker erased and repainted the WHOLE
+    // screen (visible flicker). The picker surfaces carry no paint-cache
+    // `generation`, so a plain dirty frame already re-runs their paint
+    // closure and the dashboard frame re-emits the overlay every flush;
+    // rows the picker vacates are invalidated by the coordinator's
+    // region tracking. Regression: src/ux-sim/slash-menu-frames.test.ts.
+    opts.modalSink?.requestRender?.();
   };
   return { repaintHost, repaintUserMutation };
 }
@@ -466,6 +475,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/agent-cli.ts

@@ -668,6 +668,26 @@ export function buildCliAgentTools(
   const shared = (require('../agent/shared-app-tools.js') as typeof import('../agent/shared-app-tools.js')).buildSharedAppTools(cfg);
   for (const s of shared.specs) specs.push(s);
   for (const name of shared.names) dispatchByName.set(name, async (args) => shared.dispatch(name, args));
+  // Installed knowledge is queryable in CLI chat as well as the dashboard runtime.
+  // No installed packs => preserve the existing CLI tool list and avoid creating a KGS database.
+  const { kgsDefaultDbPath } = require('../knowledge/kgs/sqlite-store.js') as typeof import('../knowledge/kgs/sqlite-store.js');
+  const { existsSync } = require('node:fs') as typeof import('node:fs');
+  let hasInstalledPacks = false;
+  try {
+    if (existsSync(kgsDefaultDbPath())) {
+      const { listInstalledPacks } = require('../knowledge/query.js') as typeof import('../knowledge/query.js');
+      hasInstalledPacks = listInstalledPacks().length > 0;
+    }
+  } catch (err) {
+    // An unreadable/corrupt KGS store must not break chat tool assembly for turns that never query knowledge.
+    debug.log('cli.agent', 'knowledge-query.tool-skipped', { reason: err instanceof Error ? err.message : String(err) });
+  }
+  if (hasInstalledPacks) {
+    const { buildKnowledgeQueryTool, dispatchKnowledgeQuery } = require('../knowledge/tools/knowledge-query.js') as typeof import('../knowledge/tools/knowledge-query.js');
+    const knowledgeSpec = buildKnowledgeQueryTool();
+    specs.push(knowledgeSpec);
+    dispatchByName.set(knowledgeSpec.name, async (args) => dispatchKnowledgeQuery(args));
+  }
   if (harnessPlan) {
     specs.push(buildPlanTool(), buildMarkStepDoneTool());
     const planCtx = {