elanous 0.2.22 → 0.2.23

package/src/dashboard/first-screen-band.ts

@@ -1,6 +1,111 @@
+import { debug } from '../debug/log.js';
+import { resolveCurrentInstance } from '../instance/current.js';
+import { resolveDaemonEndpoint, type DaemonEndpoint } from '../nexus/daemon-endpoint.js';
+
+export type TuiDaemonLink =
+  | { readonly status: 'checking' }
+  | { readonly status: 'connected'; readonly address: string }
+  | { readonly status: 'absent' | 'unhealthy'; readonly startCommand: string }
+  | { readonly status: 'error'; readonly stage: 'endpoint' | 'health' | 'identity' };
+
+export interface TuiDaemonLinkDeps {
+  readonly endpoint?: () => Pick<DaemonEndpoint, 'baseUrl' | 'healthUrl' | 'source'> | null;
+  readonly probe?: (url: string, init: RequestInit) => Promise<Response>;
+  readonly universe?: () => 'test' | 'prod';
+  /** An explicitly chosen test root (`--test=<root>` / parent stamp); bare `--test` cannot name it. */
+  readonly testRoot?: () => string | undefined;
+  readonly observe?: (data: {
+    status: TuiDaemonLink['status'];
+    stage: 'endpoint' | 'health' | 'identity';
+    universe: 'test' | 'prod' | 'unknown';
+    source: 'registry' | 'lifecycle' | 'none';
+  }) => void;
+}
+
+// C0/C1 controls incl. ESC (ANSI sequences), newline and DEL.
+const CONTROL_CHARS = /[\u0000-\u001f\u007f-\u009f]/;
+
+function shellQuote(value: string): string {
+  return /^[A-Za-z0-9_./:=@%+-]+$/.test(value) ? value : `'${value.replaceAll("'", `'\\''`)}'`;
+}
+
+/** Probe the write target in this universe only; never use a watch/production fallback. */
+export async function resolveTuiDaemonLink(deps: TuiDaemonLinkDeps = {}): Promise<TuiDaemonLink> {
+  const universe = deps.universe ?? (() => resolveCurrentInstance().kind === 'test' ? 'test' : 'prod');
+  const observe = deps.observe ?? ((data) => debug.log('dashboard.tui-daemon-link', 'resolved', data));
+  let kind: 'test' | 'prod' | 'unknown' = 'unknown';
+  let source: 'registry' | 'lifecycle' | 'none' = 'none';
+  const finish = (result: TuiDaemonLink, stage: 'endpoint' | 'health' | 'identity'): TuiDaemonLink => {
+    try { observe({ status: result.status, stage, universe: kind, source }); } catch { /* observation is fail-soft */ }
+    return result;
+  };
+  try {
+    kind = universe();
+  } catch {
+    return finish({ status: 'error', stage: 'identity' }, 'identity');
+  }
+  let explicitRoot: string | undefined;
+  if (kind === 'test') {
+    try {
+      // An injected identity comes with its own root (or none); only the real identity reads the real root.
+      explicitRoot = (deps.testRoot ?? (deps.universe ? () => undefined : () => {
+        const resolution = resolveCurrentInstance();
+        return resolution.layer === 'explicit-flag' || resolution.layer === 'parent-stamp' ? resolution.root : undefined;
+      }))();
+    } catch {
+      return finish({ status: 'error', stage: 'identity' }, 'identity');
+    }
+  }
+  // The start command must name *this* universe: a custom test root is passed as one literal shell argument.
+  // A root with control characters cannot be shown safely (it would rewrite the screen): name no command at all.
+  const startCommand = kind === 'test'
+    ? explicitRoot ? (CONTROL_CHARS.test(explicitRoot) ? '' : `elanous --test=${shellQuote(explicitRoot)} nexus run --hmr`) : 'elanous --test nexus run --hmr'
+    : 'elanous nexus run --hmr';
+  let endpoint: ReturnType<NonNullable<TuiDaemonLinkDeps['endpoint']>>;
+  try {
+    endpoint = (deps.endpoint ?? (() => resolveDaemonEndpoint({ purpose: 'write' })))();
+    if (!endpoint) return finish({ status: 'absent', startCommand }, 'endpoint');
+    source = endpoint.source;
+  } catch {
+    return finish({ status: 'error', stage: 'endpoint' }, 'endpoint');
+  }
+  let address: string;
+  let healthAddress: string;
+  try {
+    const url = new URL(endpoint.baseUrl);
+    const healthUrl = new URL(endpoint.healthUrl);
+    if (!['http:', 'https:'].includes(url.protocol) || !url.hostname || url.username || url.password
+      || url.pathname !== '/' || url.search || url.hash || healthUrl.origin !== url.origin
+      || healthUrl.username || healthUrl.password || healthUrl.pathname !== '/v1/health'
+      || healthUrl.search || healthUrl.hash) {
+      return finish({ status: 'error', stage: 'endpoint' }, 'endpoint');
+    }
+    address = url.origin;
+    healthAddress = `${address}/v1/health`;
+  } catch {
+    return finish({ status: 'error', stage: 'endpoint' }, 'endpoint');
+  }
+  try {
+    const response = await (deps.probe ?? fetch)(healthAddress, { signal: AbortSignal.timeout(1500) });
+    if (!response.ok) return finish({ status: 'unhealthy', startCommand }, 'health');
+    const body: unknown = await response.json();
+    if (!body || typeof body !== 'object' || !('ok' in body) || body.ok !== true) {
+      return finish({ status: 'unhealthy', startCommand }, 'health');
+    }
+    // «Connected» is a claim about *this* universe: the daemon must state its universe and it must match.
+    if (!('testUniverse' in body) || typeof body.testUniverse !== 'boolean' || body.testUniverse !== (kind === 'test')) {
+      return finish({ status: 'error', stage: 'identity' }, 'identity');
+    }
+    return finish({ status: 'connected', address }, 'health');
+  } catch {
+    return finish({ status: 'error', stage: 'health' }, 'health');
+  }
+}
+
 export interface FirstScreenBandInput {
   readonly width: number;
   readonly daemon: boolean;
+  readonly link?: TuiDaemonLink;
   readonly pwa?: {
     readonly tailnet?: string | null;
     readonly lan?: string | null;
@@ -8,6 +113,31 @@ export interface FirstScreenBandInput {
   };
 }
 
+// The link row contains Hangul (two terminal cells per syllable); count display cells, not UTF-16 units.
+function cellWidth(text: string): number {
+  let width = 0;
+  for (const char of text) {
+    const point = char.codePointAt(0)!;
+    if (point >= 0x1100 && (point <= 0x115f || point >= 0x2329 && point <= 0x232a
+      || point >= 0x2e80 && point <= 0xa4cf || point >= 0xac00 && point <= 0xd7a3
+      || point >= 0xf900 && point <= 0xfaff || point >= 0xfe10 && point <= 0xfe6f
+      || point >= 0xff01 && point <= 0xff60 || point >= 0xffe0 && point <= 0xffe6
+      || point >= 0x1f000 && point <= 0x1ffff)) width += 2;
+    else if (point >= 0x300 && point <= 0x36f || point >= 0xfe00 && point <= 0xfe0f) continue;
+    else width++;
+  }
+  return width;
+}
+
+function fitCells(text: string, limit: number): string {
+  let result = '';
+  for (const char of text) {
+    if (cellWidth(result + char) > limit) break;
+    result += char;
+  }
+  return result;
+}
+
 /** A startup transcript band; never includes credentials or a partial address. */
 export function buildFirstScreenBand(input: FirstScreenBandInput): string[] {
   const width = Number.isFinite(input.width) ? Math.max(0, Math.floor(input.width)) : 0;
@@ -27,8 +157,28 @@ export function buildFirstScreenBand(input: FirstScreenBandInput): string[] {
   const fallback = input.pwa === undefined ? 'PWA: not checked' : 'PWA: unavailable';
   const addressLine = address ? `PWA: ${address}` : fallback;
 
+  const daemonLine = (() => {
+    const link = input.link;
+    if (!link) return `elanous | daemon: ${input.daemon ? 'online' : 'offline'}`;
+    if (link.status === 'checking') return 'elanous | 데몬: 확인 중';
+    if (link.status === 'connected') {
+      let address: string;
+      try {
+        const url = new URL(link.address);
+        address = ['http:', 'https:'].includes(url.protocol) && url.hostname ? url.origin : '';
+      } catch { address = ''; }
+      const line = `elanous | 데몬: 연결됨${address ? ` (${address})` : ''}`;
+      return cellWidth(line) <= width ? line : 'elanous | 데몬: 연결됨';
+    }
+    if (link.status === 'error') return `elanous | 데몬: ${link.stage} 조회 오류`;
+    const bare = `elanous | 데몬: ${link.status === 'absent' ? '없음' : '응답 없음'}`;
+    if (!link.startCommand || CONTROL_CHARS.test(link.startCommand)) return bare;
+    const line = `${bare} · 시작: ${link.startCommand}`;
+    return cellWidth(line) <= width ? line : bare;
+  })();
+
   return [
-    fit(`elanous | daemon: ${input.daemon ? 'online' : 'offline'}`),
+    input.link ? fitCells(daemonLine, width) : fit(daemonLine),
     addressLine.length <= width ? addressLine : fit(address ? 'PWA: address available' : fallback),
     fit('Type a message to begin | /help for commands'),
   ];

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 {
@@ -6197,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 */ }