elanous 0.2.14 → 0.2.16

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`;
+}

package/src/domains/core-tools.ts

@@ -30,7 +30,7 @@ import { LOGS_QUERY_SPEC, dispatchLogsQuery } from './logs-tool.js';
 import { MISSION_DECIDE_SPEC, dispatchMissionDecide } from '../autopilot/mission-decide-tool.js';
 import { COO_ADMIN_SPEC, dispatchCooAdmin } from './coo-admin-tool.js';
 import { RELEASE_STATUS_SPEC, RELEASE_CHANGE_SPEC, dispatchReleaseStatus, dispatchReleaseChange } from './release-tool.js';
-import { OPS_SEATS_SPEC, DECISIONS_PENDING_SPEC, dispatchOpsSeats, dispatchDecisionsPending } from './ops-facts-tool.js';
+import { OPS_SEATS_SPEC, DECISIONS_PENDING_SPEC, PROACT_METER_SPEC, dispatchOpsSeats, dispatchDecisionsPending, dispatchProactMeter } from './ops-facts-tool.js';
 
 /** memory_recall — 크로스서피스 기억(자기 발송 원장 회상). 도메인 무관(domain 필터는 옵션).
  *  finance-tools 에서 L2 로 이관(2026-07-08). */
@@ -142,7 +142,7 @@ const SELF_RECALL_BUDGET_SPEC: LLMToolSpec = {
     },
   },
 };
-export const CORE_TOOL_SPECS: LLMToolSpec[] = [SCHEDULE_MANAGE_SPEC, SESSION_MANAGE_SPEC, MEMORY_RECALL_SPEC, FACT_CHECK_SPEC, SELF_RECALL_BUDGET_SPEC, CONTEXT_NOW_SPEC, AUTOPILOT_MISSION_SPEC, OPS_STATUS_SPEC, SE_BUILD_SPEC, LOGS_QUERY_SPEC, MISSION_DECIDE_SPEC, COO_ADMIN_SPEC, RELEASE_STATUS_SPEC, RELEASE_CHANGE_SPEC, OPS_SEATS_SPEC, DECISIONS_PENDING_SPEC];
+export const CORE_TOOL_SPECS: LLMToolSpec[] = [SCHEDULE_MANAGE_SPEC, SESSION_MANAGE_SPEC, MEMORY_RECALL_SPEC, FACT_CHECK_SPEC, SELF_RECALL_BUDGET_SPEC, CONTEXT_NOW_SPEC, AUTOPILOT_MISSION_SPEC, OPS_STATUS_SPEC, SE_BUILD_SPEC, LOGS_QUERY_SPEC, MISSION_DECIDE_SPEC, COO_ADMIN_SPEC, RELEASE_STATUS_SPEC, RELEASE_CHANGE_SPEC, OPS_SEATS_SPEC, DECISIONS_PENDING_SPEC, PROACT_METER_SPEC];
 
 export interface CoreTools {
   specs: LLMToolSpec[];
@@ -159,10 +159,11 @@ export function buildCoreTools(recallSearch?: RecallSearch): CoreTools {
     names,
     dispatch: async (name, args, onPartial, context) => {
       const h = CORE_TOOL_HANDLERS[name];
-      if (!h && name !== 'release_change' && name !== 'ops_seats' && name !== 'decisions_pending') return { error: `unknown core tool: ${name}` };
+      if (!h && name !== 'release_change' && name !== 'ops_seats' && name !== 'decisions_pending' && name !== 'proact_meter') return { error: `unknown core tool: ${name}` };
       if (name === 'release_change') return dispatchReleaseChange(args, context);
       if (name === 'ops_seats') return dispatchOpsSeats(args, context);
       if (name === 'decisions_pending') return dispatchDecisionsPending(context);
+      if (name === 'proact_meter') return dispatchProactMeter(args, context);
       if (name === 'memory_recall' || name === 'self_recall') {
         return runRecall(name, args, context ?? { surface: 'skill' }, recallSearch, onPartial);
       }

package/src/domains/ops-facts-tool.ts

@@ -2,6 +2,7 @@ import type { LLMToolSpec } from '../llm.js';
 import type { ToolRuntimeContext } from '../tool-runtime/types.js';
 import { debug } from '../debug/log.js';
 import { DecisionLedger, type DecisionEntry } from '../decisions/decision-ledger.js';
+import { readProactMeter, type ProactMeter } from '../decisions/proact-meter.js';
 import { buildSeatsBoard, todayKst, type SeatsSources } from '../nexus/api/ops-seats.js';
 import { liveSeatsSources } from '../nexus/api/ops-seats-sources.js';
 
@@ -11,6 +12,12 @@ export const OPS_SEATS_SPEC: LLMToolSpec = {
   parameters: { type: 'object', properties: { date: { type: 'string', description: '조회할 KST 날짜 YYYY-MM-DD. 생략하면 KST 오늘.' } }, required: [] },
 };
 
+export const PROACT_METER_SPEC: LLMToolSpec = {
+  name: 'proact_meter',
+  description: '오너 전용 읽기 — 선제성 기준선. 지난 7 KST일마다 대표가 시키지 않고 시스템이 먼저 낸 수(offered), 그중 채택된 수(adopted), 대표가 먼저 물어서야 드러난 수(asked). 표본은 결정·지시·조율·루프 원문 링크를 가진다. 못 읽은 원천은 sources.read=false 이며 0이 아니다.',
+  parameters: { type: 'object', properties: { days: { type: 'number', description: 'KST 일수. 생략하면 7.' } }, required: [] },
+};
+
 export const DECISIONS_PENDING_SPEC: LLMToolSpec = {
   name: 'decisions_pending',
   description: '오너 전용 읽기 — 결정 원장의 열린 결정을 기한 순으로 조회한다. 결정 선택·기록은 하지 않는다.',
@@ -21,13 +28,14 @@ export interface OpsFactsDeps {
   seatsSources?: () => SeatsSources;
   listDecisions?: (filters: { status: 'open' }) => DecisionEntry[];
   today?: () => string;
+  readProact?: (days: number) => ProactMeter;
 }
 
 function ownerVerified(context?: ToolRuntimeContext): boolean {
   return context?.requestOrigin !== 'external-agent' && !!context?.sessionId && !!context?.verifiedOwner?.id.trim();
 }
 
-function logCall(tool: 'ops_seats' | 'decisions_pending', ok: boolean, nulls: number): void {
+function logCall(tool: 'ops_seats' | 'decisions_pending' | 'proact_meter', ok: boolean, nulls: number): void {
   debug.log('ops.facts', 'call', { tool, ok, nulls });
 }
 
@@ -56,6 +64,28 @@ export async function dispatchOpsSeats(args: Record<string, unknown>, context?:
   }
 }
 
+/** Seven KST days. An unreadable ledger stays sources.read=false; it is not a zero day. */
+export function dispatchProactMeter(args: Record<string, unknown>, context?: ToolRuntimeContext, deps: OpsFactsDeps = {}) {
+  if (!ownerVerified(context)) {
+    logCall('proact_meter', false, 0);
+    return { error: '오너 확인이 필요한 조회다' };
+  }
+  const days = args.days === undefined ? 7 : args.days;
+  if (typeof days !== 'number' || !Number.isInteger(days) || days < 1 || days > 31) {
+    logCall('proact_meter', false, 0);
+    return { error: 'days 는 1 이상 31 이하의 정수여야 한다' };
+  }
+  try {
+    const meter = (deps.readProact ?? ((n: number) => readProactMeter({ days: n })))(days);
+    const unread = Object.values(meter.sources).filter(source => !source.read).length;
+    logCall('proact_meter', true, unread);
+    return meter;
+  } catch {
+    logCall('proact_meter', false, 1);
+    return { error: '선제성 원장을 읽지 못했다', days: null };
+  }
+}
+
 /** Only the five requested fields leave the decision ledger. Undated entries follow dated entries. */
 export function dispatchDecisionsPending(context?: ToolRuntimeContext, deps: OpsFactsDeps = {}) {
   if (!ownerVerified(context)) {

package/src/flow-loop/split.ts

@@ -0,0 +1,24 @@
+import type { TaskCard } from '../task-cards/card-store.js';
+
+export interface SplitCell { id: string; title: string; seat?: string; host?: string }
+
+/** FLOW1: only explicitly assigned work may enter a seat's queue. The same proposal is used in shadow and live. */
+export function splitCard(card: TaskCard, _opts: { shadow?: boolean } = {}): SplitCell[] {
+  const intake = [...card.sections].reverse().find(section => section.key.startsWith('intake:wish:'));
+  let text = card.title;
+  if (intake) {
+    let body: unknown;
+    try { body = JSON.parse(intake.content); } catch { body = intake.content; }
+    if (typeof body === 'string') text = body;
+    else if (body && typeof body === 'object' && typeof (body as { text?: unknown }).text === 'string') text = (body as { text: string }).text;
+  }
+  const lines = text.split(/\r?\n/).map(line => line.trim()).filter(Boolean);
+  const cells: SplitCell[] = lines.map((line, index) => {
+    const match = /^(?:[-*]|\d+[.)])?\s*\[(OP|MK|TC|UX)\]\s*(.+)$/u.exec(line);
+    if (match) return { id: `${card.id}-${index + 1}`, title: match[2]!.trim(), seat: match[1]! };
+    // 담당 없는 행도 칸으로 남긴다 — seat 가 없으니 대기열엔 못 들어가고 tick 이 unplaced-no-owner 로 센다.
+    return { id: `${card.id}-${index + 1}`, title: line.replace(/^(?:[-*]|\d+[.)])\s*/u, '') };
+  });
+  // 의뢰 본문이 있으면 담당이 하나도 없어도 행마다 칸으로 남긴다. 본문 없이 제목뿐일 때만 카드 한 칸.
+  return intake || cells.some(cell => cell.seat) ? cells : [{ id: card.id, title: card.title }];
+}