elanous 0.2.21 → 0.2.23

package/src/dashboard/index.ts

@@ -6,7 +6,7 @@
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { fileURLToPath } from 'node:url';
-import { createStaleInstallCheck, readCurrentInstalledCommit, readDashboardBootCommit, STALE_INSTALL_CHECK_INTERVAL_MS, versionedDashboardInstallDir } from './stale-install-check.js';
+import { createStaleInstallCheck, formatStaleInstallNotice, readCurrentInstalledCommit, readDashboardBootCommit, STALE_INSTALL_CHECK_INTERVAL_MS, versionedDashboardInstallDir } from './stale-install-check.js';
 import { spawn, spawnSync } from 'node:child_process';
 import { $ } from 'bun';
 import { LOCAL_SKILLS_DIR, SERVICE_NAMES, DATA_DIR, OBSIDIAN_VAULT } from '../config.js';
@@ -896,7 +896,7 @@ import { inspectActiveProvider } from '../provider-summary.js';
 import { activeCodexAccountView } from '../oauth/codex-account-store.js';
 import { buildDashboardStatusLines } from './dashboard-status-lines.js';
 import { readSlashContextNow, seatsNowLine } from '../context-bus/context-now-surfaces.js';
-import { buildFirstScreenBand } from './first-screen-band.js';
+import { buildFirstScreenBand, resolveTuiDaemonLink, type TuiDaemonLink } from './first-screen-band.js';
 import { runNexusShow, type NexusShowResult } from '../cli/nexus-show.js';
 import {
   workingDirSegment, sessionCwdSegment, modelSegment, gitSegment,
@@ -2128,15 +2128,22 @@ export function renderDashboardFirstScreenBand(input: {
   readonly draw: () => void;
   readonly observe: (data: { daemon: boolean; hasPwa: boolean; hasTailnet: boolean }) => void;
   readonly show?: () => Promise<Pick<NexusShowResult, 'status' | 'urls'>>;
+  readonly daemonLink?: () => Promise<TuiDaemonLink>;
 }): Promise<void> {
   if (input.history.some((message) => message.role !== 'system')) return Promise.resolve();
-  const band = buildFirstScreenBand({ width: input.width, daemon: false });
+  const band = buildFirstScreenBand({ width: input.width, daemon: false, link: { status: 'checking' } });
   input.lines.unshift(...band);
+  const daemonLink = input.daemonLink ?? resolveTuiDaemonLink;
+  const linkPending = Promise.resolve().then(() => daemonLink()).catch((): TuiDaemonLink => ({ status: 'error', stage: 'health' })).then((link) => {
+    if (input.lines[0] !== band[0]) return;
+    input.lines[0] = buildFirstScreenBand({ width: input.width, daemon: false, link })[0]!;
+    try { input.draw(); } catch { /* screen may have closed */ }
+  });
   const show = input.show ?? (() => runNexusShow({ format: 'json', out: { log: () => {}, error: () => {} } }));
   const observe = (data: { daemon: boolean; hasPwa: boolean; hasTailnet: boolean }): void => {
     try { input.observe(data); } catch { /* observation cannot interrupt the transcript */ }
   };
-  return Promise.resolve().then(show).then((result) => {
+  const pwaPending = Promise.resolve().then(show).then((result) => {
     const daemon = result.status !== 'absent';
     const pwa = result.urls?.pwa;
     const hasPwa = !!pwa;
@@ -2148,6 +2155,7 @@ export function renderDashboardFirstScreenBand(input: {
   }).catch(() => {
     observe({ daemon: false, hasPwa: false, hasTailnet: false });
   });
+  return Promise.all([linkPending, pwaPending]).then(() => {});
 }
 
 export async function showDashboard(opts: ShowDashboardOptions = {}): Promise<DashboardAction> {
@@ -4361,13 +4369,27 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     now: Date.now,
   });
   if (versionDir) {
+    let staleNoticeIndex = -1;
+    let staleNoticeLine: string | undefined;
+    let staleNoticeCount = 0;
     const checkInstall = (): void => {
       const result = staleInstallCheck.check();
       debug.log('dashboard.version', 'install-check', {
         state: result.state, bootCommit: result.bootCommit, installedCommit: result.installedCommit,
       });
       if (staleInstallCheck.shouldNotify(result)) {
-        chatLines.push(C.warning(`elanous 가 새 판으로 바뀌었다 (${result.bootCommit!.slice(0, 7)} → ${result.installedCommit!.slice(0, 7)}) · TUI 를 다시 띄워라`));
+        staleNoticeCount++;
+        const notice = C.warning(formatStaleInstallNotice(result, staleNoticeCount));
+        if (chatLines[staleNoticeIndex] !== staleNoticeLine || staleNoticeLine === undefined) {
+          staleNoticeIndex = staleNoticeLine === undefined ? -1 : chatLines.indexOf(staleNoticeLine);
+        }
+        if (staleNoticeIndex < 0) {
+          chatLines.push(notice);
+          staleNoticeIndex = chatLines.length - 1;
+        } else {
+          chatLines[staleNoticeIndex] = notice;
+        }
+        staleNoticeLine = notice;
         chatScrollOffset = -1;
         try { draw(); } catch { /* TUI torn down */ }
       }

package/src/dashboard/slash-runtime/dashboard-handlers.ts

@@ -343,7 +343,7 @@ import { terminalModalRouter } from '../input/terminal-modal-router.js';
 import { termSize, stripAnsi } from '../../tui.js';
 import { SLASH_COMMANDS } from '../../chat/index.js';
 import { buildEssentialHelpLines } from './help-from-registry.js';
-import { HUMAN_MODEL_WORDS, MODEL_CODE_NAMES, modelChangeLine, modelOverviewLines, resolveModelChoice } from './model-choices.js';
+import { HUMAN_MODEL_WORDS, MODEL_CODE_NAMES, humanWordForModel, modelChangeLine, modelOverviewLines, resolveModelChoice } from './model-choices.js';
 import type { FoldMode } from '../../log-entry.js';
 import { resolveDashboardChatMainLogCommand } from '../input/chat-main-log-command.js';
 import {
@@ -395,6 +395,8 @@ import { dispatchTerminalModalObserve } from '../../skills/tools/terminal-modal.
 import { SlashCommandRegistry } from './registry.js';
 import { cronSecondDueAt, filterLoopRows, formatLoopsTable, localLoopRows, type LoopsTableRow } from './loops-table.js';
 import { loopCronVerdict } from '../../loops/verdict.js';
+import { checklistBoardSlash } from '../../release-loop/checklist-board.js';
+import type { Checklist } from '../../release-loop/checklist.js';
 import { executeImmediateDashboardSlash } from '../input/slash-executor.js';
 import {
   buildContextSlashCommand,
@@ -1046,6 +1048,8 @@ export interface DashboardSlashContext {
 
   /** Test seam for the local read-only loop and cron registry. */
   loopsLocalRows?: (now: Date) => LoopsTableRow[];
+  /** Test seam for the read-only release checklist. */
+  checklistRead?: (version: string) => Checklist;
 
   sessionSlash: {
     /** opts.remote — when the dashboard is attached to a remote daemon. */
@@ -1467,6 +1471,11 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
     ctx.setChatScrollOffset(-1);
   });
 
+  registry.register('board', (args, ctx) => {
+    for (const line of checklistBoardSlash(args, ctx.checklistRead).split('\n')) ctx.pushChatLine(line);
+    ctx.setChatScrollOffset(-1);
+  });
+
   registry.register('wish', (args, ctx) => {
     const text = args.join(' ').trim();
     if (!text) {
@@ -6188,8 +6197,10 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
     const curModel = curCfg.llm.model;
     const curReasoning = effectiveReasoningLevel(curCfg.llm, curProvider, curModel);
     if (!arg) {
-      const [now, codes] = modelOverviewLines(curProvider, curModel, curReasoning);
-      ctx.chatLines.push(now);
+      const [, codes] = modelOverviewLines(curProvider, curModel, curReasoning);
+      // A model outside the 빠름/보통/깊음 map (codename or custom) says so explicitly instead of dropping the tier slot.
+      const tierName = humanWordForModel(curProvider, curModel, curReasoning) ?? '단계 밖';
+      ctx.chatLines.push(`지금: ${curModel?.trim() || '기본 모델'} (${tierName} · 생각 ${curReasoning}) · 고르기: /model ${HUMAN_MODEL_WORDS.join(' | ')}`);
       ctx.chatLines.push(ctx.muted(codes));
       ctx.setChatScrollOffset(-1);
       return;

package/src/dashboard/stale-install-check.ts

@@ -12,6 +12,11 @@ export type StaleInstallResult = {
 
 export const STALE_INSTALL_CHECK_INTERVAL_MS = 60_000;
 
+export function formatStaleInstallNotice(result: StaleInstallResult, notifiedCount: number): string {
+  const message = `새 판이 깔렸습니다 (부팅 판 ${result.bootCommit!.slice(0, 7)} → 지금 ${result.installedCommit!.slice(0, 7)}) · TUI 를 다시 띄우면 새 판으로 돕니다`;
+  return notifiedCount >= 2 ? `${message} · 이 TUI 가 뜬 뒤 ${notifiedCount}번째 새 판` : message;
+}
+
 /** Identify the immutable installed version containing this module, never the session cwd. */
 export function versionedDashboardInstallDir(
   codeRoot: string,
@@ -21,8 +26,14 @@ export function versionedDashboardInstallDir(
     const packageRoot = realpathSync(codeRoot);
     if (basename(packageRoot) !== 'elanous' || basename(dirname(packageRoot)) !== 'node_modules') return undefined;
     const versionDir = dirname(dirname(packageRoot));
-    if (dirname(versionDir) !== resolve(installRoot, 'versions')) return undefined;
-    return versionDir;
+    let canonicalInstallRoot: string;
+    try { canonicalInstallRoot = realpathSync(installRoot); }
+    catch { canonicalInstallRoot = resolve(installRoot); }
+    if (dirname(versionDir) !== join(canonicalInstallRoot, 'versions')) return undefined;
+    const requestedVersionDir = dirname(dirname(resolve(codeRoot)));
+    return dirname(requestedVersionDir) === resolve(installRoot, 'versions')
+      && realpathSync(requestedVersionDir) === versionDir
+      ? requestedVersionDir : versionDir;
   } catch {
     return undefined;
   }

package/src/dashboard/turn-stream-formatter.ts

@@ -20,6 +20,7 @@ import type { ToolRenderModel } from '../chat/tool-render/types.js';
 import { toolOperationKind, type FoldMode } from '../log-entry.js';
 import { stripAnsi } from '../tui.js';
 import type { TurnStreamPresentationEvent } from './turn-stream-presentation-applier.js';
+import { buildFoldedTailLine, splitNoSynthesisTail } from './chat-fold.js';
 
 /** Drop leading/trailing blank (whitespace-only, ANSI-stripped) rows
  *  from a rendered assistant block. Codex-family models frequently
@@ -181,6 +182,7 @@ export function createTurnStreamFormatter(
   const toolArgsByCallId = new Map<string, Record<string, unknown>>();
   const nonGenericCallIds = new Set<string>();
   let toolCallCount = 0;
+  let noSynthesisTailCount = 0;
 
   const emitAssistantBlock = (): void => {
     deps.thinking.update('Streaming');
@@ -219,6 +221,29 @@ export function createTurnStreamFormatter(
       }
       if (chunk === '') {
         // Path 2 — authoritative replacement (W5-E/F/G force-synthesis).
+        const split = splitNoSynthesisTail(accumulated);
+        if (split) {
+          perRoundText = split.head;
+          emitAssistantBlock();
+          closeRound();
+          deps.emit({ type: 'assistant.commit' });
+          const callId = `no-synthesis-tail-${++noSynthesisTailCount}`;
+          const expandedLines = trimBlankEdges(
+            deps.formatResponse(split.tail, deps.termCols() - 6, deps.wrapOpts),
+          ).map(deps.text);
+          const collapsedLines = [buildFoldedTailLine(expandedLines.length)];
+          if (debug.enabled) {
+            debug.log('dashboard.chat.stream', 'formatter.noSynthesisTail.folded', {
+              callId,
+              headLen: split.head.length,
+              tailLen: split.tail.length,
+              expandedLineCount: expandedLines.length,
+            });
+          }
+          deps.emit({ type: 'tool.appendBlock', callId, lines: collapsedLines, args: {} });
+          deps.emit({ type: 'tool.replaceBlock', callId, collapsedLines, expandedLines });
+          return;
+        }
         perRoundText = accumulated;
       } else {
         // Path 3 — streaming delta. accumulated 무시 (cross-turn fullText).

package/src/debug/log-diet.ts

@@ -0,0 +1,159 @@
+import type { DebugEvent } from './log.js';
+
+export const LOG_DIET_WINDOW_MS = 60_000;
+
+export const LOG_DIET_KEYS: Readonly<Record<string, 'repeat' | 'consecutive'>> = {
+  'watchdog/activity': 'consecutive',
+  'user-config.llm/provider-resolved': 'repeat',
+  'hitl.card-bridge/skipped': 'repeat',
+  'input.cursor.claim/chat-main': 'repeat',
+  'tox.loop/waiting-capacity': 'repeat',
+  'tox.loop/tick': 'repeat',
+};
+
+export interface LogDietSummary {
+  category: string;
+  event: string;
+  count: number;
+  windowMs: number;
+  firstSuppressedAt: string;
+  lastSuppressedAt: string;
+  runId?: string;
+  sessionId?: string;
+}
+
+type Policy = 'repeat' | 'consecutive';
+type DietRecord = Pick<DebugEvent, 'category' | 'event' | 'data' | 'level' | 'session_id' | 'runId'>;
+
+interface Stream {
+  category: string;
+  event: string;
+  runId?: string;
+  sessionId?: string;
+  value: string;
+  lastEmittedAt: number;
+  count: number;
+  firstSuppressedAt?: string;
+  lastSuppressedAt?: string;
+}
+
+/** Canonicalize objects (not arrays) so payload property insertion order is not an identity. */
+function stableValue(value: unknown): string {
+  const seen = new WeakSet<object>();
+  return JSON.stringify(value, (_key, item: unknown) => {
+    if (typeof item === 'bigint') return `${item}n`;
+    if (item && typeof item === 'object') {
+      if (seen.has(item)) return '<circular>';
+      seen.add(item);
+      if (Array.isArray(item)) return item;
+      return Object.fromEntries(Object.entries(item).sort(([a], [b]) => a.localeCompare(b)));
+    }
+    return item;
+  }) ?? 'undefined';
+}
+
+export class LogDietGuard {
+  private readonly windowMs: number;
+  private readonly now: () => number;
+  private readonly keys: Readonly<Record<string, Policy>>;
+  private readonly maxStreams: number;
+  private readonly disabled: boolean;
+  private readonly streams = new Map<string, Stream>();
+
+  constructor(opts: { windowMs?: number; now?: () => number; keys?: Readonly<Record<string, Policy>>; maxStreams?: number } = {}) {
+    this.windowMs = opts.windowMs ?? LOG_DIET_WINDOW_MS;
+    this.now = opts.now ?? Date.now;
+    this.keys = opts.keys ?? LOG_DIET_KEYS;
+    this.maxStreams = Math.max(1, opts.maxStreams ?? 2000);
+    this.disabled = process.env.ELANOUS_LOG_DIET === 'off';
+  }
+
+  private summary(stream: Stream): LogDietSummary | undefined {
+    if (!stream.count) return undefined;
+    return {
+      category: stream.category,
+      event: stream.event,
+      count: stream.count,
+      windowMs: this.windowMs,
+      firstSuppressedAt: stream.firstSuppressedAt!,
+      lastSuppressedAt: stream.lastSuppressedAt!,
+      ...(stream.runId !== undefined ? { runId: stream.runId } : {}),
+      ...(stream.sessionId !== undefined ? { sessionId: stream.sessionId } : {}),
+    };
+  }
+
+  admit(rec: DietRecord): { pass: boolean; summaries: LogDietSummary[] } {
+    const policy = this.keys[`${rec.category}/${rec.event}`];
+    if (this.disabled || !policy || rec.category === 'log.diet'
+      || rec.level === 'warn' || rec.level === 'error' || rec.level === 'critical') {
+      return { pass: true, summaries: [] };
+    }
+
+    const runId = rec.runId ?? (rec.data && typeof rec.data === 'object' && !Array.isArray(rec.data)
+      ? (rec.data as Record<string, unknown>).runId : undefined);
+    const sessionId = rec.session_id;
+    let value: string;
+    try {
+      value = stableValue([stableValue(rec.data), rec.level ?? 'debug', sessionId, runId]);
+    } catch {
+      return { pass: true, summaries: [] }; // Logging must remain fail-open for unusual payloads.
+    }
+    const key = stableValue(policy === 'repeat'
+      ? [rec.category, rec.event, value]
+      : [rec.category, rec.event, sessionId, runId]);
+    const time = this.now();
+    const summaries: LogDietSummary[] = [];
+    const stream = this.streams.get(key);
+    if (stream) {
+      this.streams.delete(key); // Evict the least recently observed flow.
+      this.streams.set(key, stream);
+      if ((policy === 'repeat' || stream.value === value) && time - stream.lastEmittedAt < this.windowMs) {
+        stream.count++;
+        const at = new Date(time).toISOString();
+        stream.firstSuppressedAt ??= at;
+        stream.lastSuppressedAt = at;
+        return { pass: false, summaries };
+      }
+      const pending = this.summary(stream);
+      if (pending) summaries.push(pending);
+      stream.count = 0;
+      stream.firstSuppressedAt = undefined;
+      stream.lastSuppressedAt = undefined;
+      stream.value = value;
+      stream.lastEmittedAt = time;
+      return { pass: true, summaries };
+    }
+
+    if (this.streams.size >= this.maxStreams) {
+      const oldestKey = this.streams.keys().next().value!;
+      const oldest = this.streams.get(oldestKey)!;
+      const pending = this.summary(oldest);
+      if (pending) summaries.push(pending);
+      this.streams.delete(oldestKey);
+    }
+    this.streams.set(key, { category: rec.category, event: rec.event,
+      ...(typeof runId === 'string' ? { runId } : {}),
+      ...(sessionId !== undefined ? { sessionId } : {}),
+      value, lastEmittedAt: time, count: 0 });
+    return { pass: true, summaries };
+  }
+
+  /** Emit pending counts without reopening the current sample windows. */
+  flushPending(): LogDietSummary[] {
+    const summaries: LogDietSummary[] = [];
+    for (const stream of this.streams.values()) {
+      const pending = this.summary(stream);
+      if (pending) summaries.push(pending);
+      stream.count = 0;
+      stream.firstSuppressedAt = undefined;
+      stream.lastSuppressedAt = undefined;
+    }
+    return summaries;
+  }
+
+  drain(): LogDietSummary[] {
+    const summaries = this.flushPending();
+    this.streams.clear();
+    return summaries;
+  }
+}

package/src/debug/log.ts

@@ -81,8 +81,7 @@ import { redactLogRecord } from '../mss/logging/redaction.js';
 import { isRenderCategory } from '../mss/logging/render-categories.js';
 import type { LogSource, LogLevel } from '../mss/logging/record.js';
 import { cleanupLogDir } from '../mss/logging/retention.js';
-import { createStderrSinkFromFlags } from '../mss/logging/sinks/stderr-sink.js';
-import { createOtelGenAISinkFromFlags } from '../mss/logging/sinks/otel-genai-sink.js';
+import { LogDietGuard, type LogDietSummary } from './log-diet.js';
 
 /** DebugEvent is the legacy shape. Pre-MSS callers only read/write
  *  `ts` / `category` / `event` / `data`. MSS M2.1 adds four optional
@@ -285,6 +284,7 @@ class DebugLog {
   private readonly _ringSink = new RingSink(500);
   private readonly _mirrorSink = new MirrorSink(formatLine);
   private readonly _extraSinks: LogSink[] = [];
+  private _logDietGuard: LogDietGuard | null = new LogDietGuard();
   private readonly _redactEnabled: boolean;
 
   constructor() {
@@ -550,8 +550,20 @@ class DebugLog {
     return this._ringSink.events().map(formatLine).join('\n');
   }
 
+  /** Replace the guard for isolated sink tests; return the previous guard. */
+  setLogDietGuard(guard: LogDietGuard | null): LogDietGuard | null {
+    const previous = this._logDietGuard;
+    this._logDietGuard = guard;
+    return previous;
+  }
+
+  private emitLogDietSummaries(summaries: LogDietSummary[]): void {
+    for (const summary of summaries) this.log('log.diet', 'suppressed', summary);
+  }
+
   /** Force any buffered events to disk immediately. */
   flush(): void {
+    if (this._logDietGuard) this.emitLogDietSummaries(this._logDietGuard.flushPending());
     this._fileSink.flush();
     this._chatFileSink.flush();
     for (const sink of this._extraSinks) {
@@ -600,6 +612,12 @@ class DebugLog {
     // when off).
     if (this._redactEnabled) rec = redactLogRecord(rec) as DebugEvent;
 
+    if (this._logDietGuard) {
+      const decision = this._logDietGuard.admit(rec);
+      this.emitLogDietSummaries(decision.summaries);
+      if (!decision.pass) return;
+    }
+
     // Ring buffer — always populated when at least one sink is live so
     // `/debug tail` shows activity even when the file write failed.
     this._ringSink.emit(rec);
@@ -767,7 +785,18 @@ function safeStringSlice(value: string, limit: number, fromEnd = false): string
 /** Format a single event as a compact one-line string. Long payloads
  *  get truncated at ~400 chars so the chat mirror doesn't flood the
  *  log pane on a big LLM response. */
+let configTimeZoneRegistrationLoaded = false;
+
 export function formatLine(ev: DebugEvent): string {
+  // Standalone logger consumers can format before application bootstrap. Load
+  // the config owner once on demand without a static or type import edge.
+  if (!configTimeZoneRegistrationLoaded) {
+    try {
+      const configModulePath: string = '../user-config.js';
+      require(configModulePath);
+      configTimeZoneRegistrationLoaded = true;
+    } catch { /* config unavailable during startup — formatter falls back to env/OS */ }
+  }
   const time = formatClock(ev.ts, { millis: true }); // 사용자 시간대 HH:MM:SS.mmm
   const head = `[${time}] [${ev.category}] ${ev.event}`;
   if (ev.data === undefined) return head;
@@ -905,6 +934,8 @@ const SECRET_TEXT_RULES: readonly { readonly id: string; readonly re: RegExp; re
   { id: 'generic-api-key', re: /\b(api[_-]?key|secret|password|passwd|token|credential)\b(\s*[:=]\s*)["']?[^\s"',;)]{4,}/gi, to: '$1$2***' },
   // 환경변수 형태 `OPENROUTER_API_KEY=…` — 위 규칙은 `_API_KEY` 앞에 단어 경계가 없어 못 잡는다. 값에 글자가 있어야 한다(`MAX_TOKEN=4096` 은 그대로).
   { id: 'env-secret', re: /\b([A-Z][A-Z0-9]*_(?:[A-Z0-9]+_)*(?:API_KEY|TOKEN|SECRET|PASSWORD|ACCESS_KEY))(\s*[:=]\s*)["']?(?=[^\s"',;)]*[A-Za-z])[^\s"',;)]{8,}/g, to: '$1$2***' },
+  // BEDROCK-PROVIDER — `AWS_BEARER_TOKEN_BEDROCK=…` 은 이름이 TOKEN 으로 «끝나지» 않아 위 규칙이 못 잡는다.
+  { id: 'aws-bedrock-bearer-env', re: /\b(AWS_BEARER_TOKEN_BEDROCK)(\s*[:=]\s*)["']?[^\s"',;)]{8,}/g, to: '$1$2***' },
   // Authorization 헤더(로그에서 흔하다).
   { id: 'authorization-header', re: /\b(Bearer|Basic)\s+[A-Za-z0-9._~+/-]{8,}={0,2}/gi, to: '$1 ***' },
 ];
@@ -959,19 +990,23 @@ export function redactSecrets<T>(obj: T): T {
 /** The singleton. Import as `debug` from this module. */
 export const debug = new DebugLog();
 
-// MSS M2.2 Phase A2 — opt-in stderr mirror. Default off, so this is a
-// no-op unless `MSS_STDERR_SINK=1` is set in the environment. Kept as
-// the only "extra sink" wire point baked into the debug module; future
-// sinks should register themselves from their consuming subsystem
-// rather than being listed here, so this stays small.
-try {
-  const stderrSink = createStderrSinkFromFlags(getFlags());
-  if (stderrSink) debug.registerSink(stderrSink);
-} catch { /* flag-parse failure must not block the rest of the tracer */ }
-
-// PLAN §4.6 / Arc 2.2 — opt-in OTel GenAI sink. Default off; wire only
-// when `MSS_OTEL_ENDPOINT` is set so a missing collector is silent.
+// Optional sinks register synchronously after the singleton exists, before
+// its first caller can log. Non-literal require keeps their type graph out of
+// the foundation and avoids losing records during asynchronous import.
 try {
-  const otelSink = createOtelGenAISinkFromFlags(getFlags());
-  if (otelSink) debug.registerSink(otelSink);
-} catch { /* flag-parse / sink-init failure must not block the tracer */ }
+  const flags = getFlags();
+  if (flags.stderrSink) {
+    try {
+      const sinkModulePath: string = '../mss/logging/sinks/stderr-sink.js';
+      const sink = require(sinkModulePath).createStderrSinkFromFlags(flags) as LogSink | null;
+      if (sink) debug.registerSink(sink);
+    } catch { /* one optional sink must not block the other */ }
+  }
+  if (flags.otelEndpoint) {
+    try {
+      const sinkModulePath: string = '../mss/logging/sinks/otel-genai-sink.js';
+      const sink = require(sinkModulePath).createOtelGenAISinkFromFlags(flags) as LogSink | null;
+      if (sink) debug.registerSink(sink);
+    } catch { /* optional sink must not block the tracer */ }
+  }
+} catch { /* flag-parse failure must not block the tracer */ }

package/src/decisions/decision-cards.ts

@@ -34,7 +34,9 @@ export function isIrreversible(entry: Pick<DecisionEntry, 'category'>): boolean
   return IRREVERSIBLE.has(entry.category);
 }
 
-const kst = (at: string) => new Intl.DateTimeFormat('ko-KR', { timeZone: 'Asia/Seoul', month: 'numeric', day: 'numeric', hour: '2-digit', minute: '2-digit', hour12: false }).format(new Date(at));
+const kst = (at: string) => Number.isFinite(Date.parse(at))
+  ? new Intl.DateTimeFormat('ko-KR', { timeZone: 'Asia/Seoul', month: 'numeric', day: 'numeric', hour: '2-digit', minute: '2-digit', hour12: false }).format(new Date(at))
+  : '읽을 수 없음';
 
 /** The card opens with a short pitch; the full question and choice buttons remain below it. */
 export function renderCardText(e: DecisionEntry, extra: { note?: string; confirm?: string } = {}): string {
@@ -101,6 +103,7 @@ interface CardState {
    *  deploy); they stay reachable through `/decisions`. */
   since?: string;
   cards: Record<string, { refs: CardRef[]; closed?: boolean; remindedAt?: string; note?: string; attempts?: number; noSubscribers?: boolean }>;
+  deferred?: Record<string, true>;
   testOriginQuestions?: Record<string, true>;
 }
 
@@ -113,6 +116,10 @@ export interface DecisionCardServiceOptions {
   /** Where this platform keeps which card it sent (one file per platform — the two bots may run in different processes). */
   statePath?: string;
   now?: () => Date;
+  /** Optional gate for new-card delivery. Omit to send every eligible open decision. */
+  sendFilter?: (entry: DecisionEntry, now: Date) => boolean;
+  /** Label recorded in the `push-deferred` observation when `sendFilter` holds a decision back. */
+  deferredReason?: (entry: DecisionEntry, now: Date) => string;
   /** Tell the seat that raised it. Default: none (observed only). */
   replyToRaiser?: (entry: DecisionEntry, via: CardPlatform) => Promise<void>;
 }
@@ -223,6 +230,18 @@ export class DecisionCardService {
       const card = state.cards[e.id];
       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 (this.opts.sendFilter) {
+          const now = this.now();
+          if (!this.opts.sendFilter(e, now)) {
+            if (!state.deferred?.[e.id]) {
+              (state.deferred ??= {})[e.id] = true;
+              dirty = true;
+              debug.log(platform === 'webpush' ? 'decisions.webpush' : 'decisions.telegram', 'push-deferred',
+                { ...(platform === 'webpush' ? {} : { platform }), id: e.id, urgency: this.opts.deferredReason?.(e, now) ?? 'filtered' });
+            }
+            continue;
+          }
+        }
         if (platform === 'webpush' && !chats.length) {
           if (!card?.noSubscribers) {
             state.cards[e.id] = { ...(card ?? { refs: [] }), noSubscribers: true };

package/src/decisions/decision-ledger.ts

@@ -5,6 +5,8 @@ import { readPendingQuestionAnswer, readPendingQuestions, writePendingQuestionAn
 import { debug, redactSecretText } from '../debug/log.js';
 import { createVersionResolver, type VersionOptions, type Versions } from '../directives/version-at.js';
 import { getUserConfig } from '../user-config.js';
+import { registeredSeats, resolveSeat } from '../seat-address/seat-address.js';
+import { isSeatId } from '../seat-dispatch/seat-questions.js';
 
 export type DecisionCategory = 'secret' | 'publish' | 'money' | 'security' | 'scope' | 'irreversible' | 'other';
 /** Old track letters (S·T·F·O) stay readable; seat names (OP·MK·TC·UX) are the current identities. */
@@ -53,7 +55,8 @@ export class DecisionAnswerDeliveryError extends Error {
   }
 }
 const CATEGORIES: readonly string[] = ['secret', 'publish', 'money', 'security', 'scope', 'irreversible', 'other'];
-const TRACKS: readonly string[] = ['S', 'T', 'F', 'O', 'OP', 'MK', 'TC', 'UX'];
+const isDecisionTrack = (value: string): boolean => registeredSeats().some(({ id, alias }) => value === id || value === alias);
+const isRegisteredSeat = (value: string): boolean => isSeatId(value) && resolveSeat(value)?.id === value;
 
 function required(value: string, name: string): string {
   if (typeof value !== 'string' || !value.trim()) throw new Error(`${name} is required`);
@@ -88,7 +91,7 @@ function validate(input: RaiseInput, historical = false): RaiseInput {
   const title = safe(single(input.title, 'title'));
   if (!CATEGORIES.includes(input.category)) throw new Error('invalid category');
   if (!input.raisedBy?.agent) throw new Error('raisedBy.agent is required');
-  if (input.raisedBy.track && !TRACKS.includes(input.raisedBy.track)) throw new Error('invalid track');
+  if (input.raisedBy.track && !isDecisionTrack(input.raisedBy.track)) throw new Error('invalid track');
   const s = scqaField(input.scqa.s, 's');
   const c = scqaField(input.scqa.c, 'c');
   const q = input.scqa.q?.trim() ? scqaField(input.scqa.q, 'q') : undefined;
@@ -117,7 +120,7 @@ function validate(input: RaiseInput, historical = false): RaiseInput {
   if (input.crossCheck !== undefined && !Array.isArray(input.crossCheck)) throw new Error('cross-check must be a list');
   const crossCheck = input.crossCheck?.map(check => {
     const seat = single(check.seat, 'cross-check seat');
-    if (!['OP', 'MK', 'TC', 'UX'].includes(seat)) throw new Error('invalid cross-check seat');
+    if (!isRegisteredSeat(seat)) throw new Error('invalid cross-check seat');
     return { seat, at: utc(check.at), note: safe(single(check.note, 'cross-check note')) };
   });
   const crossCheckSkipped = input.crossCheckSkipped === undefined ? undefined : safe(single(input.crossCheckSkipped, 'cross-check skipped reason'));
@@ -242,7 +245,7 @@ export class DecisionLedger {
   /** Delegated decisions are already made: they share the append-only ledger, never the owner's open-card state machine. */
   recordSeatDecision(input: SeatDecisionInput): SeatDecisionRecord {
     const seat = input.seat;
-    if (!['OP', 'MK', 'TC', 'UX'].includes(seat)) throw new Error('invalid seat');
+    if (!isRegisteredSeat(seat)) throw new Error('invalid seat');
     const title = safe(single(input.title, 'title'));
     const decision = safe(single(input.decision, 'decision'));
     const delegation = safe(single(input.delegation, 'delegation'));
@@ -263,7 +266,7 @@ export class DecisionLedger {
   }
   seatReport(filters: { since?: string; seat?: Seat } = {}): SeatDecisionRecord[] {
     const since = filters.since === undefined ? undefined : utc(filters.since);
-    if (filters.seat && !['OP', 'MK', 'TC', 'UX'].includes(filters.seat)) throw new Error('invalid seat');
+    if (filters.seat && !isRegisteredSeat(filters.seat)) throw new Error('invalid seat');
     return this.events().filter((event): event is Extract<Event, { type: 'seat-recorded' }> => event.type === 'seat-recorded')
       .map(event => event.entry)
       .filter(entry => (!since || (entry.recordedAt ?? entry.decidedAt ?? '') >= since) && (!filters.seat || entry.seat === filters.seat))
@@ -307,7 +310,7 @@ export class DecisionLedger {
     if (!by || (by.kind !== 'human' && by.kind !== 'auto')) throw new Error('decidedBy is required');
     if (by.kind === 'auto') {
       single(by.delegation, 'delegation'); single(by.agent, 'agent');
-      if (by.track && !TRACKS.includes(by.track)) throw new Error('invalid track');
+      if (by.track && !isDecisionTrack(by.track)) throw new Error('invalid track');
       by = { ...by, agent: safe(single(by.agent, 'agent')), delegation: safe(single(by.delegation, 'delegation')) };
     }
     return this.locked(() => {
@@ -424,7 +427,7 @@ export class DecisionLedger {
     if (choice ? !clean.options.some(o => o.key === choice) : clean.options.length !== 0) throw new Error(`option not found: ${choice}`);
     if (by.kind === 'auto') {
       single(by.agent, 'agent'); single(by.delegation, 'delegation');
-      if (by.track && !TRACKS.includes(by.track)) throw new Error('invalid track');
+      if (by.track && !isDecisionTrack(by.track)) throw new Error('invalid track');
       by = { ...by, agent: safe(single(by.agent, 'agent')), delegation: safe(single(by.delegation, 'delegation')) };
     }
     const cleanNote = safe(single(note, 'note'));
@@ -449,7 +452,7 @@ export class DecisionLedger {
   completeRecorded(id: string, choice: string | undefined, by: DecisionActor, note: string, sourceOptions: DecisionOption[]): DecisionEntry {
     if (by.kind === 'auto') {
       single(by.agent, 'agent'); single(by.delegation, 'delegation');
-      if (by.track && !TRACKS.includes(by.track)) throw new Error('invalid track');
+      if (by.track && !isDecisionTrack(by.track)) throw new Error('invalid track');
       by = { ...by, agent: safe(single(by.agent, 'agent')), delegation: safe(single(by.delegation, 'delegation')) };
     }
     const cleanNote = safe(single(note, 'note'));

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

@@ -1,8 +1,24 @@
 import { debug } from '../debug/log.js';
 import { listSubscriptions } from '../web-push/subscriptions.js';
 import { sendPushToAll } from '../web-push/sender.js';
-import { type CardTransport, type CardView } from './decision-cards.js';
-import { DecisionLedger } from './decision-ledger.js';
+import { isIrreversible, type CardTransport, type CardView } from './decision-cards.js';
+import { DecisionLedger, type DecisionEntry } from './decision-ledger.js';
+
+/** How close a deadline must be for an otherwise reversible decision to ring the phone. */
+export const WEB_PUSH_URGENT_WINDOW_MS = 24 * 3600_000;
+
+export type WebPushUrgency = 'irreversible' | 'due-soon' | 'not-urgent' | 'due-unreadable';
+
+/** Web push rings only for urgent decisions; an unreadable deadline is its own value (fail open, never folded into not-urgent). */
+export function webPushUrgency(entry: DecisionEntry, now: Date): WebPushUrgency {
+  if (isIrreversible(entry)) return 'irreversible';
+  if (entry.dueAt !== undefined) {
+    const due = Date.parse(entry.dueAt);
+    if (!Number.isFinite(due)) return 'due-unreadable';
+    if (due - now.getTime() <= WEB_PUSH_URGENT_WINDOW_MS) return 'due-soon';
+  }
+  return 'not-urgent';
+}
 
 const ID_IN_CARD = /^🗳 결정 요청 (D-\d{8}-\d+)(?: ·|\n)/;
 const ID_IN_REMINDER = /^⏰ 기한 2시간 전 — (D-\d{8}-\d+) /;
@@ -26,7 +42,7 @@ export function webPushDecisionTransport(
       const entry = ledger.show(id);
       if (entry.status !== 'open') return null;
       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 body = `${recommendation}${entry.dueAt ? ` · 기한: ${Number.isFinite(Date.parse(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) });
       if (result.attempted) debug.log('decisions.webpush', 'card-sent', { id, delivered: result.delivered });
       return result.delivered ? { chat: 'webpush', message: id } : null;