elanous 0.2.14 → 0.2.16

package/src/context-bus/context-now-public.ts

@@ -2,21 +2,30 @@ import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { checkBrand } from '../../scripts/brand/check.js';
+import { debug } from '../debug/log.js';
 import type { ContextFact, ContextNowAnswer } from './context-now.js';
 
 const internalItem = (count: number) => `내부 항목 ${count}개`;
 const seatNames: Record<string, string> = { OP: '운영', TC: '기술', MK: '마케팅', UX: '사용자 경험' };
 
 /** Public copy only: no raw ledger identifiers or private sources in the rendered answer. */
-export function filterPublicDemoContext(answer: ContextNowAnswer): ContextNowAnswer {
+export function filterPublicDemoContext(answer: ContextNowAnswer, brandCheck: typeof checkBrand = checkBrand): ContextNowAnswer {
   const dir = mkdtempSync(join(tmpdir(), 'context-now-public-'));
   const file = join(dir, 'text.txt');
   try {
+    let rulesMissing = brandCheck('public-docs', []).missing;
+    const logMissing = () => debug.log('context.now', 'brand-rules-missing', { audience: 'public-demo' });
+    if (rulesMissing) logMissing();
     const flagged = (texts: string[]): Set<number> => {
+      if (rulesMissing) return new Set(texts.map((_, index) => index));
       if (!texts.length) return new Set();
       writeFileSync(file, texts.map(text => text.replace(/[\r\n]+/g, ' ')).join('\n') + '\n');
-      const result = checkBrand('public-docs', [file]);
-      if (result.missing) throw new Error('brand rules missing');
+      const result = brandCheck('public-docs', [file]);
+      if (result.missing) {
+        rulesMissing = true;
+        logMissing();
+        return new Set(texts.map((_, index) => index));
+      }
       return new Set(result.findings.map(finding => finding.line - 1));
     };
     const publicText = (value: string): string => value
@@ -60,8 +69,9 @@ export function filterPublicDemoContext(answer: ContextNowAnswer): ContextNowAns
             status: safe(fact.status, '진행 중'), source: source(fact.source) });
       } else if (fact.kind === 'seat') {
         facts.push({ ...fact, seat: safe(fact.seat, '공개 담당'), status: safe(fact.status, '진행 중'),
-          id: fact.id ? (privateIds.has(fact.id) ? '내부 항목' : safe(fact.id, '공개 항목')) : null,
-          title: fact.title ? (privateIds.has(fact.id ?? '') ? '내부 항목' : safe(fact.title, '공개 항목')) : null, source: source(fact.source) });
+          id: fact.id ? (rulesMissing || privateIds.has(fact.id) ? '내부 항목' : safe(fact.id, '공개 항목')) : null,
+          title: fact.title === null ? null : rulesMissing ? internalItem(1) : privateIds.has(fact.id ?? '') ? '내부 항목' : safe(fact.title, '공개 항목'),
+          source: source(fact.source) });
       } else facts.push({ ...fact, version: safe(fact.version, '공개 판'), source: source(fact.source) });
     }
     for (const kind of ['cell', 'decision'] as const) {
@@ -78,7 +88,7 @@ export function filterPublicDemoContext(answer: ContextNowAnswer): ContextNowAns
       events: answer.events.map(event => ({ ...event, kind: safe(event.kind, '소식'),
         summary: publicField(event.summary, '공개 소식'), source: source(event.source) })),
       guide: answer.guide.map(text => publicField(text, '공개 안내')),
-      hiddenCount: collapsed.cell + collapsed.decision,
+      hiddenCount: collapsed.cell + collapsed.decision + (rulesMissing ? answer.facts.filter(fact => fact.kind === 'seat' && fact.title !== null).length : 0),
     };
   } finally {
     rmSync(dir, { recursive: true, force: true });

package/src/context-bus/context-now.ts

@@ -1,4 +1,5 @@
 import { existsSync, readFileSync } from 'node:fs';
+import { checkBrand } from '../../scripts/brand/check.js';
 import { debug, redactSecretText } from '../debug/log.js';
 import { DecisionLedger, type DecisionEntry } from '../decisions/decision-ledger.js';
 import { listChecklist, devVersion, type Checklist } from '../release-loop/checklist.js';
@@ -22,6 +23,7 @@ export interface ContextNowDeps {
   decisions?: () => DecisionEntry[];
   seatEntries?: (now: Date) => Array<{ entry: SeatEntry; source: string }>;
   events?: (since: string) => CoordEvent[];
+  brandCheck?: typeof checkBrand;
 }
 
 function todaySeatEntries(now: Date): Array<{ entry: SeatEntry; source: string }> {
@@ -101,5 +103,5 @@ export function contextNow(options: { topic?: string; limit?: number; audience?:
     .map(event => `📌 ${event.summary} — ${event.source}`);
   const answer = { at, topic, facts: boundedFacts, events: selectedEvents, guide };
   debug.log('context.now', 'answer', { topic, facts: answer.facts, events: answer.events });
-  return options.audience === 'public-demo' ? filterPublicDemoContext(answer) : answer;
+  return options.audience === 'public-demo' ? filterPublicDemoContext(answer, deps.brandCheck) : answer;
 }

package/src/context-bus/coord-events.ts

@@ -1,4 +1,4 @@
-import type { Database } from 'bun:sqlite';
+import { Database } from 'bun:sqlite';
 import { readFileSync, existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { debug, redactSecretText } from '../debug/log.js';
@@ -99,12 +99,14 @@ export function recordCoordEvent(input: CoordEventInput, deps: { db?: Database }
 }
 
 /** Read-only chronological list; a missing store is an empty ledger, not a newly created one. */
-export function listCoordEvents(opts: { since: string; seat?: string }, deps: { db?: Database } = {}): CoordEvent[] {
+export function listCoordEvents(opts: { since: string; seat?: string; channelOnly?: boolean }, deps: { db?: Database } = {}): CoordEvent[] {
   if (!deps.db && !existsSync(surfaceEventsDbPath())) return [];
-  const db = deps.db ?? openSurfaceEventsDb();
+  const db = deps.db ?? (opts.channelOnly
+    ? new Database(surfaceEventsDbPath(), { readonly: true, strict: true })
+    : openSurfaceEventsDb());
   try {
     const rows = db.prepare(`SELECT id, ts, text, summary, kind, refs FROM events
-      WHERE surface IN ('coord:channel', 'context:external', 'context:session') AND direction='outbound' AND ts>=?
+      WHERE surface ${opts.channelOnly ? "= 'coord:channel'" : "IN ('coord:channel', 'context:external', 'context:session')"} AND direction='outbound' AND ts>=?
       ${opts.seat ? "AND json_extract(refs,'$.seat')=?" : ''} ORDER BY ts ASC, rowid ASC`)
       .all(...(opts.seat ? [opts.since, opts.seat] : [opts.since])) as Array<{
         id: string; ts: string; text: string; summary: string; kind: string; refs: string;

package/src/decisions/decision-cards.ts

@@ -28,6 +28,7 @@ export interface CardTransport {
 const IRREVERSIBLE = new Set(['money', 'publish', 'security', 'irreversible', 'secret']);
 export const DECISION_DATA_PREFIX = 'dec:';
 const REMIND_BEFORE_MS = 2 * 3600_000;
+const WEBPUSH_MAX_SEND_ATTEMPTS = 3;
 
 export function isIrreversible(entry: Pick<DecisionEntry, 'category'>): boolean {
   return IRREVERSIBLE.has(entry.category);
@@ -99,7 +100,8 @@ interface CardState {
   /** First start of this platform's service — decisions raised before it are not pushed (no burst of old items at
    *  deploy); they stay reachable through `/decisions`. */
   since?: string;
-  cards: Record<string, { refs: CardRef[]; closed?: boolean; remindedAt?: string; note?: string }>;
+  cards: Record<string, { refs: CardRef[]; closed?: boolean; remindedAt?: string; note?: string; attempts?: number; noSubscribers?: boolean }>;
+  testOriginQuestions?: Record<string, true>;
 }
 
 export interface DecisionCardServiceOptions {
@@ -165,16 +167,27 @@ export class DecisionCardService {
       for (const record of pending.questions) {
         for (const question of record.questions) {
           const data = { questionId: record.id, runId: record.runId };
+          const logSkip = (reason: string): void => debug.log('hitl.card-bridge', 'skipped', { ...data, reason });
+          // Path is not provenance: operational goals can live under the OS temporary directory too.
+          if (record.testOrigin === true) {
+            state.testOriginQuestions ??= {};
+            if (!state.testOriginQuestions[record.id]) {
+              state.testOriginQuestions[record.id] = true;
+              dirty = true;
+              debug.log('hitl.card-bridge', 'skipped', { ...data, reason: 'test-origin' });
+            }
+            continue;
+          }
           if (record.expiresAt && record.expiresAt <= this.now().toISOString()) {
-            debug.log('hitl.card-bridge', 'skipped', { ...data, reason: 'expired' });
+            logSkip('expired');
             continue;
           }
           if (question.impact !== 'high' && question.impact !== 'critical') {
-            debug.log('hitl.card-bridge', 'skipped', { ...data, reason: 'impact' });
+            logSkip('impact');
             continue;
           }
           if (record.questions.length !== 1 || question.options.length < 2 || question.options.length > 4) {
-            debug.log('hitl.card-bridge', 'skipped', { ...data, reason: 'options' });
+            logSkip('options');
             continue;
           }
           if (seen.has(record.id)) {
@@ -200,7 +213,7 @@ export class DecisionCardService {
             all.unshift(entry);
             debug.log('hitl.card-bridge', 'raised', { ...data, decisionId: entry.id });
           } catch (error) {
-            debug.log('hitl.card-bridge', 'skipped', { ...data, reason: error instanceof Error ? error.name : 'unknown' });
+            logSkip(error instanceof Error ? error.name : 'unknown');
           }
         }
       }
@@ -208,13 +221,26 @@ export class DecisionCardService {
     const chats = await this.opts.transport.ownerChats().catch(() => [] as string[]);
     for (const e of all) {
       const card = state.cards[e.id];
-      if (e.status === 'open' && !card && e.options.length >= 2 && e.raisedAt !== undefined && e.raisedAt >= state.since) {
+      if (e.status === 'open' && (!card || (platform === 'webpush' && !card.refs.length && (card.attempts ?? 0) < WEBPUSH_MAX_SEND_ATTEMPTS))
+        && e.options.length >= 2 && e.raisedAt !== undefined && e.raisedAt >= state.since) {
+        if (platform === 'webpush' && !chats.length) {
+          if (!card?.noSubscribers) {
+            state.cards[e.id] = { ...(card ?? { refs: [] }), noSubscribers: true };
+            dirty = true;
+            debug.log('decisions.webpush', 'no-subscribers', { id: e.id });
+          }
+          continue;
+        }
         const refs: CardRef[] = [];
         for (const chat of chats) {
           const ref = await this.opts.transport.send(chat, renderCard(e)).catch(() => null);
           if (ref) refs.push(ref);
         }
-        if (refs.length) { state.cards[e.id] = { refs }; sent++; }
+        if (platform === 'webpush') {
+          state.cards[e.id] = { ...(card ?? { refs: [] }), refs, attempts: (card?.attempts ?? 0) + 1 };
+          dirty = true;
+        } else if (refs.length) state.cards[e.id] = { refs };
+        if (refs.length) sent++;
         debug.log('decisions.telegram', 'card-sent', { platform, id: e.id, category: e.category, chats: chats.length, delivered: refs.length });
         continue;
       }

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/discord-self-message.ts

@@ -66,6 +66,7 @@ import { localOcrText } from './telegram-card-followup.js';
 import type { runGraph } from './graph-runner/runner.js';
 import { readSlashContextNow, renderTelegramNow } from './context-bus/context-now-surfaces.js';
 import type { ContextNowDeps } from './context-bus/context-now.js';
+import { botUnavailableSlashReply, deriveTuiSlashAvailability, type TuiSlashAvailability } from './maturity/tui-slash-availability.js';
 
 const SLASH_FOCUS_TURNS_DEFAULT = 8;
 
@@ -142,6 +143,8 @@ export interface DiscordSelfMessageDeps {
   log?: (msg: string) => void;
   cardFollowupDeps?: { ocrText?: (path: string) => Promise<string | null>; runGraph?: typeof runGraph; rootDir?: () => string };
   nowDeps?: ContextNowDeps;
+  /** Override the TUI slash projection for isolated message-path tests. */
+  tuiSlashAvailability?: readonly TuiSlashAvailability[];
 }
 
 /** Compose the full discord self+interweave onMessage handler. */
@@ -399,6 +402,12 @@ export function buildDiscordSelfOnMessage(deps: DiscordSelfMessageDeps): DcMessa
       log(`session cmd: ${ctx.text.trim().slice(0, 40)}`);
       return sessionReply;
     }
+    const slashName = /^\/([a-z0-9_-]{1,32})(?:\s|$)/i.exec(ctx.text.trim())?.[1]?.toLowerCase();
+    if (slashName) {
+      const entry = (deps.tuiSlashAvailability ?? deriveTuiSlashAvailability()).find(({ name }) => name === slashName);
+      const unavailable = botUnavailableSlashReply(entry, 'discord');
+      if (unavailable) return unavailable;
+    }
     log(`◀ ${ctx.userName ?? ctx.userId}: ${ctx.text.slice(0, 80)}${ctx.attachments.length ? ` (+첨부 ${ctx.attachments.length})` : ''}`);
     debug.log('discord.self.turn', 'inbound', { channelId: ctx.channelId, chars: ctx.text.length, attachments: ctx.attachments.length });
     // C2+ — 첨부 기억(사진만 먼저 올리는 패턴 지원). 명령 여부와 무관.