elanous 0.2.15 → 0.2.17

package/src/briefing/brief-items.ts

@@ -2,32 +2,45 @@ import { Database } from 'bun:sqlite';
 import { chmodSync, mkdirSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { debug } from '../debug/log.js';
+import { dateKey } from '../time/format.js';
 
-export type BriefPriority = 'high' | 'medium' | 'low';
+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 type BriefDomain = (typeof BRIEF_DOMAINS)[number];
+export type BriefPriority = (typeof BRIEF_PRIORITIES)[number];
+export type BriefSlot = (typeof BRIEF_SLOTS)[number];
+
+const KST = 'Asia/Seoul';
 
 export interface BriefItem {
   id: number;
   text: string;
-  domain: string;
+  domain: BriefDomain;
   priority: BriefPriority;
   deadline: string | null;
   evidence: string | null;
   source: string;
   created_at: string;
+  sent_at: string | null;
 }
 
 export interface AddBriefItem {
   text: string;
-  domain: string;
+  domain: BriefDomain;
   priority: BriefPriority;
   deadline?: string | null;
   evidence?: string | null;
   source: string;
+  createdAt?: string;
 }
 
 export interface BriefItemsOptions {
   stateDir?: string;
   now?: () => Date;
+  log?: (category: string, event: string, data?: unknown) => void;
 }
 
 export class BriefItemsInputError extends Error {
@@ -43,14 +56,121 @@ function optional(value: string | null | undefined, field: string): string | nul
   return value == null ? null : required(value, field);
 }
 
-/** Append-only item ledger. All three operations open the same instance-scoped SQLite file. */
+/** Collapse whitespace so the same claim, however spaced, counts once. */
+export function normalizeClaim(text: string): string {
+  return text.normalize('NFKC').trim().replace(/\s+/g, ' ').toLowerCase();
+}
+
+function deadlineDate(deadline: string): string {
+  return /^\d{4}-\d{2}-\d{2}$/.test(deadline) ? deadline : dateKey(deadline, { timeZone: KST });
+}
+
+/**
+ * Unsent items created strictly before the slot instant (KST).
+ * `08:30` and `22:00` are that clock today. `after-release` has no fixed
+ * clock — a release can land at any hour — so its instant is `now`.
+ * Tomorrow's items stay out of every slot.
+ */
+export function beforeSlot(createdAt: string, slot: BriefSlot, now: Date): boolean {
+  const createdMs = Date.parse(createdAt);
+  if (!Number.isFinite(createdMs)) return false;
+  const today = dateKey(now, { timeZone: KST });
+  const cutoff = slot === 'after-release' ? now.getTime() : Date.parse(`${today}T${slot}:00+09:00`);
+  return createdMs < cutoff;
+}
+
+function needsDecision(item: BriefItem, today: string): boolean {
+  return item.priority === 'P0' || (item.deadline !== null && deadlineDate(item.deadline) === today);
+}
+
+/**
+ * One briefing page. Item text is copied verbatim.
+ * Order: decisions due (P0, then a deadline of today) → domain groups →
+ * duplicate claims dropped (same normalized sentence, most urgent kept).
+ */
+export function composeBriefMarkdown(items: readonly BriefItem[], slot: BriefSlot, now: Date): string {
+  const today = dateKey(now, { timeZone: KST });
+  const eligible = items.filter(item => item.sent_at === null && beforeSlot(item.created_at, slot, now));
+  // 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]!; };
+  const best = new Map<string, BriefItem>();
+  for (const item of eligible) {
+    const key = normalizeClaim(item.text);
+    const kept = best.get(key);
+    if (!kept || better(item, kept) < 0) best.set(key, item);
+  }
+  const unique = [...best.values()].sort((a, b) => a.id - b.id);
+  const decisions = unique.filter(item => needsDecision(item, today))
+    .sort((a, b) => Number(b.priority === 'P0') - Number(a.priority === 'P0') || a.id - b.id);
+  const decisionIds = new Set(decisions.map(item => item.id));
+  const lines = [`# 브리핑 — ${slot}`, ''];
+  if (decisions.length > 0) {
+    lines.push('## 결정이 필요한 것', '');
+    for (const item of decisions) lines.push(itemLine(item));
+    lines.push('');
+  }
+  for (const domain of BRIEF_DOMAINS) {
+    const group = unique.filter(item => item.domain === domain && !decisionIds.has(item.id));
+    if (group.length === 0) continue;
+    lines.push(`## ${domain}`, '');
+    for (const item of group.sort((a, b) => a.id - b.id)) lines.push(itemLine(item));
+    lines.push('');
+  }
+  return `${lines.join('\n').trimEnd()}\n`;
+}
+
+function itemLine(item: BriefItem): string {
+  const extra = [
+    item.deadline ? `마감: ${item.deadline}` : '',
+    item.evidence ? `근거: ${item.evidence}` : '',
+    `출처: ${item.source}`,
+  ].filter(Boolean).join(' · ');
+  return `- [${item.priority}] ${item.text} (${extra})`;
+}
+
+/**
+ * The first ledger (#24193) used priorities high/medium/low and had no sent_at column. Keep its rows: move the old
+ * table aside and copy them into the current shape (high→P0 · medium→P1 · low→P2) — append-only, nothing is lost.
+ */
+function migrateLegacyItems(db: Database, log: (category: string, event: string, data?: unknown) => void): void {
+  const columns = db.query("SELECT name FROM pragma_table_info('items')").all() as { name: string }[];
+  if (columns.length === 0 || columns.some(column => column.name === 'sent_at')) return;
+  db.transaction(() => {
+    db.exec('DROP TRIGGER IF EXISTS items_no_update; DROP TRIGGER IF EXISTS items_no_delete; ALTER TABLE items RENAME TO items_v1;');
+    db.exec(`CREATE TABLE items (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      text TEXT NOT NULL,
+      domain TEXT NOT NULL CHECK(domain IN ('운영', '판', '흡수', '시장', '행정', '코나투스')),
+      priority TEXT NOT NULL CHECK(priority IN ('P0', 'P1', 'P2')),
+      deadline TEXT,
+      evidence TEXT,
+      source TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      sent_at TEXT
+    )`);
+    db.exec(`INSERT INTO items (id, text, domain, priority, deadline, evidence, source, created_at, sent_at)
+      SELECT id, text,
+        CASE WHEN domain IN ('운영', '판', '흡수', '시장', '행정', '코나투스') THEN domain ELSE '운영' END,
+        CASE priority WHEN 'high' THEN 'P0' WHEN 'medium' THEN 'P1' ELSE 'P2' END,
+        deadline, evidence,
+        -- An unknown legacy domain keeps its meaning in the source label instead of vanishing (ACP must-fix).
+        CASE WHEN domain IN ('운영', '판', '흡수', '시장', '행정', '코나투스') THEN source ELSE source || ' · 옛 도메인 ' || domain END,
+        created_at, NULL FROM items_v1`);
+  })();
+  log('briefing.items', 'migrated-legacy', { rows: (db.query('SELECT COUNT(*) AS n FROM items_v1').get() as { n: number }).n });
+}
+
+/** Append-only briefing item ledger at `<state>/briefing/items.sqlite`. */
 export class BriefItemsLedger {
   readonly path: string;
   private readonly now: () => Date;
+  private readonly log: (category: string, event: string, data?: unknown) => void;
 
   constructor(options: BriefItemsOptions = {}) {
     this.path = join(options.stateDir ?? elanousStateRoot(), 'briefing', 'items.sqlite');
     this.now = options.now ?? (() => new Date());
+    this.log = options.log ?? ((category, event, data) => debug.log(category, event, data));
   }
 
   private using<T>(work: (db: Database) => T): T {
@@ -59,16 +179,27 @@ export class BriefItemsLedger {
     try {
       chmodSync(this.path, 0o600);
       db.exec('PRAGMA busy_timeout = 10000');
+      migrateLegacyItems(db, this.log);
       db.exec(`CREATE TABLE IF NOT EXISTS items (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
-        text TEXT NOT NULL, domain TEXT NOT NULL,
-        priority TEXT NOT NULL CHECK(priority IN ('high', 'medium', 'low')),
-        deadline TEXT, evidence TEXT, source TEXT NOT NULL, created_at TEXT NOT NULL
+        text TEXT NOT NULL,
+        domain TEXT NOT NULL CHECK(domain IN ('운영', '판', '흡수', '시장', '행정', '코나투스')),
+        priority TEXT NOT NULL CHECK(priority IN ('P0', 'P1', 'P2')),
+        deadline TEXT,
+        evidence TEXT,
+        source TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        sent_at TEXT
       );
       CREATE TRIGGER IF NOT EXISTS items_no_update BEFORE UPDATE ON items
         BEGIN SELECT RAISE(ABORT, 'brief items are immutable'); END;
       CREATE TRIGGER IF NOT EXISTS items_no_delete BEFORE DELETE ON items
-        BEGIN SELECT RAISE(ABORT, 'brief items are immutable'); END;`);
+        BEGIN SELECT RAISE(ABORT, 'brief items are immutable'); END;
+      CREATE TABLE IF NOT EXISTS sends (
+        item_id INTEGER NOT NULL REFERENCES items(id),
+        slot TEXT NOT NULL,
+        sent_at TEXT NOT NULL
+      );`);
       return work(db);
     } finally {
       db.close();
@@ -77,45 +208,69 @@ export class BriefItemsLedger {
 
   add(input: AddBriefItem): BriefItem {
     const text = required(input.text, 'text');
-    const domain = required(input.domain, 'domain');
+    // A brief item is one claim line; a line break would break the composed Markdown structure (ACP must-fix).
+    if (/[\r\n]/.test(text)) throw new BriefItemsInputError('text must be a single line');
+    if (!(BRIEF_DOMAINS as readonly string[]).includes(input.domain)) throw new BriefItemsInputError('invalid domain');
+    if (!(BRIEF_PRIORITIES as readonly string[]).includes(input.priority)) throw new BriefItemsInputError('invalid priority');
     const source = required(input.source, 'source');
-    if (!['high', 'medium', 'low'].includes(input.priority)) throw new BriefItemsInputError('invalid priority');
     const deadline = optional(input.deadline, 'deadline');
+    // Every field that reaches the composed Markdown is one line, so no stored item can forge a heading or entry (ACP must-fix).
+    for (const [field, value] of [['source', source], ['evidence', input.evidence ?? null], ['deadline', deadline]] as const) {
+      if (value !== null && /[\r\n]/.test(value)) throw new BriefItemsInputError(`${field} must be a single line`);
+    }
     if (deadline !== null) {
       const format = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2}))?$/;
       if (!format.test(deadline) || !Number.isFinite(Date.parse(deadline))) throw new BriefItemsInputError('invalid deadline');
     }
     const evidence = optional(input.evidence, 'evidence');
-    return this.using(db => {
-      const createdAt = this.now().toISOString();
-      const result = db.query('INSERT INTO items (text, domain, priority, deadline, evidence, source, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)')
-        .run(text, domain, input.priority, deadline, evidence, source, createdAt);
-      return db.query('SELECT id, text, domain, priority, deadline, evidence, source, created_at FROM items WHERE id = ?')
-        .get(result.lastInsertRowid) as BriefItem;
+    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;
     });
+    this.log('briefing.items', 'added', { id: item.id, domain: item.domain, priority: item.priority, source: item.source });
+    return item;
   }
 
-  /** Higher priorities first, then nearest deadline by instant, then insertion order. */
-  list(filters: { domain?: string } = {}): BriefItem[] {
-    const items = this.using(db => (filters.domain === undefined
-      ? db.query('SELECT id, text, domain, priority, deadline, evidence, source, created_at FROM items').all()
-      : db.query('SELECT id, text, domain, priority, deadline, evidence, source, created_at FROM items WHERE domain = ?').all(filters.domain)) as BriefItem[]);
-    const rank: Record<BriefPriority, number> = { high: 0, medium: 1, low: 2 };
-    return items.sort((a, b) => rank[a.priority] - rank[b.priority]
-      || Number(a.deadline === null) - Number(b.deadline === null)
-      || (a.deadline !== null && b.deadline !== null ? Date.parse(a.deadline) - Date.parse(b.deadline) : 0)
-      || a.id - b.id);
+  /** Insertion order. Optional domain filter. Item text is the stored original. */
+  list(filters: { domain?: BriefDomain } = {}): BriefItem[] {
+    return this.using(db => (filters.domain === undefined
+      ? 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()
+      : 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 domain = ? ORDER BY id').all(filters.domain)) as BriefItem[]);
   }
 
-  /** Pure Markdown output: composing never marks, alters, or sends stored items. */
-  compose(slot: string, filters: { domain?: string } = {}): string {
-    required(slot, 'slot');
-    const items = this.list(filters);
-    const lines = [`# Briefing — ${slot}`, ''];
-    for (const item of items) {
-      lines.push(`- [${item.priority}] ${item.text} (${item.domain})`);
-      lines.push(`  - Source: ${item.source}${item.deadline ? ` · Deadline: ${item.deadline}` : ''}${item.evidence ? ` · Evidence: ${item.evidence}` : ''}`);
-    }
-    return `${lines.join('\n').trimEnd()}\n`;
+  /**
+   * Markdown for one slot. Reads only — never marks, rewrites, or sends an item.
+   * Items created at or after the slot instant are left out.
+   */
+  compose(slot: string): string {
+    if (!(BRIEF_SLOTS as readonly string[]).includes(slot)) throw new BriefItemsInputError('invalid slot');
+    const items = this.list();
+    const markdown = composeBriefMarkdown(items, slot as BriefSlot, this.now());
+    const included = items.filter(item => item.sent_at === null && beforeSlot(item.created_at, slot as BriefSlot, this.now()));
+    this.log('briefing.items', 'composed', { slot, candidates: included.length, bytes: Buffer.byteLength(markdown) });
+    return markdown;
+  }
+
+  /**
+   * 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');
+    const at = this.now().toISOString();
+    const count = this.using(db => {
+      const insert = db.query('INSERT INTO sends (item_id, slot, sent_at) VALUES (?, ?, ?)');
+      let n = 0;
+      db.transaction(() => { for (const id of ids) { insert.run(id, slot, at); n++; } })();
+      return n;
+    });
+    this.log('briefing.items', 'marked-sent', { slot, count });
+    return count;
   }
 }

package/src/budget/usage-outcomes.ts

@@ -0,0 +1,204 @@
+// `elanous usage outcomes` — 런 원장의 childProvider × 결과.
+// provider 가 기록되지 않은 런은 «불명». 이름을 지어 세지 않는다.
+
+import { readdirSync } from 'node:fs';
+import {
+  loadRunLedger,
+  runLedgerDir,
+  type RunLedgerEntry,
+  type RunLedgerReader,
+} from '../self-implement/run-ledger.js';
+
+export const UNKNOWN_PROVIDER_LABEL = '불명';
+
+export type OutcomeKind = 'landed' | 'draft' | 'failed' | 'open';
+
+export interface ProviderOutcomeRow {
+  readonly provider: string;
+  readonly runs: number;
+  readonly landed: number;
+  readonly draft: number;
+  readonly failed: number;
+  readonly open: number;
+  /** landed / runs. 런이 0이면 0. */
+  readonly unattendedLandRate: number;
+  readonly rounds: number;
+  readonly blockReasons: Readonly<Record<string, number>>;
+}
+
+export interface UsageOutcomesReport {
+  readonly sinceDays: number;
+  readonly sinceMs: number;
+  readonly rows: readonly ProviderOutcomeRow[];
+  readonly unreadableLedgers: number;
+}
+
+export interface UsageOutcomesDeps {
+  readonly dir?: string;
+  readonly nowMs?: number;
+  readonly list?: (path: string) => string[];
+  readonly read?: RunLedgerReader;
+  readonly load?: (runId: string, dir: string, read?: RunLedgerReader) => RunLedgerEntry[] | null;
+}
+
+const LEDGER_FILE = /\.jsonl$/;
+
+function stringField(data: Record<string, unknown>, key: string): string | undefined {
+  const value = data[key];
+  return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+
+function entryMs(entry: RunLedgerEntry): number | undefined {
+  if (!entry.timestamp) return undefined;
+  const ms = Date.parse(entry.timestamp);
+  return Number.isFinite(ms) ? ms : undefined;
+}
+
+/** 기록된 childProvider 만. 없거나 공백이면 «불명». */
+export function providerLabel(entries: readonly RunLedgerEntry[]): string {
+  const origin = entries.find((entry) => entry.event === 'run-origin');
+  const recorded = origin ? stringField(origin.data, 'childProvider') : undefined;
+  return recorded ?? UNKNOWN_PROVIDER_LABEL;
+}
+
+function blockReason(entry: RunLedgerEntry): string | undefined {
+  return stringField(entry.data, 'stopReason')
+    ?? stringField(entry.data, 'reason')
+    ?? stringField(entry.data, 'verdict')
+    ?? stringField(entry.data, 'error');
+}
+
+interface ClassifiedRun {
+  readonly provider: string;
+  readonly outcome: OutcomeKind;
+  readonly rounds: number;
+  readonly blockReason?: string;
+  readonly atMs: number;
+}
+
+export function classifyLedgerRun(entries: readonly RunLedgerEntry[], nowMs: number): ClassifiedRun | null {
+  if (entries.length === 0) return null;
+  const times = entries.map(entryMs).filter((ms): ms is number => ms !== undefined);
+  const atMs = times.length > 0 ? Math.max(...times) : nowMs;
+  const rounds = new Set(
+    entries
+      .map((entry) => entry.data.round)
+      .filter((round): round is number => typeof round === 'number' && Number.isFinite(round)),
+  ).size;
+  const merged = [...entries].reverse().find((entry) => entry.event === 'merged' && entry.data.merged === true);
+  const drafted = [...entries].reverse().find((entry) => entry.event === 'pr-opened' && entry.data.draft !== false);
+  const failed = [...entries].reverse().find((entry) => entry.event === 'failed' || entry.event === 'run-status' && (entry.data.runStatus === 'failed' || entry.data.runStatus === 'stopped'));
+  const outcome: OutcomeKind = merged ? 'landed' : drafted ? 'draft' : failed ? 'failed' : 'open';
+  const reason = outcome === 'failed' || outcome === 'open'
+    ? (failed ? blockReason(failed) : undefined)
+      ?? entries.map(blockReason).reverse().find((value) => value !== undefined)
+    : undefined;
+  return {
+    provider: providerLabel(entries),
+    outcome,
+    rounds,
+    ...(reason ? { blockReason: reason } : {}),
+    atMs,
+  };
+}
+
+export function aggregateUsageOutcomes(
+  runs: readonly ClassifiedRun[],
+  sinceDays: number,
+  sinceMs: number,
+  unreadableLedgers = 0,
+): UsageOutcomesReport {
+  const byProvider = new Map<string, {
+    runs: number;
+    landed: number;
+    draft: number;
+    failed: number;
+    open: number;
+    rounds: number;
+    blockReasons: Record<string, number>;
+  }>();
+  for (const run of runs) {
+    const row = byProvider.get(run.provider) ?? {
+      runs: 0, landed: 0, draft: 0, failed: 0, open: 0, rounds: 0, blockReasons: {},
+    };
+    row.runs += 1;
+    row[run.outcome] += 1;
+    row.rounds += run.rounds;
+    if (run.blockReason && run.outcome !== 'landed' && run.outcome !== 'draft') {
+      row.blockReasons[run.blockReason] = (row.blockReasons[run.blockReason] ?? 0) + 1;
+    }
+    byProvider.set(run.provider, row);
+  }
+  const rows = [...byProvider.entries()]
+    .map(([provider, row]): ProviderOutcomeRow => ({
+      provider,
+      ...row,
+      unattendedLandRate: row.runs === 0 ? 0 : row.landed / row.runs,
+    }))
+    .sort((a, b) => a.provider.localeCompare(b.provider, 'en'));
+  return { sinceDays, sinceMs, rows, unreadableLedgers };
+}
+
+export function queryUsageOutcomes(sinceDays: number, deps: UsageOutcomesDeps = {}): UsageOutcomesReport {
+  const days = Number.isFinite(sinceDays) && sinceDays > 0 ? sinceDays : 2;
+  const nowMs = deps.nowMs ?? Date.now();
+  const sinceMs = nowMs - days * 24 * 60 * 60 * 1000;
+  const dir = deps.dir ?? runLedgerDir();
+  const list = deps.list ?? readdirSync;
+  const load = deps.load ?? loadRunLedger;
+  let names: string[];
+  try {
+    names = list(dir);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      return aggregateUsageOutcomes([], days, sinceMs, 0);
+    }
+    throw error;
+  }
+  const runs: ClassifiedRun[] = [];
+  let unreadableLedgers = 0;
+  for (const name of names) {
+    if (!LEDGER_FILE.test(name)) continue;
+    const runId = name.slice(0, -'.jsonl'.length);
+    let ledger: RunLedgerEntry[] | null;
+    try {
+      ledger = load(runId, dir, deps.read);
+    } catch {
+      unreadableLedgers += 1;
+      continue;
+    }
+    if (!ledger) {
+      unreadableLedgers += 1;
+      continue;
+    }
+    const classified = classifyLedgerRun(ledger, nowMs);
+    if (!classified || classified.atMs < sinceMs) continue;
+    runs.push(classified);
+  }
+  return aggregateUsageOutcomes(runs, days, sinceMs, unreadableLedgers);
+}
+
+export function formatUsageOutcomes(report: UsageOutcomesReport): string {
+  const header = `최근 ${report.sinceDays}일 · 런 원장 childProvider × 결과`;
+  const verdict = outcomeTableHasCodexGrokUnknown(report)
+    ? '판정: codex·grok·불명'
+    : '판정: codex·grok·불명 아님';
+  if (report.rows.length === 0) return `${header}\n${verdict}\n(해당 런 없음)`;
+  const lines = [header, verdict, 'provider  runs  landed  draft  failed  open  landRate  rounds  blockReasons'];
+  for (const row of report.rows) {
+    const reasons = Object.entries(row.blockReasons)
+      .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+      .map(([reason, count]) => `${reason}=${count}`)
+      .join(',');
+    const rate = `${Math.round(row.unattendedLandRate * 1000) / 10}%`;
+    lines.push(`${row.provider}  ${row.runs}  ${row.landed}  ${row.draft}  ${row.failed}  ${row.open}  ${rate}  ${row.rounds}  ${reasons || '-'}`);
+  }
+  if (report.unreadableLedgers > 0) lines.push(`unreadable ledgers: ${report.unreadableLedgers}`);
+  return lines.join('\n');
+}
+
+/** 판정이 요구하는 최근 이틀 표에 codex·grok·불명 세 줄이 있는지. */
+export function outcomeTableHasCodexGrokUnknown(report: UsageOutcomesReport): boolean {
+  const names = new Set(report.rows.map((row) => row.provider));
+  return names.has('codex') && names.has('grok') && names.has(UNKNOWN_PROVIDER_LABEL) && report.rows.length >= 3;
+}

package/src/cli/autopilot-cli.ts

@@ -7,9 +7,75 @@ import { writeStdoutJson } from './stdout-json.js';
 // AutopilotLoopDriver against the mission, prints agent deltas on
 // stdout + envelope/termination summary on stderr.
 export function registerAutopilotCommands(program: Command): void {
+  // Explicit runtime entry for a selected action; the task chooser can invoke this entry.
   const autopilotCmd = program
     .command('autopilot')
     .description('Mission-driven autopilot — runs an ACP agent against a single mission with safety + budget guards');
+  autopilotCmd.command('task-agent-action <actionJson>')
+    .description('Execute a selected task-agent action; defaults to shadow')
+    .action(async (actionJson: string) => {
+      const { executeNextAction } = await import('../task-agent/actions.js');
+      const { getUserConfig } = await import('../user-config.js');
+      const { spawnSync } = await import('node:child_process');
+      const { readFileSync, writeFileSync, mkdirSync } = await import('node:fs');
+      const { join, dirname } = await import('node:path');
+      const { debug } = await import('../debug/log.js');
+      const { withFileLockSync } = await import('../storage/file-lock.js');
+      const config = getUserConfig() as ReturnType<typeof getUserConfig> & { taskAgent?: { mode?: string } };
+      const { effectiveInstanceRoot } = await import('../instance/resolve.js');
+      const statePath = join(effectiveInstanceRoot(), 'task-agent-actions.json');
+      let state: { landingDay?: string; landingsToday?: number; failureCounts?: Record<string, number> } = {};
+      try { state = JSON.parse(readFileSync(statePath, 'utf8')); } catch { /* first run */ }
+      const action = JSON.parse(actionJson) as import('../task-agent/actions.js').NextAction;
+      const deps: import('../task-agent/actions.js').ActionDeps = {
+        ...state,
+        failureCounts: state.failureCounts ?? {},
+        saveState: () => {
+          mkdirSync(dirname(statePath), { recursive: true });
+          // 실패 횟수는 incrementFailure 가 잠금 안에서 키별로 더한다 — 여기선 덮어쓰지 않는다.
+        },
+        mode: config.taskAgent?.mode,
+        // 하루 착지 칸은 상태 파일 잠금 안에서 확보·반환한다 — 두 CLI 프로세스가 같은 잔여 칸을 쓰지 않게.
+        reserveLanding: (day, limit) => withFileLockSync(`${statePath}.lock`, () => {
+          let disk: typeof state = {};
+          try { disk = JSON.parse(readFileSync(statePath, 'utf8')); } catch { /* first */ }
+          const used = disk.landingDay === day ? disk.landingsToday ?? 0 : 0;
+          if (used >= limit) return false;
+          mkdirSync(dirname(statePath), { recursive: true });
+          writeFileSync(statePath, JSON.stringify({ ...disk, landingDay: day, landingsToday: used + 1 }));
+          deps.landingDay = day; deps.landingsToday = used + 1;
+          return true;
+        }),
+        incrementFailure: (key) => withFileLockSync(`${statePath}.lock`, () => {
+          let disk: typeof state = {};
+          try { disk = JSON.parse(readFileSync(statePath, 'utf8')); } catch { /* first */ }
+          const counts = { ...(disk.failureCounts ?? {}) };
+          counts[key] = (counts[key] ?? 0) + 1;
+          mkdirSync(dirname(statePath), { recursive: true });
+          writeFileSync(statePath, JSON.stringify({ ...disk, failureCounts: counts }));
+          return counts[key]!;
+        }),
+        releaseLanding: (day) => withFileLockSync(`${statePath}.lock`, () => {
+          let disk: typeof state = {};
+          try { disk = JSON.parse(readFileSync(statePath, 'utf8')); } catch { return; }
+          if (disk.landingDay !== day || !disk.landingsToday) return;
+          writeFileSync(statePath, JSON.stringify({ ...disk, landingsToday: disk.landingsToday - 1 }));
+          deps.landingsToday = disk.landingsToday - 1;
+        }),
+        observe: (_event, data) => debug.log('task-agent', 'action', data),
+        command: async args => {
+          const p = args[0] === 'gh'
+            // PR 조회는 착지할 작업 트리에서 — 다른 저장소에서 불러도 엉뚱한 PR 을 읽지 않게.
+            ? spawnSync('gh', args.slice(1), { encoding: 'utf8', ...(action.cwd ? { cwd: action.cwd } : {}) })
+            // 지금 돌고 있는 진입점으로 부른다 — 저장소 밖(설치본)에서 불러도 같은 elanous 를 쓴다.
+            : spawnSync(process.execPath, [process.argv[1]!, ...(process.argv.includes('--test') ? ['--test'] : []), ...args], { encoding: 'utf8' });
+          return { status: p.status ?? 1, stdout: p.stdout ?? '', stderr: p.stderr ?? '' };
+        },
+      };
+      const result = await executeNextAction(action, deps);
+      if (config.taskAgent?.mode === 'live') deps.saveState?.();
+      process.stdout.write(`${result}\n`);
+    });
 
 autopilotCmd
   .command('run <mission...>')

package/src/cli/brief-cli.ts

@@ -0,0 +1,73 @@
+import type { Command } from 'commander';
+import { BRIEF_DOMAINS, BRIEF_PRIORITIES, BRIEF_SLOTS, BriefItemsInputError, BriefItemsLedger, type BriefDomain, type BriefPriority } from '../briefing/brief-items.js';
+
+export interface BriefCliDeps {
+  ledger?: BriefItemsLedger;
+  stateDir?: string;
+  now?: () => Date;
+  output?: (line: string) => void;
+  error?: (line: string) => void;
+}
+
+export function registerBriefCommands(program: Command, deps: BriefCliDeps = {}): void {
+  const output = deps.output ?? ((line: string) => console.log(line));
+  const error = deps.error ?? ((line: string) => console.error(line));
+  const ledger = () => deps.ledger ?? new BriefItemsLedger({
+    ...(deps.stateDir ? { stateDir: deps.stateDir } : {}),
+    ...(deps.now ? { now: deps.now } : {}),
+  });
+  const fail = (verb: string, cause: unknown) => {
+    error(`brief ${verb}: ${cause instanceof Error ? cause.message : String(cause)}`);
+    process.exitCode = cause instanceof BriefItemsInputError ? 2 : 1;
+  };
+  const brief = program.command('brief').description('대표 브리핑 항목 원장 — 발신자는 항목만 내고, 발송은 하지 않는다');
+
+  brief.command('add')
+    .description('주장 한 줄을 원장에 추가한다 (원문 그대로)')
+    .requiredOption('--text <text>', '주장 한 줄')
+    .requiredOption('--domain <domain>', `도메인 (${BRIEF_DOMAINS.join('|')})`)
+    .requiredOption('--priority <priority>', `중요도 (${BRIEF_PRIORITIES.join('|')})`)
+    .requiredOption('--source <source>', '출처 (루프·자리·흡수·코나투스)')
+    .option('--deadline <deadline>', '마감 (YYYY-MM-DD 또는 ISO)')
+    .option('--evidence <evidence>', '근거 링크')
+    .option('--created-at <iso>', '작성 시각 (ISO, 생략 시 지금)')
+    .option('--json', 'JSON 출력')
+    .action((opts: { text: string; domain: string; priority: string; source: string; deadline?: string; evidence?: string; createdAt?: string; json?: boolean }) => {
+      try {
+        const item = ledger().add({
+          text: opts.text,
+          domain: opts.domain as BriefDomain,
+          priority: opts.priority as BriefPriority,
+          source: opts.source,
+          ...(opts.deadline !== undefined ? { deadline: opts.deadline } : {}),
+          ...(opts.evidence !== undefined ? { evidence: opts.evidence } : {}),
+          ...(opts.createdAt !== undefined ? { createdAt: opts.createdAt } : {}),
+        });
+        output(opts.json ? JSON.stringify(item) : `added ${item.id} [${item.priority}] ${item.domain}`);
+      } catch (cause) { fail('add', cause); }
+    });
+
+  brief.command('list')
+    .description('원장 항목을 추가 순으로 본다')
+    .option('--domain <domain>', `도메인 필터 (${BRIEF_DOMAINS.join('|')})`)
+    .option('--json', 'JSON 출력')
+    .action((opts: { domain?: string; json?: boolean }) => {
+      try {
+        if (opts.domain !== undefined && !(BRIEF_DOMAINS as readonly string[]).includes(opts.domain)) {
+          throw new BriefItemsInputError('invalid domain');
+        }
+        const items = ledger().list(opts.domain === undefined ? {} : { domain: opts.domain as BriefDomain });
+        if (opts.json) output(JSON.stringify(items));
+        else if (items.length === 0) output('(항목 없음)');
+        else for (const item of items) output(`${item.id}\t${item.priority}\t${item.domain}\t${item.source}\t${item.text}`);
+      } catch (cause) { fail('list', cause); }
+    });
+
+  brief.command('compose')
+    .description('슬롯 이전의 미발송 항목을 한 장 마크다운으로 만든다 (표준 출력만, 발송 없음)')
+    .requiredOption('--slot <slot>', `슬롯 (${BRIEF_SLOTS.join('|')})`)
+    .action((opts: { slot: string }) => {
+      try { output(ledger().compose(opts.slot)); }
+      catch (cause) { fail('compose', cause); }
+    });
+}