elanous 0.2.22 → 0.2.24

package/src/debug/log-diet.ts

@@ -0,0 +1,190 @@
+import type { DebugEvent } from './log.js';
+
+export const LOG_DIET_WINDOW_MS = 60_000;
+
+/** LOG-DIET-2 — minimum spacing between two `log.diet/suppressed` summary releases.
+ *  One diet window: a folded stream costs at most one summary row per window instead of one per flush. */
+export const LOG_DIET_SUMMARY_MIN_INTERVAL_MS = LOG_DIET_WINDOW_MS;
+
+/** LOG-DIET-2 — pending-stream pressure that releases summaries before the interval elapses. */
+export const LOG_DIET_SUMMARY_MAX_PENDING = 256;
+
+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',
+  'llm.credential/provider-key-missing': 'repeat',
+  'llm.credential/provider-key-resolved': 'repeat',
+  'pty.manifest/output-bytes-flushed': 'repeat',
+  // `pod-lease/admit-by-usage` is NOT folded: dispatch backpressure and the TA parent-host admission
+  // read it back from logs and count rows (`admissionCounts`) — it is a judgment-path event.
+};
+
+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 summaryMinIntervalMs: number;
+  private readonly summaryMaxPending: number;
+  private readonly disabled: boolean;
+  private readonly streams = new Map<string, Stream>();
+  private lastSummaryReleaseAt = Number.NEGATIVE_INFINITY;
+  private pendingStreams = 0;
+
+  constructor(opts: { windowMs?: number; now?: () => number; keys?: Readonly<Record<string, Policy>>; maxStreams?: number; summaryMinIntervalMs?: number; summaryMaxPending?: 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.summaryMinIntervalMs = Math.max(0, opts.summaryMinIntervalMs ?? LOG_DIET_SUMMARY_MIN_INTERVAL_MS);
+    this.summaryMaxPending = Math.max(1, opts.summaryMaxPending ?? LOG_DIET_SUMMARY_MAX_PENDING);
+    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}`];
+    // LOG-DIET-2 — a registered key folds at warn too; unregistered warn/error/critical alarms never fold.
+    if (this.disabled || !policy || rec.category === 'log.diet'
+      || 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) {
+        if (stream.count === 0) this.pendingStreams++;
+        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); this.pendingStreams--; }
+      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.pendingStreams--; }
+      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.
+   *  LOG-DIET-2 — releases are spaced by `summaryMinIntervalMs` unless forced (drain)
+   *  or the pending-stream pressure cap is hit. Deferred counts stay accumulated on
+   *  their streams, so a held-back release never drops a suppressed event. */
+  flushPending(force = false): LogDietSummary[] {
+    if (!force && !this.summaryReleaseDue()) return [];
+    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;
+    }
+    this.pendingStreams = 0;
+    this.lastSummaryReleaseAt = this.now();
+    return summaries;
+  }
+
+  private summaryReleaseDue(): boolean {
+    if (this.pendingStreams >= this.summaryMaxPending) return true;
+    return this.now() - this.lastSummaryReleaseAt >= this.summaryMinIntervalMs;
+  }
+
+  drain(): LogDietSummary[] {
+    const summaries = this.flushPending(true);
+    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,38 @@ 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);
+  }
+
+  /** LOG-DIET-2 — summaries are now spaced by the diet window, so a short-lived process could exit
+   *  holding folded counts. On the first suppression we arm one exit drain that force-releases them
+   *  (and flushes the sinks synchronously) so a held-back release never drops a count at shutdown. */
+  private _logDietExitArmed = false;
+  private armLogDietExitDrain(): void {
+    if (this._logDietExitArmed) return;
+    this._logDietExitArmed = true;
+    const drain = (): void => { try { this.drainLogDietPending(); } catch { /* exit path must not throw */ } };
+    process.once('beforeExit', drain);
+    process.once('exit', drain);
+  }
+
+  /** Force-release every pending diet summary (ignores the summary interval) and flush sinks. */
+  drainLogDietPending(): void {
+    if (this._logDietGuard) this.emitLogDietSummaries(this._logDietGuard.flushPending(true));
+    this.flush();
+  }
+
   /** 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 +630,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) { this.armLogDietExitDrain(); 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 +803,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 +952,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 +1008,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/display/coordinator.ts

@@ -252,6 +252,15 @@ export class DisplayCoordinator {
   private readonly regionMap: RegionMap;
   private readonly termSize: () => TermSize;
   private readonly invalidateRow: (row0: number) => void;
+  /** TUI-SLASH-FLICKER — true when the host wired a real row
+   *  invalidator, so a region move can be repaired by a plain diff
+   *  frame instead of a forced full-screen repaint. */
+  private readonly hasRowInvalidator: boolean;
+  /** TUI-SLASH-FLICKER — the previous flush invalidated overlay rows
+   *  (region moved / vanished); the next flush must re-emit the overlay
+   *  even when its bytes are unchanged, because the base rows under it
+   *  were just repainted. Replaces the old forceNext follow-up. */
+  private overlayRowsInvalidated = false;
 
   private surfaces = new Map<SurfaceId, DisplaySurface>();
   private focusNodes = new Map<SurfaceId, FocusNode>();
@@ -536,6 +545,7 @@ export class DisplayCoordinator {
     this.regionMap = opts.regionMap ?? new DefaultRegionMap();
     this.termSize = opts.termSize ?? (() => ({ rows: 24, cols: 80 }));
     this.invalidateRow = opts.invalidateRow ?? (() => { /* no-op default */ });
+    this.hasRowInvalidator = typeof opts.invalidateRow === 'function';
 
     // H1.6 · W1 → W2 bridge. Whenever LayerTree announces a layer
     // state change (bounds / opacity / parent / zIndex), inform the
@@ -2848,8 +2858,10 @@ export class DisplayCoordinator {
     // region invalidation (V4 cascade above) handles the actual
     // erase by marking rows dirty in the main frame buffer.
     let overlaySkippedThisFlush = false;
+    const overlayRowsInvalidated = this.overlayRowsInvalidated;
+    this.overlayRowsInvalidated = false;
     if (ansi.length > 0) {
-      if (request.force || ansi !== this.prevOverlayAnsi) {
+      if (request.force || overlayRowsInvalidated || ansi !== this.prevOverlayAnsi) {
         this.writeOverlay(ansi);
         this.prevOverlayAnsi = ansi;
         this.overlayWritesEmitted++;
@@ -2875,7 +2887,18 @@ export class DisplayCoordinator {
     }
     this.lastOverlayRegions = currentRegions;
     if (vanished && !request.force) {
-      this.forceNext = true;
+      // TUI-SLASH-FLICKER (2026-10-09) — the prior region rows were
+      // invalidated above, so the follow-up frame's row diff already
+      // repaints exactly those rows. Forcing it reached tui.ts::render
+      // as a full-screen erase (`\x1b[1;1H\x1b[J`) every time the slash
+      // picker's height changed while typing — whole-screen flicker.
+      // Keep the blanket force only when no row invalidator is wired.
+      if (this.hasRowInvalidator) {
+        this.markDirty('all');
+        this.overlayRowsInvalidated = true;
+      } else {
+        this.forceNext = true;
+      }
       this.requestFrame();
     }
   }

package/src/domains/coo-admin-tool.ts

@@ -30,6 +30,7 @@ export interface CooAdminDeps {
   project?: string;
   now?: Date;
   dateEvidence?: CooDateEvidence;
+  briefing?: boolean;
 }
 
 /** Reads the configured Linear project without changing any Linear issue. */
@@ -58,6 +59,32 @@ export async function dispatchCooAdmin(_args: Record<string, unknown>, deps: Coo
       : undefined;
     const deadlineFor = (item: LinearProjectIssue) => verifiedDate(evidenceFor(item)?.officialDeadline);
     const rank = (item: LinearProjectIssue) => item.priority === 0 ? 5 : item.priority;
+    if (deps.briefing) {
+      const todayKst = new Date(today.getTime() + 9 * 3_600_000).toISOString().slice(0, 10);
+      const day = (date: string) => Date.parse(`${date}T00:00:00Z`);
+      const todayDay = day(todayKst);
+      const byDeadline = (a: LinearProjectIssue, b: LinearProjectIssue) =>
+        day(deadlineFor(a)!) - day(deadlineFor(b)!) || rank(a) - rank(b) || a.identifier.localeCompare(b.identifier);
+      const dated = issues.filter(item => deadlineFor(item) !== null).sort(byDeadline);
+      const format = (item: LinearProjectIssue) => {
+        const due = deadlineFor(item);
+        const representative = verifiedDate(evidenceFor(item)?.representativeActionDate);
+        const priority = item.priority === 1 ? 'Urgent' : item.priority === 2 ? 'High' : `우선순위 ${item.priority || '미지정'}`;
+        const title = item.title.replace(/[\r\n\u2028\u2029]+/g, ' ').trim();
+        const url = item.url.replace(/[\r\n\u2028\u2029]+/g, '');
+        return `- ${due ? `확인된 마감일 ${due}` : '기한 미확인'} · ${priority} · ${title}${representative ? ` · 대표 손이 필요한 날 ${representative}` : ''}\n  ${url}`;
+      };
+      const overdueItems = dated.filter(item => day(deadlineFor(item)!) < todayDay);
+      const upcoming = dated.filter(item => day(deadlineFor(item)!) >= todayDay && day(deadlineFor(item)!) <= todayDay + 14 * 86_400_000);
+      const later = dated.filter(item => day(deadlineFor(item)!) > todayDay + 14 * 86_400_000);
+      const unknown = issues.filter(item => deadlineFor(item) === null).sort((a, b) => rank(a) - rank(b) || a.identifier.localeCompare(b.identifier));
+      debug.log('coo.admin', 'read', { count: issues.length, overdue: overdueItems.length, reason: 'ok' });
+      return [issues.truncated ? '조회 상한 250건 · 아래 목록은 일부이며 빠진 항목의 기한은 측정 불가' : '',
+        `지난 기한 ${overdueItems.length}건\n${overdueItems.map(format).join('\n') || '없음'}`,
+        `14일 안 기한 ${upcoming.length}건\n${upcoming.map(format).join('\n') || '없음'}`,
+        ...(later.length || unknown.length ? [`그 밖 · 14일 이후 ${later.length}건 · 기한 미확인 ${unknown.length}건\n${[...later, ...unknown].map(format).join('\n')}`] : []),
+      ].filter(Boolean).join('\n');
+    }
     issues.sort((a, b) => {
       const aDue = deadlineFor(a);
       const bDue = deadlineFor(b);

package/src/domains/cron-match.ts

@@ -13,6 +13,7 @@
 // 레포 내부 계약(src/time/format.ts)에 위임한다. 로컬 게터로 시/분/요일을 뽑으면
 // 프로세스 주변 TZ 에 종속돼 launchd 환경에서 조용히 어긋나기 때문.
 import { calendarFields, resolveTimeZone } from '../time/format.js';
+import '../user-config.js'; // Standalone catch-up queries share the saved timezone with the scheduler.
 
 // 한 파트 매칭 — 지원: 별표, 별표+스텝, 범위 a-b, 범위+스텝, 단일 값 n.
 function matchPart(part: string, value: number, min: number, max: number): boolean {

package/src/domains/outbound-alert.ts

@@ -26,7 +26,7 @@ import { effectiveInstanceRoot, prodInstanceRoot } from '../instance/resolve.js'
 //   import 라 런타임 순환 없음(발송 로직은 이 파일에 self-contained). origin 없으면 report 폴백.
 import type { MissionOrigin } from '../autopilot/mission-origin.js';
 import { conatusDataDir, conatusPath } from './conatus-data-dir.js';
-import { assertNoRealSendFromTest, assertNotTestWritingOps, isTestDouble } from '../instance/test-write-guard.js';
+import { assertNoRealSendFromTest, assertNotTestWritingOps, isTestDouble, TestOpsWriteRefusedError } from '../instance/test-write-guard.js';
 
 /** Explicit `ELANOUS_NEXUS_URL` wins. Otherwise ask the daemon endpoint resolver.
  *  A missing daemon is not a guessed port — the caller falls through to direct send. */
@@ -627,6 +627,7 @@ export function deliver(text: string, kind = 'alert', onBot?: (bot: string) => v
   }
   // 2) fallback: 텔레그램 sendMessage 직접(3900자 분할) — 데몬 미경유라 클라가 원장 기록.
   //    The same config judges the route and explains a failure (review r1).
+  //    deliver → sendTelegramDirect: the refusal propagates to the caller instead of becoming «undeliverable».
   let cfg: UserConfig | undefined;
   try { cfg = getUserConfig(); } catch { /* sendTelegramDirect fails closed without config */ }
   if (sendTelegramDirect(text, kind, cfg ? { config: cfg } : {}, onBot)) return 'direct';
@@ -704,16 +705,26 @@ export function sendTelegramDirect(
   deps: { config?: UserConfig; sendRaw?: typeof sendTelegramRaw; legacyEnv?: typeof conatusEnv } = {},
   onBot?: (bot: string) => void,
 ): boolean {
-  const sendRaw = deps.sendRaw ?? sendTelegramRaw;
-  // An injected sender still may not run in a test that resolved the ops universe.
-  if (deps.sendRaw) assertTestSendFaked('send a Telegram message from the ops universe', false);
+  const sendRaw = (token: string, chatId: string | number, body: string): boolean => {
+    // The transport is checked only after a route is eligible; a test double cannot target the ops universe.
+    assertTestSendFaked('send a real Telegram message', !deps.sendRaw);
+    return (deps.sendRaw ?? sendTelegramRaw)(token, chatId, body);
+  };
   let cfg: UserConfig | undefined;
   try { cfg = deps.config ?? getUserConfig(); } catch { /* unavailable config: operational delivery still fails closed */ }
   if (cfg) {
     try {
       const target = kindRouteTarget(cfg, kind);
-      if (target) { onBot?.(botLabel(target.botToken)); return sendRaw(target.botToken, String(target.chatId), text); }
-    } catch { /* unavailable channel routing: fall through */ }
+      if (target) {
+        // Refusal must escape the routing fallback; other routing/callback/transport failures retain that fallback.
+        assertTestSendFaked('send a real Telegram message', !deps.sendRaw);
+        onBot?.(botLabel(target.botToken));
+        return (deps.sendRaw ?? sendTelegramRaw)(target.botToken, String(target.chatId), text);
+      }
+    } catch (error) {
+      if (error instanceof TestOpsWriteRefusedError) throw error;
+      /* unavailable channel routing: fall through */
+    }
     // A declared table is authoritative: missing roles cannot escape to an env bot.
     if (cfg.telegram.channels?.length) {
       logKindRouteFallback(kind, 'none', false);