elanous 0.2.14 → 0.2.15

package/src/decisions/proact-meter.ts

@@ -0,0 +1,286 @@
+import { readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { DecisionLedger, type DecisionEntry, type SeatDecisionRecord } from './decision-ledger.js';
+import { createRequire } from 'node:module';
+import { listCoordEvents, type CoordEvent } from '../context-bus/coord-events.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+
+/** Directive row fields this meter reads — kept local because `src/directives/directive-index` is excluded from the public export. */
+export interface DirectiveRow { ts: string; text: string; source_file: string; line_no: number }
+
+/** Loads the private directive index at run time only, so public builds (no index) bundle cleanly and report `directivesError`. */
+function openDirectiveIndex(stateDir?: string): { search(q: string, f: { since?: string; until?: string; limit?: number }): DirectiveRow[]; close(): void } {
+  const spec = ['..', 'directives', 'directive-index.js'].join('/');
+  const mod = createRequire(import.meta.url)(spec) as { DirectiveIndex: new (o: { stateDir?: string }) => ReturnType<typeof openDirectiveIndex> };
+  return new mod.DirectiveIndex(stateDir ? { stateDir } : {});
+}
+
+/** KST calendar day, matching the seat-loop ledger file name. */
+export function proactKstDay(at: Date | string): string {
+  const date = typeof at === 'string' ? new Date(at) : at;
+  if (!Number.isFinite(date.getTime())) throw new Error('valid timestamp required');
+  return new Intl.DateTimeFormat('en-CA', { timeZone: 'Asia/Seoul', year: 'numeric', month: '2-digit', day: '2-digit' }).format(date);
+}
+
+export function proactWindow(now: Date, days = 7): { since: string; until: string; days: string[] } {
+  if (!Number.isFinite(now.getTime()) || !Number.isInteger(days) || days < 1) throw new Error('valid window required');
+  const today = proactKstDay(now);
+  const todayStart = Date.parse(`${today}T00:00:00+09:00`);
+  const list: string[] = [];
+  for (let i = days - 1; i >= 0; i--) list.push(proactKstDay(new Date(todayStart - i * 86_400_000)));
+  return { since: new Date(todayStart - (days - 1) * 86_400_000).toISOString(), until: now.toISOString(), days: list };
+}
+
+export type ProactKind = 'proposal' | 'alert' | 'action';
+export type ProactSource = 'decision' | 'directive' | 'coord' | 'loop';
+export interface ProactSample {
+  readonly day: string;
+  readonly bucket: 'offered' | 'adopted' | 'asked';
+  readonly source: ProactSource;
+  readonly id: string;
+  readonly at: string;
+  readonly title: string;
+  /** Where the original row lives, so a count can be opened again. */
+  readonly link: string;
+}
+export interface ProactDay {
+  readonly day: string;
+  /** System offered a proposal, alert, or action before the owner asked. */
+  readonly offered: number;
+  /** Of those, the ones the owner (or a delegated seat) adopted. */
+  readonly adopted: number;
+  /** Problems that stayed invisible until the owner asked first. */
+  readonly asked: number;
+}
+export interface ProactSourceStatus { readonly read: boolean; readonly reason?: string }
+export interface ProactMeter {
+  readonly since: string;
+  readonly until: string;
+  readonly days: readonly ProactDay[];
+  readonly samples: readonly ProactSample[];
+  readonly sources: Readonly<Record<ProactSource, ProactSourceStatus>>;
+}
+
+export interface ProactMeterInput {
+  decisions?: readonly DecisionEntry[];
+  seatDecisions?: readonly SeatDecisionRecord[];
+  directives?: readonly DirectiveRow[];
+  coord?: readonly CoordEvent[];
+  loops?: readonly ProactLoopRow[];
+  decisionsError?: string;
+  directivesError?: string;
+  coordError?: string;
+  loopsError?: string;
+}
+export interface ProactLoopRow {
+  readonly seat: string;
+  readonly at: string;
+  readonly status: string;
+  readonly action?: string;
+  readonly id?: string;
+  readonly title?: string;
+  readonly file: string;
+}
+
+const ALERT = /경보|경고|장애|실패|막힘|alert|fail|blocked|stall/i;
+const ACTION = /조치|실행|발사|launch|queued|launched/i;
+const ASKED = /왜|문제|안 되|안돼|고장|버그|실패|막혀|뭐가|무슨 일|확인해/;
+
+export function proactKind(text: string, action?: string): ProactKind {
+  if (action === 'decision' || action === 'harness' || action === 'seat-question' || ACTION.test(text)) return 'action';
+  if (ALERT.test(text)) return 'alert';
+  return 'proposal';
+}
+
+function sample(day: string, bucket: ProactSample['bucket'], source: ProactSource, id: string, at: string, title: string, link: string): ProactSample {
+  return { day, bucket, source, id, at, title: title.replace(/\s+/g, ' ').trim().slice(0, 160), link };
+}
+
+/** Count one row once. Adoption is a property of an offered row, never a second offered row. */
+export function measureProact(input: ProactMeterInput, now: Date, days = 7): ProactMeter {
+  const window = proactWindow(now, days);
+  const inWindow = (at: string | undefined): at is string => !!at && at >= window.since && at <= window.until;
+  const offered: ProactSample[] = [];
+  const adopted: ProactSample[] = [];
+  const asked: ProactSample[] = [];
+
+  if (!input.decisionsError) {
+    for (const card of input.decisions ?? []) {
+      const at = card.raisedAt ?? card.importedAt;
+      if (!inWindow(at)) continue;
+      const day = proactKstDay(at);
+      const link = `decisions://${card.id}`;
+      const system = card.raisedBy.agent !== 'human' && card.raisedBy.agent !== 'owner';
+      if (system) {
+        offered.push(sample(day, 'offered', 'decision', card.id, at, card.title, link));
+        const decidedAt = card.decidedAt;
+        const adoptedDay = decidedAt ? proactKstDay(decidedAt) : '';
+        if (card.status === 'decided' && decidedAt && decidedAt <= window.until) {
+          adopted.push(sample(adoptedDay, 'adopted', 'decision', card.id, decidedAt, card.title, link));
+        }
+      } else if (ASKED.test(`${card.title} ${card.scqa.c}`)) {
+        asked.push(sample(day, 'asked', 'decision', card.id, at, card.title, link));
+      }
+    }
+    for (const seat of input.seatDecisions ?? []) {
+      if (!inWindow(seat.recordedAt)) continue;
+      const at = seat.decidedAt && seat.decidedAt <= window.until ? seat.decidedAt : seat.recordedAt;
+      const adoptedDay = proactKstDay(at);
+      const link = `decisions://${seat.id}`;
+      offered.push(sample(proactKstDay(seat.recordedAt), 'offered', 'decision', seat.id, seat.recordedAt, seat.title, link));
+      if (window.days.includes(adoptedDay)) adopted.push(sample(adoptedDay, 'adopted', 'decision', seat.id, at, seat.title, link));
+    }
+  }
+
+  if (!input.directivesError) {
+    for (const row of input.directives ?? []) {
+      if (!inWindow(row.ts) || !ASKED.test(row.text)) continue;
+      asked.push(sample(proactKstDay(row.ts), 'asked', 'directive', `${row.source_file}:${row.line_no}`, row.ts, row.text, `directives://${row.source_file}#L${row.line_no}`));
+    }
+  }
+
+  if (!input.coordError) {
+    for (const event of input.coord ?? []) {
+      if (!inWindow(event.at)) continue;
+      const day = proactKstDay(event.at);
+      const link = event.refs.url ?? `coord://${event.id}`;
+      const text = `${event.summary} ${event.kind}`;
+      const systemOffered = event.refs.seat && event.refs.seat !== 'CEO' && (event.kind === '제안' || event.kind === '보고' || event.kind === '사고' || ALERT.test(text) || ACTION.test(text));
+      if (systemOffered) {
+        offered.push(sample(day, 'offered', 'coord', event.id, event.at, event.summary, link));
+      } else if (event.refs.seat === 'CEO' && (event.kind === '요청' || ASKED.test(text))) {
+        asked.push(sample(day, 'asked', 'coord', event.id, event.at, event.summary, link));
+      }
+    }
+  }
+
+  if (!input.loopsError) {
+    const proactive = new Set(['queued', 'launched', 'asked', 'hitl', 'shadow', 'attempting']);
+    for (const row of input.loops ?? []) {
+      if (!inWindow(row.at)) continue;
+      const day = proactKstDay(row.at);
+      const id = row.id ?? `${row.seat}:${row.at}`;
+      const link = `loop://${row.file}#${id}`;
+      const title = row.title ?? `${row.seat} ${row.status}`;
+      if (proactive.has(row.status) || row.action === 'decision' || row.action === 'harness') {
+        offered.push(sample(day, 'offered', 'loop', id, row.at, `${proactKind(title, row.action)}:${title}`, link));
+        if (row.status === 'launched' || row.status === 'queued' || row.action === 'decision') {
+          adopted.push(sample(day, 'adopted', 'loop', id, row.at, title, link));
+        }
+      }
+    }
+  }
+
+  const tally = new Map<string, { day: string; offered: number; adopted: number; asked: number }>(window.days.map(day => [day, { day, offered: 0, adopted: 0, asked: 0 }]));
+  for (const row of offered) tally.get(row.day)!.offered += 1;
+  for (const row of adopted) {
+    const cell = tally.get(row.day);
+    if (cell) cell.adopted += 1;
+  }
+  for (const row of asked) tally.get(row.day)!.asked += 1;
+  const pick = (rows: ProactSample[]) => {
+    const seen = new Set<string>();
+    const out: ProactSample[] = [];
+    for (const source of ['decision', 'directive', 'coord', 'loop'] as const) {
+      for (const row of rows.filter(item => item.source === source).sort((a, b) => b.at.localeCompare(a.at) || a.id.localeCompare(b.id))) {
+        if (seen.has(row.link)) continue;
+        seen.add(row.link);
+        out.push(row);
+        if (out.length === 2) break;
+      }
+    }
+    return out;
+  };
+  const status = (error: string | undefined, read: boolean): ProactSourceStatus => error ? { read: false, reason: error } : { read };
+  return {
+    since: window.since, until: window.until,
+    days: window.days.map(day => tally.get(day)!),
+    samples: [...pick(offered), ...pick(adopted), ...pick(asked)],
+    sources: {
+      decision: status(input.decisionsError, !input.decisionsError),
+      directive: status(input.directivesError, !input.directivesError),
+      coord: status(input.coordError, !input.coordError),
+      loop: status(input.loopsError, !input.loopsError),
+    },
+  };
+}
+
+function readLoopRows(root: string, days: readonly string[]): ProactLoopRow[] {
+  const base = join(root, 'seat-loop');
+  const seats = readdirSync(base, { withFileTypes: true }).filter(entry => entry.isDirectory()).map(entry => entry.name);
+  const rows: ProactLoopRow[] = [];
+  for (const seat of seats) {
+    for (const day of days) {
+      const file = join(base, seat, `${day}.jsonl`);
+      let text = '';
+      try { text = readFileSync(file, 'utf8'); } catch (error) {
+        if ((error as NodeJS.ErrnoException).code === 'ENOENT') continue;
+        throw error;
+      }
+      for (const line of text.split('\n')) {
+        if (!line.trim()) continue;
+        const parsed = JSON.parse(line) as { at?: string; ts?: string; status?: string; action?: string; item?: { id?: string; title?: string } };
+        const at = parsed.at ?? parsed.ts;
+        if (!at || !parsed.status) continue;
+        rows.push({ seat, at, status: parsed.status, action: parsed.action, id: parsed.item?.id, title: parsed.item?.title, file });
+      }
+    }
+  }
+  return rows;
+}
+
+export interface ProactMeterDeps {
+  readonly now?: Date;
+  readonly days?: number;
+  readonly stateDir?: string;
+  readonly instanceRoot?: string;
+  readonly readDecisions?: () => { decisions: DecisionEntry[]; seatDecisions: SeatDecisionRecord[] };
+  readonly readDirectives?: (since: string, until: string) => DirectiveRow[];
+  readonly readCoord?: (since: string) => CoordEvent[];
+  readonly readLoops?: (days: readonly string[]) => ProactLoopRow[];
+}
+
+/** Read the four ledgers. A source that cannot be opened is reported, never counted as zero evidence. */
+export function readProactMeter(deps: ProactMeterDeps = {}): ProactMeter {
+  const now = deps.now ?? new Date();
+  const window = proactWindow(now, deps.days ?? 7);
+  const input: ProactMeterInput = {};
+  const stateDir = deps.stateDir;
+  try {
+    const read = deps.readDecisions ?? (() => {
+      const ledger = new DecisionLedger(stateDir ? { stateDir } : {});
+      return { decisions: ledger.list({ status: 'all', since: window.since }), seatDecisions: ledger.seatReport({ since: window.since }) };
+    });
+    const got = read();
+    input.decisions = got.decisions;
+    input.seatDecisions = got.seatDecisions;
+  } catch (error) { input.decisionsError = error instanceof Error ? error.message : String(error); }
+  try {
+    input.directives = (deps.readDirectives ?? ((since, until) => {
+      const index = openDirectiveIndex(stateDir);
+      try { return index.search('', { since, until, limit: 1000 }); }
+      finally { index.close(); }
+    }))(window.since, window.until);
+  } catch (error) { input.directivesError = error instanceof Error ? error.message : String(error); }
+  try {
+    input.coord = (deps.readCoord ?? ((since) => listCoordEvents({ since, channelOnly: true })))(window.since);
+  } catch (error) { input.coordError = error instanceof Error ? error.message : String(error); }
+  try {
+    const loopRoot = deps.instanceRoot ?? stateDir ?? effectiveInstanceRoot() ?? elanousStateRoot();
+    input.loops = (deps.readLoops ?? ((days) => readLoopRows(loopRoot, days)))(window.days);
+  } catch (error) { input.loopsError = error instanceof Error ? error.message : String(error); }
+  return measureProact(input, now, deps.days ?? 7);
+}
+
+export function formatProactMeter(meter: ProactMeter): string {
+  const lines = [`선제성 ${meter.since} ~ ${meter.until}`, '날짜 · 먼저 냄 · 채택 · 물어서야'];
+  for (const day of meter.days) lines.push(`${day.day} · ${day.offered} · ${day.adopted} · ${day.asked}`);
+  const unread = (Object.entries(meter.sources) as Array<[ProactSource, ProactSourceStatus]>).filter(([, status]) => !status.read);
+  if (unread.length) lines.push(`못 읽음: ${unread.map(([name, status]) => `${name}(${status.reason})`).join(' · ')}`);
+  if (meter.samples.length) {
+    lines.push('표본:');
+    for (const row of meter.samples) lines.push(`  ${row.bucket} · ${row.source} · ${row.id} · ${row.link}`);
+  }
+  return lines.join('\n');
+}

package/src/decisions/proact1-lite.ts

@@ -0,0 +1,86 @@
+import type { DecisionEntry } from './decision-ledger.js';
+import type { ChecklistItem } from '../release-loop/checklist.js';
+import type { ReleaseSchedule } from '../release-loop/release-schedule.js';
+import type { DraftSweepResult, SweepDraft } from '../self-dev/draft-sweep.js';
+
+type ProactLoop = { readonly name: string; readonly state: 'alive' | 'late' | 'failing' | 'off' | 'unknown'; readonly scope?: string };
+type ProactYellow = { readonly version: string; readonly item: Pick<ChecklistItem, 'id' | 'title' | 'status'> };
+type ProactDrafts = { readonly drafts: readonly Pick<SweepDraft, 'number' | 'title'>[]; readonly sweep: Pick<DraftSweepResult, 'complete' | 'entries'> };
+export interface ProactSignals {
+  /** A suspended run (resume) or an explicitly observed blocker, not merely an old open card. */
+  readonly decisions?: readonly (Pick<DecisionEntry, 'id' | 'title' | 'status' | 'raisedAt' | 'importedAt' | 'resume'> & { readonly blocked?: boolean })[];
+  readonly yellow?: readonly ProactYellow[];
+  readonly schedules?: readonly Pick<ReleaseSchedule, 'version' | 'landBy'>[];
+  readonly loops?: readonly ProactLoop[];
+  /** Only a complete, read-only runDraftSweep({ apply: false }) assessment proves draft staleness. */
+  readonly draftAssessment?: ProactDrafts;
+}
+type ProactSuggestion = {
+  readonly key: string;
+  readonly kind: 'decision' | 'yellow' | 'loop' | 'draft';
+  readonly title: string;
+  readonly reason: string;
+  readonly source: string;
+  readonly score: number;
+};
+
+const HOUR = 3_600_000;
+const DECISION_AGE_HOURS = 24;
+const LANDING_WINDOW_HOURS = 24;
+const MAX_SUGGESTIONS = 3;
+
+/** Rules-only, read-only selection. Missing/invalid observations are unknown, never evidence of urgency. */
+export function selectProact1Lite(signals: ProactSignals, options: { now: Date; previouslySuggested?: ReadonlySet<string> }): ProactSuggestion[] {
+  const now = options.now.getTime();
+  if (!Number.isFinite(now)) throw new Error('valid now required');
+  const candidates: ProactSuggestion[] = [];
+  const elapsedHours = (iso: string | undefined): number => iso ? (now - Date.parse(iso)) / HOUR : NaN;
+  const valid = (text: string): boolean => text.trim().length > 0;
+
+  for (const card of signals.decisions ?? []) {
+    if (card.status !== 'open' || (card.blocked !== true && !card.resume) || !valid(card.id) || !valid(card.title)) continue;
+    // Imported historical cards have no known raise time; their import time is a lower bound on age.
+    const age = elapsedHours(card.raisedAt ?? card.importedAt);
+    if (!Number.isFinite(age) || age < DECISION_AGE_HOURS) continue;
+    candidates.push({ key: `decision:${card.id}`, kind: 'decision', title: card.title,
+      reason: `열린 결정 ${Math.floor(age)}시간 대기${card.raisedAt ? '' : ' (가져온 시각 기준)'}`,
+      source: card.id, score: 400 + Math.min(100, Math.floor(age / 24)) });
+  }
+
+  const deadlines = new Map((signals.schedules ?? []).map(schedule => [schedule.version, schedule.landBy]));
+  for (const { version, item } of signals.yellow ?? []) {
+    if (item.status !== 'yellow' || !valid(item.id) || !valid(item.title) || !valid(version)) continue;
+    const landBy = deadlines.get(version);
+    const remaining = landBy ? (Date.parse(landBy) - now) / HOUR : NaN;
+    if (!Number.isFinite(remaining) || remaining > LANDING_WINDOW_HOURS) continue;
+    candidates.push({ key: `yellow:${version}:${item.id}`, kind: 'yellow', title: item.title,
+      reason: remaining < 0 ? `착지 마감 ${Math.ceil(-remaining)}시간 경과` : `착지 마감 ${Math.ceil(remaining)}시간 전`,
+      source: `${version}/${item.id} · ${landBy}`, score: 500 + Math.min(100, Math.max(0, Math.ceil(-remaining))) });
+  }
+
+  for (const loop of signals.loops ?? []) {
+    if (loop.state !== 'late' || !valid(loop.name)) continue;
+    candidates.push({ key: `loop:${loop.scope ?? ''}:${loop.name}`, kind: 'loop', title: loop.name,
+      reason: '루프 실행 지연 관측', source: `${loop.scope ?? 'loop'}/${loop.name}`, score: 300 });
+  }
+
+  const assessment = signals.draftAssessment;
+  if (assessment?.sweep.complete) {
+    const drafts = new Map(assessment.drafts.map(draft => [draft.number, draft]));
+    for (const entry of assessment.sweep.entries) {
+      // A stale assessment is not a request to close: only surface the already-verified signal.
+      if (entry.action !== 'close' || entry.applied || !['stale-unobserved', 'claim-expired', 'claim-expired (self-implement.result final; worktree is not live)'].includes(entry.reason)) continue;
+      const draft = drafts.get(entry.number);
+      if (!draft || !valid(draft.title)) continue;
+      candidates.push({ key: `draft:${entry.number}`, kind: 'draft', title: draft.title,
+        reason: `draft PR 정체 (${entry.reason})`, source: `#${entry.number}`, score: 200 });
+    }
+  }
+
+  const selected = new Map<string, ProactSuggestion>();
+  for (const candidate of candidates) {
+    if (options.previouslySuggested?.has(candidate.key)) continue;
+    if (!selected.has(candidate.key) || selected.get(candidate.key)!.score < candidate.score) selected.set(candidate.key, candidate);
+  }
+  return [...selected.values()].sort((a, b) => b.score - a.score || a.key.localeCompare(b.key)).slice(0, MAX_SUGGESTIONS);
+}

package/src/decisions/web-push-decision-cards.ts

@@ -28,7 +28,7 @@ export function webPushDecisionTransport(
       const recommendation = 'skipped' in entry.recommendation ? '추천안 없음' : `추천안: ${entry.recommendation.option.toUpperCase()}`;
       const body = `${recommendation}${entry.dueAt ? ` · 기한: ${new Intl.DateTimeFormat('ko-KR', { timeZone: 'Asia/Seoul', month: 'numeric', day: 'numeric', hour: '2-digit', minute: '2-digit', hour12: false }).format(new Date(entry.dueAt))}` : ''}`;
       const result = await push({ title: title('대표 결정 · ', entry.title), body, url: url(id), tag: tag(id) });
-      debug.log('decisions.webpush', 'card-sent', { id, delivered: result.delivered });
+      if (result.attempted) debug.log('decisions.webpush', 'card-sent', { id, delivered: result.delivered });
       return result.delivered ? { chat: 'webpush', message: id } : null;
     },
     edit: async (ref, _view) => {

package/src/domains/alert-audit.ts

@@ -0,0 +1,271 @@
+// 대표에게 가는 알림·브리핑 전수 재고 (ALERT-AUDIT).
+//
+// «전달 ok» 는 발송 시도 기록이다. 도착은 배송 원장의 채널 ok 한 건뿐이다.
+// 발송 설정이 꺼져 있으면 시도 기록만 남고 도착은 0건이 된다 — 그 칸을
+// claimed-without-arrival 로 표시한다. 같은 내용이 둘 이상의 채널·봇에
+// 도착하면 overlap, 레지스트리에 있는데 아무도 안 보내면 gap.
+
+import type { ScheduleRow } from './schedule-registry.js';
+import type { DeliveryRow } from '../nexus/outbound/delivery-ledger.js';
+
+export type AlertSenderKind = 'loop' | 'cron' | 'script';
+export type AlertMark = 'claimed-without-arrival' | 'overlap' | 'gap' | 'overlap-unknown' | 'none';
+
+export interface AlertSenderRef {
+  kind: AlertSenderKind;
+  id: string;
+}
+
+export interface AlertRegistrySender {
+  kind: AlertSenderKind;
+  id: string;
+  /** 대표에게 보내는 알림·브리핑이면 true. false 는 대조 모집단에서 빠진다. */
+  representative: boolean;
+  what: string;
+  when: string;
+  channel: string;
+  bot: string;
+  /** 같은 내용으로 겹치는지 가르는 키. 비면 겹침은 미상이다. */
+  contentKey?: string;
+}
+
+export interface AlertClaim {
+  sender: AlertSenderRef;
+  what: string;
+  when: string;
+  channel: string;
+  bot: string;
+  contentKey?: string;
+  /** «전달 ok» 류의 발송 기록. 도착 증거가 아니다. */
+  recordedOk: boolean;
+  /** 발송 기록 시각. 도착이 없을 때 표의 «언제»는 이 시각이다. */
+  at?: string;
+}
+
+export interface AlertArrival {
+  sender: AlertSenderRef;
+  what: string;
+  channel: string;
+  bot: string;
+  contentKey?: string;
+  /** 채널이 실제로 받았다고 원장에 남은 시각. */
+  arrivedAt: string;
+  ok: boolean;
+}
+
+export interface AlertAuditInput {
+  registry: readonly AlertRegistrySender[];
+  /** 크론 레지스트리. representative 크론 발신자가 여기 없으면 누락이다. */
+  crons: readonly Pick<ScheduleRow, 'id' | 'name' | 'cron' | 'command' | 'enabled'>[];
+  /** 루프 레지스트리 id. representative 루프 발신자가 여기 없으면 누락이다. */
+  loops: readonly { id: string }[];
+  claims: readonly AlertClaim[];
+  arrivals: readonly AlertArrival[];
+}
+
+export interface AlertAuditRow {
+  who: string;
+  senderKind: AlertSenderKind;
+  senderId: string;
+  what: string;
+  when: string;
+  channel: string;
+  bot: string;
+  lastArrivedAt: string | null;
+  marks: AlertMark[];
+}
+
+export interface AlertAudit {
+  rows: AlertAuditRow[];
+  /** 레지스트리 representative 발신자 중 크론·루프 대조에서 빠진 수. 스크립트는 대조 대상이 아니다. */
+  missingFromRegistry: number;
+  missingSenders: AlertSenderRef[];
+  claimedWithoutArrival: AlertAuditRow[];
+  overlaps: AlertAuditRow[];
+  gaps: AlertAuditRow[];
+  /** contentKey 를 모르는 도착이 있어 겹침을 판정하지 못한 행. */
+  overlapUnknown: AlertAuditRow[];
+  verdict: 'pass' | 'fail';
+}
+
+export interface DeliveryArrivalView {
+  sender: AlertSenderRef;
+  what: string;
+  channel: string;
+  bot: string;
+  contentKey?: string;
+}
+
+const MARK_ORDER: AlertMark[] = ['claimed-without-arrival', 'overlap', 'gap', 'overlap-unknown'];
+
+function senderKey(sender: AlertSenderRef): string {
+  return `${sender.kind}:${sender.id}`;
+}
+
+/** 세 표시(+미상)를 MARK_ORDER 순으로 남긴다. none 은 표시가 없을 때만. */
+export function markOrder(marks: readonly AlertMark[]): AlertMark[] {
+  const ordered = MARK_ORDER.filter(mark => marks.includes(mark));
+  return ordered.length ? ordered : ['none'];
+}
+
+function knownContentKey(item: { contentKey?: string }): string | null {
+  const key = item.contentKey?.trim();
+  return key ? key : null;
+}
+
+function latestIso(values: readonly string[]): string | null {
+  const finite = values.filter(value => Number.isFinite(Date.parse(value)));
+  if (!finite.length) return null;
+  return finite.reduce((best, value) => Date.parse(value) > Date.parse(best) ? value : best);
+}
+
+function marksOf(row: { claimedWithoutArrival: boolean; overlap: boolean; gap: boolean; overlapUnknown: boolean }): AlertMark[] {
+  return markOrder([
+    ...(row.claimedWithoutArrival ? ['claimed-without-arrival' as const] : []),
+    ...(row.overlap ? ['overlap' as const] : []),
+    ...(row.gap ? ['gap' as const] : []),
+    ...(row.overlapUnknown ? ['overlap-unknown' as const] : []),
+  ]);
+}
+
+/** 배송 원장에서 ok 채널만 도착으로 읽는다. 실패 채널·빈 채널은 도착이 아니다. */
+export function arrivalsFromDeliveries(
+  rows: readonly DeliveryRow[],
+  view: (row: DeliveryRow) => DeliveryArrivalView | null,
+): AlertArrival[] {
+  const arrivals: AlertArrival[] = [];
+  for (const row of rows) {
+    let channels: Array<{ type?: unknown; ok?: unknown; bot?: unknown }> = [];
+    try { channels = JSON.parse(row.channels) as typeof channels; } catch { channels = []; }
+    const mapped = view(row);
+    if (!mapped) continue;
+    const okChannels = channels.filter(channel => channel.ok === true);
+    if (!okChannels.length) continue;
+    const bots = [...new Set(okChannels.map(channel => typeof channel.bot === 'string' && channel.bot ? channel.bot : mapped.bot))];
+    for (const bot of bots) {
+      arrivals.push({
+        sender: mapped.sender,
+        what: mapped.what,
+        channel: mapped.channel,
+        bot,
+        ...(mapped.contentKey ? { contentKey: mapped.contentKey } : {}),
+        arrivedAt: row.ts,
+        ok: true,
+      });
+    }
+  }
+  return arrivals;
+}
+
+/** 발신자 전수를 한 장으로 접는다. 판정은 누락 0 이고, 세 표시는 행에 남는다. */
+export function auditAlerts(input: AlertAuditInput): AlertAudit {
+  const cronIds = new Set(input.crons.map(row => row.id));
+  const loopIds = new Set(input.loops.map(row => row.id));
+  const representative = input.registry.filter(sender => sender.representative);
+  const missingSenders = representative.filter(sender => {
+    if (sender.kind === 'cron') return !cronIds.has(sender.id);
+    if (sender.kind === 'loop') return !loopIds.has(sender.id);
+    return false;
+  }).map(sender => ({ kind: sender.kind, id: sender.id }));
+
+  const arrivalsBySender = new Map<string, AlertArrival[]>();
+  for (const arrival of input.arrivals) {
+    if (!arrival.ok) continue;
+    const key = senderKey(arrival.sender);
+    const list = arrivalsBySender.get(key) ?? [];
+    list.push(arrival);
+    arrivalsBySender.set(key, list);
+  }
+  const claimsBySender = new Map<string, AlertClaim[]>();
+  for (const claim of input.claims) {
+    const key = senderKey(claim.sender);
+    const list = claimsBySender.get(key) ?? [];
+    list.push(claim);
+    claimsBySender.set(key, list);
+  }
+
+  const overlapKeys = new Set<string>();
+  const byContent = new Map<string, Set<string>>();
+  for (const arrival of input.arrivals) {
+    if (!arrival.ok) continue;
+    const key = knownContentKey(arrival);
+    if (!key) continue;
+    const routes = byContent.get(key) ?? new Set<string>();
+    routes.add(`${arrival.channel}|${arrival.bot}`);
+    byContent.set(key, routes);
+    if (routes.size >= 2) overlapKeys.add(key);
+  }
+
+  const rows: AlertAuditRow[] = representative.map(sender => {
+    const key = senderKey(sender);
+    const arrivals = arrivalsBySender.get(key) ?? [];
+    const claims = claimsBySender.get(key) ?? [];
+    const recordedOk = claims.some(claim => claim.recordedOk);
+    const claimedWithoutArrival = recordedOk && arrivals.length === 0;
+    const gap = !recordedOk && arrivals.length === 0;
+    const registryKey = knownContentKey(sender);
+    const arrivalKeys = arrivals.map(arrival => arrival.contentKey !== undefined ? knownContentKey(arrival) : registryKey);
+    const claimKeys = claims.map(claim => claim.contentKey !== undefined ? knownContentKey(claim) : registryKey);
+    const overlap = arrivalKeys.some(contentKey => contentKey !== null && overlapKeys.has(contentKey));
+    const overlapUnknown = !overlap && (
+      arrivals.some((_, index) => arrivalKeys[index] === null)
+      || (arrivals.length === 0 && claims.some((_, index) => claimKeys[index] === null && claims[index]?.recordedOk))
+    );
+    const last = latestIso(arrivals.map(arrival => arrival.arrivedAt));
+    const recorded = claims.find(claim => claim.recordedOk) ?? claims[0];
+    const channel = arrivals[0]?.channel ?? recorded?.channel ?? sender.channel;
+    const bot = arrivals[0]?.bot ?? recorded?.bot ?? sender.bot;
+    const what = arrivals[0]?.what ?? recorded?.what ?? sender.what;
+    const when = last ?? recorded?.at ?? recorded?.when ?? sender.when;
+    return {
+      who: `${sender.kind}:${sender.id}`,
+      senderKind: sender.kind,
+      senderId: sender.id,
+      what,
+      when,
+      channel,
+      bot,
+      lastArrivedAt: last,
+      marks: marksOf({ claimedWithoutArrival, overlap, gap, overlapUnknown }),
+    };
+  }).sort((a, b) => a.who.localeCompare(b.who) || a.what.localeCompare(b.what));
+
+  const claimedWithoutArrival = rows.filter(row => row.marks.includes('claimed-without-arrival'));
+  const overlaps = rows.filter(row => row.marks.includes('overlap'));
+  const gaps = rows.filter(row => row.marks.includes('gap'));
+  const overlapUnknown = rows.filter(row => row.marks.includes('overlap-unknown'));
+  return {
+    rows,
+    missingFromRegistry: missingSenders.length,
+    missingSenders,
+    claimedWithoutArrival,
+    overlaps,
+    gaps,
+    overlapUnknown,
+    verdict: missingSenders.length === 0 ? 'pass' : 'fail',
+  };
+}
+
+/** 한 장의 표. 세 표시가 비면 «없음» 과 그 근거를 표 아래에 적는다. */
+export function formatAlertAudit(audit: AlertAudit): string {
+  const header = '| 누가 | 무엇을 | 언제 | 채널 | 봇 | 마지막 도착 | 표시 |';
+  const rule = '| --- | --- | --- | --- | --- | --- | --- |';
+  const body = audit.rows.map(row => {
+    const marks = markOrder(row.marks).filter(mark => mark !== 'none').join(', ') || 'none';
+    const arrived = row.lastArrivedAt ?? '없음';
+    return `| ${row.who} | ${row.what} | ${row.when} | ${row.channel} | ${row.bot} | ${arrived} | ${marks} |`;
+  });
+  const lines = [header, rule, ...body, '', `대조 누락: ${audit.missingFromRegistry}`, `판정: ${audit.verdict}`];
+  const note = (label: string, found: readonly AlertAuditRow[], emptyReason: string) => {
+    if (found.length) lines.push(`${label}: ${found.map(row => row.who).join(', ')}`);
+    else lines.push(`${label}: 없음 — ${emptyReason}`);
+  };
+  note('보낸다고 기록됐는데 도착 증거가 없는 것', audit.claimedWithoutArrival, 'recordedOk 인 발신자마다 도착이 있다');
+  if (audit.overlapUnknown.length) {
+    lines.push(`겹치는 것: 미상 — contentKey 를 모르는 도착이 있어 겹침을 판정하지 않음 (${audit.overlapUnknown.map(row => row.who).join(', ')})`);
+  } else {
+    note('겹치는 것', audit.overlaps, '같은 contentKey 가 둘 이상의 채널·봇에 도착한 적이 없다');
+  }
+  note('아무도 안 보내는 것', audit.gaps, 'representative 발신자는 모두 발송 기록이 있거나 도착이 있다');
+  return `${lines.join('\n')}\n`;
+}