elanous 0.2.17 → 0.2.18

package/src/context-bus/condense.ts

@@ -1,8 +1,9 @@
-import { closeSync, constants, fstatSync, lstatSync, mkdirSync, openSync } from 'node:fs';
+import { closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, openSync } from 'node:fs';
 import { dlopen, FFIType } from 'bun:ffi';
 import { join } from 'node:path';
 import { listMemories, memoryRoot, saveMemory, type MemoryEntry } from '../memory.js';
 import { DecisionLedger } from '../decisions/decision-ledger.js';
+import { debug } from '../debug/log.js';
 import { condenseContextWindowWithReport, readCondenseEvents, type CondenseFunnel, type CondenseSkipped, type MemoryDeps, type MemoryItem, type MemorySource, type MemorySummary } from './long-term-memory.js';
 
 const summarize = async (source: MemorySource): Promise<MemorySummary> =>
@@ -51,6 +52,7 @@ export function renderCondenseMarkdown(report: Pick<CondenseReport, 'since' | 'u
 
 type CondenseStore = {
   list(): MemoryEntry[];
+  hasMemoryDirectory?(): boolean;
   save(input: Parameters<typeof saveMemory>[0]): MemoryEntry;
   raise(input: Parameters<DecisionLedger['raiseOnce']>[0], ref: string): string;
   withLock<T>(action: () => T): T;
@@ -96,6 +98,7 @@ function defaultStore(root?: string): CondenseStore {
   const ledger = new DecisionLedger(root ? { stateDir: root } : {});
   return {
     list: () => listMemories({}, memoryDir),
+    hasMemoryDirectory: () => existsSync(memoryDir),
     save: input => saveMemory(input, memoryDir),
     raise: (input, ref) => ledger.raiseOnce(input, ref).id,
     withLock: action => withMemoryLock(memoryDir, action),
@@ -118,10 +121,22 @@ function newestActive(entries: readonly MemoryEntry[]): MemoryEntry | undefined
 }
 
 /** Apply candidate cards through the existing curated memory and decision ledger paths. */
-export function applyCondensedCards(cards: readonly MemoryItem[], store: CondenseStore): NonNullable<CondenseReport['applied']> {
+export function applyCondensedCards(cards: readonly MemoryItem[], store: CondenseStore, now: Date = new Date()): NonNullable<CondenseReport['applied']> {
   const decisions: string[] = [];
   let written = 0;
   let retired = 0;
+  const cutoff = now.getTime() - 30 * 24 * 3_600_000;
+  const retireAged = () => {
+    let agedRetired = 0;
+    for (const old of store.list()) {
+      if (old.contextCard?.status !== 'active' || !(Date.parse(old.contextCard.updatedAt) < cutoff)) continue;
+      store.save({ type: old.type, name: old.name, description: old.description, body: old.body, id: old.id,
+        pinned: false, priority: old.priority, contextCard: { ...old.contextCard, status: 'retired' } });
+      agedRetired++;
+    }
+    retired += agedRetired;
+    debug.log('context.condense', 'aged-out', { retired: agedRetired });
+  };
   for (const card of cards) {
     if (card.conflict) {
       const ref = `context-condense:${JSON.stringify([card.project, card.seat, card.topic, card.source, card.updatedAt])}`;
@@ -162,6 +177,7 @@ export function applyCondensedCards(cards: readonly MemoryItem[], store: Condens
     };
     store.withLock(applyTopic);
   }
+  if (store.hasMemoryDirectory?.() !== false) store.withLock(retireAged);
   return { written, retired, decisions };
 }
 
@@ -184,6 +200,6 @@ export async function runContextCondense(options: {
   const conflicts = cards.filter(card => card.conflict !== undefined).length;
   const report: CondenseReport = { since, until, cards, conflicts, skipped, folded, droppedHarnessChild, funnel,
     markdown: renderCondenseMarkdown({ since, until, cards, conflicts, skipped, droppedHarnessChild, funnel }) };
-  if (options.apply === true) report.applied = applyCondensedCards(cards, store ?? defaultStore(options.root));
+  if (options.apply === true) report.applied = applyCondensedCards(cards, store ?? defaultStore(options.root), now);
   return report;
 }

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

@@ -12,6 +12,16 @@ export interface ContextDayRow {
   status: '들어옴' | '안 들어옴';
 }
 export interface ContextDayReport { since: string; until: string; rows: ContextDayRow[] }
+export interface ContextDayTimelineEvent {
+  at: string;
+  source: ContextDaySource;
+  kind: ContextDayKind | 'other';
+  summary: string;
+  link: string | null;
+}
+export interface ContextDayTimelineReport { since: string; until: string; events: ContextDayTimelineEvent[] }
+interface JournalEvent { surface: string; kind: string; ts: string; refs: string | null; summary: string | null }
+type DayDeps = { now?: () => Date; dbPath?: string; seat?: ContextDaySource };
 
 /** Reject malformed windows instead of silently changing the time range being judged. */
 export function contextDayHours(since: string): number {
@@ -34,43 +44,86 @@ function kindFor(surface: string, kind: string): ContextDayKind | null {
   return null;
 }
 
+function sourceFor(event: JournalEvent): { source: ContextDaySource; refs: { url?: unknown; source?: unknown } } | null {
+  let refs: { seat?: unknown; origin?: unknown; url?: unknown; source?: unknown };
+  try { refs = JSON.parse(event.refs ?? '{}') as typeof refs; } catch { return null; }
+  if (!refs || typeof refs !== 'object') return null;
+  const source = event.surface === 'context:external' ? refs.origin : refs.seat;
+  if (typeof source !== 'string' || !CONTEXT_DAY_SOURCES.some(item => item === source)) return null;
+  const isExternal = CONTEXT_DAY_SOURCES.indexOf(source as ContextDaySource) >= 4;
+  // Do not attribute an external hook to a seat (or a seat event to an external origin).
+  if ((event.surface === 'context:external') !== isExternal) return null;
+  return { source: source as ContextDaySource, refs };
+}
+
 /** Read only the context journal, not recallEvents (which mutates recall counts) or the writable DB opener. */
-export function contextDay(since = '24h', deps: { now?: () => Date; dbPath?: string } = {}): ContextDayReport {
+function readDay(since: string, deps: DayDeps): { since: string; until: string; events: JournalEvent[] } {
   const hours = contextDayHours(since);
   const now = (deps.now ?? (() => new Date()))();
   const until = now.toISOString();
   const from = new Date(now.getTime() - hours * 3_600_000).toISOString();
-  const rows: ContextDayRow[] = CONTEXT_DAY_SOURCES.map(source => ({
-    source, counts: { 'task-claimed': 0, done: 0, asked: 0, 'guidance-changed': 0 }, lastAt: null, status: '안 들어옴',
-  }));
-  const bySource = new Map(rows.map(row => [row.source, row]));
   const path = deps.dbPath ?? surfaceEventsDbPath();
-  if (!existsSync(path)) return { since: from, until, rows };
+  if (!existsSync(path)) return { since: from, until, events: [] };
   const db = new Database(path, { readonly: true });
   try {
-    const events = db.prepare(`SELECT surface, kind, ts, refs FROM events
+    const events = db.prepare(`SELECT surface, kind, ts, refs, summary FROM events
       WHERE surface IN ('coord:channel', 'context:session', 'context:external')
-        AND direction='outbound' AND ts>=? AND ts<=? ORDER BY ts ASC`).all(from, until) as Array<{
-      surface: string; kind: string; ts: string; refs: string | null;
-    }>;
-    for (const event of events) {
-      let refs: { seat?: unknown; origin?: unknown };
-      try { refs = JSON.parse(event.refs ?? '{}') as typeof refs; } catch { continue; }
-      const source = event.surface === 'context:external' ? refs.origin : refs.seat;
-      if (typeof source !== 'string') continue;
-      const row = bySource.get(source as ContextDaySource);
-      if (!row) continue;
-      // Do not attribute an external hook to a seat (or a seat event to an external origin).
-      if ((event.surface === 'context:external') !== (rows.indexOf(row) >= 4)) continue;
-      row.lastAt = event.ts;
-      row.status = '들어옴';
-      const kind = kindFor(event.surface, event.kind);
-      if (kind) row.counts[kind]++;
-    }
+        AND direction='outbound' AND ts>=? AND ts<=? ORDER BY ts ASC`).all(from, until) as JournalEvent[];
+    return { since: from, until, events };
   } finally { db.close(); }
+}
+
+export function contextDay(since = '24h', deps: { now?: () => Date; dbPath?: string } = {}): ContextDayReport {
+  const { since: from, until, events } = readDay(since, deps);
+  const rows: ContextDayRow[] = CONTEXT_DAY_SOURCES.map(source => ({
+    source, counts: { 'task-claimed': 0, done: 0, asked: 0, 'guidance-changed': 0 }, lastAt: null, status: '안 들어옴',
+  }));
+  const bySource = new Map(rows.map(row => [row.source, row]));
+  for (const event of events) {
+    const attribution = sourceFor(event);
+    if (!attribution) continue;
+    const row = bySource.get(attribution.source)!;
+    row.lastAt = event.ts;
+    row.status = '들어옴';
+    const kind = kindFor(event.surface, event.kind);
+    if (kind) row.counts[kind]++;
+  }
   return { since: from, until, rows };
 }
 
+export function contextDayTimeline(since = '24h', deps: DayDeps = {}): ContextDayTimelineReport {
+  if (deps.seat !== undefined && !CONTEXT_DAY_SOURCES.some(source => source === deps.seat)) {
+    throw new Error(`unknown --seat: ${deps.seat}`);
+  }
+  const { since: from, until, events } = readDay(since, deps);
+  const timeline: ContextDayTimelineEvent[] = [];
+  for (const event of events) {
+    const attribution = sourceFor(event);
+    if (!attribution || (deps.seat && attribution.source !== deps.seat)) continue;
+    const { url, source } = attribution.refs;
+    const link = [url, source].find(value => typeof value === 'string' && /^(?:https?:\/\/|elanous:\/\/)[^\s]+$/.test(value));
+    timeline.push({ at: event.ts, source: attribution.source, kind: kindFor(event.surface, event.kind) ?? 'other',
+      summary: event.summary ?? '', link: typeof link === 'string' ? link : null });
+  }
+  return { since: from, until, events: timeline };
+}
+
+const kstFormatter = new Intl.DateTimeFormat('en-CA', {
+  timeZone: 'Asia/Seoul', year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', hourCycle: 'h23',
+});
+function kst(at: string): string {
+  const parts = Object.fromEntries(kstFormatter.formatToParts(new Date(at)).map(part => [part.type, part.value]));
+  return `${parts.year}-${parts.month}-${parts.day} ${parts.hour}:${parts.minute} KST`;
+}
+
+export function renderContextDayTimeline(report: ContextDayTimelineReport, dbPath = surfaceEventsDbPath()): string {
+  const lines = [`맥락 사건 ${kst(report.since)} ~ ${kst(report.until)}`];
+  if (!report.events.length) lines.push(`이 창에 사건 0건 — 원장 경로: ${dbPath}`);
+  else lines.push(...report.events.map(event => `${kst(event.at).slice(11)} · ${event.source} · ${event.kind} · ${event.summary.replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029]+/g, ' ')} · ${event.link ?? '—'}`));
+  lines.push(`${report.events.length}건 · 출처 ${new Set(report.events.map(event => event.source)).size}곳`);
+  return lines.join('\n');
+}
+
 export function renderContextDay(report: ContextDayReport): string {
   return [
     `맥락 이벤트 ${report.since} ~ ${report.until} (UTC)`,

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

@@ -0,0 +1,33 @@
+import type { ContextNowAnswer, ContextNowDeps } from './context-now.js';
+
+const CONTEXT_FIRST_GAP_MS = 6 * 60 * 60 * 1000;
+const CONTEXT_UNREADABLE = '맥락 못 읽음';
+
+/** Track every allowed utterance, consuming a pending summary only on a normal turn. */
+export function createContextFirstGate({ now, gapMs = CONTEXT_FIRST_GAP_MS }: { now: () => number; gapMs?: number }) {
+  const lastUtteranceAt = new Map<string, number>();
+  const pending = new Set<string>();
+  return {
+    note(key: string): void {
+      const at = now();
+      const previous = lastUtteranceAt.get(key);
+      lastUtteranceAt.set(key, at);
+      if (previous === undefined || at - previous >= gapMs) pending.add(key);
+    },
+    take(key: string): boolean {
+      return pending.delete(key);
+    },
+  };
+}
+
+export function renderContextFirst(
+  read: (options: {}, deps?: ContextNowDeps) => ContextNowAnswer,
+  deps: ContextNowDeps | undefined,
+  render: (answer: ContextNowAnswer) => string,
+): string {
+  try {
+    return render(read({}, deps));
+  } catch {
+    return CONTEXT_UNREADABLE;
+  }
+}

package/src/discord-self-message.ts

@@ -65,7 +65,9 @@ import { detectCard, runCardFollowup, NotACardError } from './card-followup/core
 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 { contextNow, type ContextNowDeps } from './context-bus/context-now.js';
+import { createContextFirstGate, renderContextFirst } from './context-bus/context-first.js';
+import { telegramLoopsStatus, type LoopsSources } from './telegram-loops-command.js';
 import { botUnavailableSlashReply, deriveTuiSlashAvailability, type TuiSlashAvailability } from './maturity/tui-slash-availability.js';
 
 const SLASH_FOCUS_TURNS_DEFAULT = 8;
@@ -143,6 +145,9 @@ export interface DiscordSelfMessageDeps {
   log?: (msg: string) => void;
   cardFollowupDeps?: { ocrText?: (path: string) => Promise<string | null>; runGraph?: typeof runGraph; rootDir?: () => string };
   nowDeps?: ContextNowDeps;
+  /** Override the clock for the context-first gate in isolated message-path tests. */
+  contextFirstNow?: () => number;
+  loopsSources?: LoopsSources;
   /** Override the TUI slash projection for isolated message-path tests. */
   tuiSlashAvailability?: readonly TuiSlashAvailability[];
 }
@@ -151,6 +156,15 @@ export interface DiscordSelfMessageDeps {
 export function buildDiscordSelfOnMessage(deps: DiscordSelfMessageDeps): DcMessageHandler {
   const log = deps.log ?? ((): void => {});
   const cfg = deps.userConfig;
+  const contextFirstGate = createContextFirstGate({ now: deps.contextFirstNow ?? Date.now });
+  const maybeSendContextFirst = async (channelId: string): Promise<void> => {
+    if (!contextFirstGate.take(channelId) || cfg.discord?.contextFirst === false) return;
+    try {
+      await deps.getBot()?.sendMessage(channelId, renderContextFirst(contextNow, deps.nowDeps, renderTelegramNow));
+    } catch (err) {
+      log(`discord context-first failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  };
   // C2+ (2026-07-12 dogfood): 디스코드 첨부는 메시지 단위라 "사진 먼저,
   // !cdx 명령은 다음 메시지" 패턴에서 위임 턴이 빈손이 된다. 채널별로
   // 마지막 첨부를 기억해 두고, 첨부 없는 위임 명령이 2분 내 같은
@@ -359,6 +373,7 @@ export function buildDiscordSelfOnMessage(deps: DiscordSelfMessageDeps): DcMessa
 
   return async (ctx, streamer) => {
     if (deps.channelScope && ctx.channelId !== deps.channelScope) return undefined;
+    contextFirstGate.note(ctx.channelId);
     // Voice text commands pass the guild gate for the voice adapter's
     // sake — never route them into the LLM turn (legacy behavior).
     if (/^\/voice-(join|leave|status)\b/.test(ctx.text.trim())) return undefined;
@@ -367,6 +382,8 @@ export function buildDiscordSelfOnMessage(deps: DiscordSelfMessageDeps): DcMessa
       const args = nowCommand[1]?.trim().split(/\s+/).filter(Boolean) ?? [];
       return renderTelegramNow(readSlashContextNow(args, deps.nowDeps));
     }
+    if (/^[/!]loops$/.test(ctx.text.trim())) return telegramLoopsStatus([], deps.loopsSources);
+    if (/^[/!]loops\s+\S/.test(ctx.text.trim())) return telegramLoopsStatus(['extra'], deps.loopsSources);
     if (!ctx.text.trim() && ctx.attachments.length === 1 && ctx.attachments[0]!.contentType?.startsWith('image/')) {
       const photo = ctx.attachments[0]!;
       if (detectCard({ width: photo.width, height: photo.height, ocrText: null }).decision !== 'skip') {
@@ -408,6 +425,8 @@ export function buildDiscordSelfOnMessage(deps: DiscordSelfMessageDeps): DcMessa
       const unavailable = botUnavailableSlashReply(entry, 'discord');
       if (unavailable) return unavailable;
     }
+    const cmd = parseDiscordAcpCommand(ctx.text);
+    if (!cmd && !/^[!/]/.test(ctx.text.trim())) await maybeSendContextFirst(ctx.channelId);
     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+ — 첨부 기억(사진만 먼저 올리는 패턴 지원). 명령 여부와 무관.
@@ -416,7 +435,6 @@ export function buildDiscordSelfOnMessage(deps: DiscordSelfMessageDeps): DcMessa
     const delegationKey = delegationChatKey('dc', ctx.channelId);
 
     // 1) Explicit text commands — /cc·/cdx·/gem delegate, /brain exits.
-    const cmd = parseDiscordAcpCommand(ctx.text);
     if (cmd?.kind === 'brain') {
       clearActiveDelegation(delegationKey);
       return '🧠 브레인 모드로 복귀했습니다 (active delegation 해제).';

package/src/discord-slash-wire.ts

@@ -48,6 +48,7 @@ export const ELANOUS_SLASH_COMMANDS: readonly SlashCommandSchema[] = [
   { name: 'now', description: '지금 판·칸·결정·자리·최근 맥락 보기', options: [
     { name: 'topic', description: '좁혀 볼 주제 (선택)', type: 3, required: false },
   ] },
+  { name: 'loops', description: '루프·크론 현황 (늦음·실패 먼저)' },
   { name: 'sessions', description: '바인딩된 세션 목록' },
   { name: 'new', description: '새 세션으로 시작 (이전 대화 보존)' },
   { name: 'attach', description: '이 채널을 다른 세션에 연결', options: [

package/src/domains/outbound-alert.ts

@@ -5,8 +5,8 @@
 // send.py 와 동일 동작을 TS 로 포팅(완전 elanous 소유). sync(curl) 계약.
 
 import * as childProcess from 'node:child_process';
-import { existsSync, readFileSync, appendFileSync, mkdirSync, unlinkSync } from 'node:fs';
-import { dirname, join, relative } from 'node:path';
+import { existsSync, readFileSync, appendFileSync, mkdirSync, unlinkSync, readdirSync, renameSync, openSync, closeSync, statSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join, relative } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { getElanousConfigDir } from '../elanous-config-dir.js';
 import { conatusEnv } from './conatus-env.js';
@@ -138,11 +138,11 @@ export function userRecentlyActive(now: Date = new Date()): boolean {
 
 /** 야간 보류 적재 (jsonl append — 크론 동시 실행에 안전). origin 있으면 함께 적재 —
  *  아침 flush 가 그 origin(발신 채널)으로 되돌려 발송(없으면 report 묶음). */
-function deferOutbound(text: string, kind: string, origin?: MissionOrigin | null, path = DEFERRED_PATH): boolean {
+export function deferOutbound(text: string, kind: string, origin?: MissionOrigin | null, path = DEFERRED_PATH): boolean {
   try {
     mkdirSync(dirname(path), { recursive: true });
     const rec = { ts: new Date().toISOString(), kind, text, ...(origin ? { origin } : {}) };
-    appendFileSync(path, JSON.stringify(rec) + '\n');
+    withQueueLock(path, () => appendFileSync(path, JSON.stringify(rec) + '\n'));
     console.error(`[outbound] 야간 무음(00:00~06:30 KST) — 보류 적재 (${kind})`);
     return true;
   } catch (e) {
@@ -198,32 +198,195 @@ function deliverToOrigin(origin: MissionOrigin, text: string, onBot?: (bot: stri
   try { return sendTelegramRaw(token, origin.chatId, text, origin.threadId); } catch { return false; }
 }
 
-/** 보류분 일괄 발송 — 묶음 1건(아침 폭주 방지). 발송 건수 반환.
- *  무음 창 밖 첫 sendOutbound 가 자동 호출 + 06:31 플러시 크론이 보장. */
-export function flushDeferred(path = DEFERRED_PATH): number {
+/** 보류 큐 재시도 상한 env — config `outbound.deferredMaxAttempts` 가 없을 때만 읽는다. */
+export const DEFERRED_MAX_ATTEMPTS_ENV = 'ELANOUS_OUTBOUND_DEFERRED_MAX_ATTEMPTS';
+
+/** 보류 항목이 격리되기 전까지 허용하는 실패 flush 수 — config > env > 5. */
+export function deferredMaxAttempts(config?: Pick<UserConfig, 'outbound'>): number {
+  try {
+    const v = (config ?? getUserConfig()).outbound?.deferredMaxAttempts;
+    if (typeof v === 'number' && Number.isSafeInteger(v) && v > 0) return v;
+  } catch { /* unreadable config: env, then default */ }
+  const raw = Number(process.env[DEFERRED_MAX_ATTEMPTS_ENV]?.trim() || NaN);
+  if (Number.isSafeInteger(raw) && raw > 0) return raw;
+  return 5;
+}
+
+/** 격리 파일 — 보류 큐 옆 `<name>.failed.jsonl`. */
+export function deferredQuarantinePath(path: string): string {
+  return path.endsWith('.jsonl') ? `${path.slice(0, -'.jsonl'.length)}.failed.jsonl` : `${path}.failed`;
+}
+
+function pidAlive(pid: number): boolean {
+  try { process.kill(pid, 0); return true; } catch (e) { return (e as NodeJS.ErrnoException).code === 'EPERM'; }
+}
+
+/** 큐 적재·claim 이 서로를 가로지르지 않게 하는 짧은 배타 잠금(`<queue>.lock`, O_EXCL).
+ *  적재는 open→write→close 를 잠금 안에서 하므로 claim 의 rename 이 «열린 채 쓰기 전»인 적재를 가져가지 않는다.
+ *  잠금을 못 얻으면(2초 · 30초 넘은 잔여 잠금은 걷는다) 그대로 진행한다 — 알림을 잃는 것보다 낫다. */
+function withQueueLock<T>(path: string, fn: () => T): T {
+  const lock = `${path}.lock`;
+  const deadline = Date.now() + 2_000;
+  let fd: number | null = null;
+  while (fd === null && Date.now() <= deadline) {
+    try { fd = openSync(lock, 'wx'); break; } catch (e) {
+      const code = (e as NodeJS.ErrnoException).code;
+      if (code === 'ENOENT') { try { mkdirSync(dirname(path), { recursive: true }); } catch { break; } continue; }
+      if (code !== 'EEXIST') break;
+      try { if (Date.now() - statSync(lock).mtimeMs > 30_000) { unlinkSync(lock); continue; } } catch { continue; }
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+    }
+  }
+  if (fd === null) { try { debug.log('outbound.send', 'deferred-lock-unavailable', { lock: basename(lock) }); } catch { /* */ } }
+  try { return fn(); } finally {
+    if (fd !== null) { try { closeSync(fd); } catch { /* */ } try { unlinkSync(lock); } catch { /* */ } }
+  }
+}
+
+/** 이보다 오래된 claim 은 소유 pid 가 살아 있어도 회수한다(pid 재사용 대비 · 정상 flush 는 이보다 훨씬 짧다). */
+const STALE_CLAIM_MS = 15 * 60_000;
+
+let claimSeq = 0;
+/** 큐를 «가져간다» — 원자적 rename 으로 이 flush 만의 파일로 옮긴다. flush 도중 적재되는 항목은 새 큐 파일에
+ *  쌓이므로 잃지 않는다. 죽은 flusher(또는 이 프로세스의 앞 호출)가 남긴 claim 도 같이 회수한다. */
+function claimDeferred(path: string): string[] {
+  const claims: string[] = [];
+  const next = (): string => `${path}.flushing-${process.pid}-${Date.now()}-${claimSeq++}`;
+  const dir = dirname(path);
+  const prefix = `${basename(path)}.flushing-`;
+  try {
+    for (const name of readdirSync(dir)) {
+      if (!name.startsWith(prefix)) continue;
+      const m = /^(\d+)-(\d+)-/.exec(name.slice(prefix.length));
+      const pid = Number(m?.[1]);
+      const at = Number(m?.[2]);
+      if (!Number.isSafeInteger(pid)) continue;
+      // flushDeferred 는 동기라 같은 pid 의 claim 은 «지난 호출의 잔여»다. 남의 것은 죽었거나 오래됐을 때만.
+      const stale = Number.isFinite(at) && Date.now() - at > STALE_CLAIM_MS;
+      if (pid !== process.pid && !stale && pidAlive(pid)) continue;
+      const own = next();
+      try { renameSync(join(dir, name), own); claims.push(own); } catch { /* another flusher took it */ }
+    }
+  } catch { /* no directory yet */ }
+  withQueueLock(path, () => {
+    if (!existsSync(path)) return;
+    const own = next();
+    try { renameSync(path, own); claims.push(own); } catch { /* another flusher took it */ }
+  });
+  return claims;
+}
+
+/** flushDeferred 주입점 — 시험은 실제 발송 대신 sendBatch 를 준다. */
+export type FlushDeferredDeps = {
+  sendBatch?: (text: string, kind: string, origin?: MissionOrigin) => boolean;
+  maxAttempts?: number;
+};
+
+/** 보류분 일괄 발송 — 묶음 단위. 배달 건수 반환.
+ *  무음 창 밖 첫 sendOutbound 가 자동 호출 + 06:31 플러시 크론이 보장.
+ *  ⭐ 실패한 묶음의 항목만 큐에 남긴다(성공 묶음은 다시 보내지 않는다 · 10-07 야간 11회 재발송 사고).
+ *  실패가 `maxAttempts` 번 쌓인 항목은 `<name>.failed.jsonl` 로 격리한다. */
+export function flushDeferred(path = DEFERRED_PATH, deps: FlushDeferredDeps = {}): number {
   ensureOutboundLogSink();
-  const observeFlush = (count: number, lagMin: number, kinds: string[]): void => {
+  const observeFlush = (
+    count: number, lagMin: number, kinds: string[],
+    outcome: { sent: number; kept: number; quarantined: number },
+  ): void => {
     const lagWarnMin = flushLagWarnMin();
     const over = count > 0 && lagMin > lagWarnMin;
     logSend(
       'flush',
       'deferred-batch',
-      { count, lagMin, kinds: kinds.map(safeObservationLabel), path, lagWarnMin },
+      { count, lagMin, kinds: kinds.map(safeObservationLabel), path, lagWarnMin, ...outcome },
       over ? { level: 'warn' } : undefined,
     );
   };
-  if (!existsSync(path)) {
-    observeFlush(0, 0, []);
+  const none = { sent: 0, kept: 0, quarantined: 0 };
+  const claims = claimDeferred(path);
+  if (claims.length === 0) {
+    observeFlush(0, 0, [], none);
     return 0;
   }
-  type Item = { ts: string; kind: string; text: string; origin?: MissionOrigin };
-  let items: Item[] = [];
-  try {
-    items = readFileSync(path, 'utf-8').split('\n').filter(Boolean).map(l => JSON.parse(l));
-  } catch { /* 손상 라인 무시 */ }
+  type Item = { ts: string; kind: string; text: string; origin?: MissionOrigin; attempts?: number };
+  const items: Item[] = [];
+  const corrupt: string[] = [];
+  const readClaims: string[] = [];
+  for (const claim of claims) {
+    let body = '';
+    try { body = readFileSync(claim, 'utf-8'); } catch (e) {
+      // 못 읽은 claim 은 지우지 않는다 — 다음 flush 가 다시 회수한다.
+      try { debug.log('outbound.send', 'deferred-claim-unreadable', { error: e instanceof Error ? e.message : String(e) }, { level: 'warn' }); } catch { /* */ }
+      continue;
+    }
+    readClaims.push(claim);
+    for (const line of body.split('\n')) {
+      if (!line.trim()) continue;
+      try {
+        const rec = JSON.parse(line) as Item;
+        if (rec && typeof rec === 'object' && typeof rec.text === 'string') items.push(rec);
+        else corrupt.push(line);
+      } catch { corrupt.push(line); }
+    }
+  }
+  const qPath = deferredQuarantinePath(path);
+  const settleFailed = (stage: string, e: unknown): void => {
+    try { debug.log('outbound.send', 'deferred-settle-failed', { stage, error: e instanceof Error ? e.message : String(e) }, { level: 'warn' }); } catch { /* */ }
+  };
+  /** 읽은 claim 을 정산한다. 격리 기록이 실패하면 그 줄은 큐로 돌린다(다음에 다시 격리).
+   *  큐 기록이 실패하면 claim 하나를 «남길 줄만»으로 바꿔 두어 다음 flush 가 배달분을 다시 보내지 않게 한다. */
+  /** 정산된 claim 을 걷는다. 삭제가 실패하면 비워 둔다 — 남은 claim 이 다음 flush 에 배달분을 다시 내지 않게. */
+  const retireClaim = (claim: string): void => {
+    try { unlinkSync(claim); return; } catch (e) { settleFailed('claim-unlink', e); }
+    try { writeFileSync(claim, ''); } catch (e) { settleFailed('claim-truncate', e); }
+  };
+  type Quarantine = { line: string; kind?: string; attempts?: number };
+  /** 반환 = 실제 정산 결과(관측은 이것으로 센다). */
+  const settle = (keep: string[], quarantine: Quarantine[]): { kept: number; quarantined: number } => {
+    let back = keep;
+    let quarantined = 0;
+    if (quarantine.length) {
+      try {
+        appendFileSync(qPath, quarantine.map(q => q.line).join('\n') + '\n');
+        quarantined = quarantine.length;
+        for (const q of quarantine) {
+          if (q.kind === undefined) continue;
+          try { debug.log('outbound.send', 'deferred-quarantined', { kind: safeObservationLabel(q.kind), attempts: q.attempts }); } catch { /* */ }
+        }
+      } catch (e) { settleFailed('quarantine', e); back = [...keep, ...quarantine.map(q => q.line)]; }
+    }
+    const result = { kept: back.length, quarantined };
+    if (readClaims.length === 0) return result;
+    let wrote = back.length === 0;
+    if (!wrote) {
+      try { withQueueLock(path, () => appendFileSync(path, back.join('\n') + '\n')); wrote = true; } catch (e) { settleFailed('queue', e); }
+    }
+    if (!wrote) {
+      const first = readClaims[0]!;
+      const tmp = join(dirname(first), `.${basename(first)}.tmp`);
+      try {
+        writeFileSync(tmp, back.join('\n') + '\n');
+        renameSync(tmp, first);
+        for (const claim of readClaims.slice(1)) retireClaim(claim);
+      } catch (e) { settleFailed('claim-rewrite', e); }
+      return result;
+    }
+    for (const claim of readClaims) retireClaim(claim);
+    return result;
+  };
+  const maxAttempts = deps.maxAttempts ?? deferredMaxAttempts();
+  const priorAttempts = (it: Item): number =>
+    typeof it.attempts === 'number' && Number.isSafeInteger(it.attempts) && it.attempts > 0 ? it.attempts : 0;
+  const quarantine: Quarantine[] = corrupt.map(line => ({ line }));
+  // 이미 상한에 닿은 줄(앞 flush 의 격리 기록이 실패해 큐로 돌아온 것)은 보내지 않고 다시 격리만 시도한다.
+  for (let i = items.length - 1; i >= 0; i--) {
+    const it = items[i]!;
+    if (priorAttempts(it) < maxAttempts) continue;
+    quarantine.push({ line: JSON.stringify(it), kind: it.kind, attempts: priorAttempts(it) });
+    items.splice(i, 1);
+  }
   if (items.length === 0) {
-    try { unlinkSync(path); } catch { /* */ }
-    observeFlush(0, 0, []);
+    const settled = settle([], quarantine);
+    observeFlush(0, 0, [], { ...none, ...settled });
     return 0;
   }
   const kst = (iso: string) => {
@@ -236,8 +399,7 @@ export function flushDeferred(path = DEFERRED_PATH): number {
     `🌙 야간 보류 알림 ${list.length}건 (00:00~06:30 KST 무음 · ⏳ 최대 ${lagMin}분 지연 — 일괄 전달)`,
     ...list.map(i => `\n── [${kst(i.ts)} · ${i.kind}] ──\n${i.text}`),
   ].join('\n');
-  observeFlush(items.length, lagMin, [...new Set(items.map(i => i.kind))]);
-  const sendBatch = (text: string, kind: string, origin?: MissionOrigin): boolean => {
+  const sendBatch = deps.sendBatch ?? ((text: string, kind: string, origin?: MissionOrigin): boolean => {
     let bot = 'unknown';
     const path = origin
       ? (deliverToOrigin(origin, text, label => { bot = label; }) ? 'origin' : false)
@@ -250,15 +412,17 @@ export function flushDeferred(path = DEFERRED_PATH): number {
       });
     } catch { /* observation must not change delivery */ }
     return path !== false;
+  });
+  const failed: Item[] = [];
+  const send = (batch: Item[], kind: string, origin?: MissionOrigin): void => {
+    if (!sendBatch(fmt(batch), kind, origin)) failed.push(...batch);
   };
-  let delivered = 0;
   // origin 없는 매매 알림만 report 묶음. 그 외는 kind 별로 운영 봇 경계를 유지한다.
   const noOrigin = items.filter(i => !i.origin);
   const tradingBatch = noOrigin.filter(i => !isOperationalKind(i.kind));
-  if (tradingBatch.length && sendBatch(fmt(tradingBatch), 'report')) delivered += tradingBatch.length;
+  if (tradingBatch.length) send(tradingBatch, 'report');
   for (const kind of new Set(noOrigin.filter(i => isOperationalKind(i.kind)).map(i => i.kind))) {
-    const batch = noOrigin.filter(i => i.kind === kind);
-    if (sendBatch(fmt(batch), kind)) delivered += batch.length;
+    send(noOrigin.filter(i => i.kind === kind), kind);
   }
   // origin 있는 것 = 발신 채널·스레드별로 묶어 서로 다른 수신자에게 섞이지 않게 발송.
   const groups = new Map<string, { origin: MissionOrigin; list: Item[] }>();
@@ -272,10 +436,19 @@ export function flushDeferred(path = DEFERRED_PATH): number {
   }
   for (const g of groups.values()) {
     const kinds = new Set(g.list.map(i => i.kind));
-    if (sendBatch(fmt(g.list), kinds.size === 1 ? g.list[0]!.kind : 'mixed', g.origin)) delivered += g.list.length;
+    send(g.list, kinds.size === 1 ? g.list[0]!.kind : 'mixed', g.origin);
+  }
+  // 실패 묶음의 항목만 되돌린다(시도 수 +1). 상한에 닿은 항목은 격리 — 영원히 재시도하지 않는다.
+  const keep: string[] = [];
+  for (const it of failed) {
+    const attempts = priorAttempts(it) + 1;
+    const line = JSON.stringify({ ...it, attempts });
+    if (attempts >= maxAttempts) quarantine.push({ line, kind: it.kind, attempts });
+    else keep.push(line);
   }
-  // 전량 배달 성공 시에만 파일 제거(부분 실패는 다음 flush 재시도 — 성공분 중복은 드문 엣지 수용).
-  if (delivered >= items.length) { try { unlinkSync(path); } catch { /* */ } }
+  const settled = settle(keep, quarantine);
+  const delivered = items.length - failed.length;
+  observeFlush(items.length, lagMin, [...new Set(items.map(i => i.kind))], { sent: delivered, ...settled });
   return delivered;
 }
 

package/src/domains/outbound-log-probe.ts

@@ -1,8 +1,23 @@
-import { sendOutbound, setInProcessOutbound } from './outbound-alert.js';
+import { inQuietHours, kstMinutes, sendOutbound, setInProcessOutbound } from './outbound-alert.js';
 import { setUserConfigOverlay } from '../user-config.js';
 
 // Focused subprocess fixture: isolated state/config roots and a fake curl on PATH.
 setUserConfigOverlay(cfg => ({ ...cfg, telegram: { ...cfg.telegram, botToken: '123456:private-secret', homeChannel: 98765 } }));
 process.env.SEND_VIA_ELANOUS = '0';
+// Quiet hours (00:00~06:30 KST) defer instead of sending, so a gate run at night saw no `sent` row.
+// Shift this fixture's clock back to 23:59 KST of the previous day; the shift stays inside this process.
+const quietShiftMs = inQuietHours() ? (kstMinutes() + 1) * 60_000 : 0;
+if (quietShiftMs > 0) {
+  const RealDate = Date;
+  const shifted = () => RealDate.now() - quietShiftMs;
+  class ShiftedDate extends RealDate {
+    constructor(...args: unknown[]) {
+      if (args.length === 0) super(shifted());
+      else super(...(args as [string | number | Date]));
+    }
+    static override now(): number { return shifted(); }
+  }
+  globalThis.Date = ShiftedDate as DateConstructor;
+}
 setInProcessOutbound(null);
 if (!sendOutbound('SECRET-BODY-DO-NOT-LOG', 'ops-alert', { channel: 'cli', surface: process.env.OUTBOUND_PROBE_SOURCE ?? 'outbound-log-probe' })) process.exitCode = 1;

package/src/domains/release-tool.ts

@@ -2,7 +2,7 @@ import type { LLMToolSpec } from '../llm.js';
 import type { ToolRuntimeContext } from '../tool-runtime/types.js';
 import { debug } from '../debug/log.js';
 import { requestConfirmation, type ConfirmOpts, type ConfirmResult } from '../hitl/confirm.js';
-import { devVersion, listChecklist, summarizeChecklist, type Checklist } from '../release-loop/checklist.js';
+import { devVersion, checklistDevVersion, listChecklist, summarizeChecklist, type Checklist } from '../release-loop/checklist.js';
 import { add, move, validateVersion } from '../release-loop/feature-store.js';
 import { formatKst, getSchedule, setSchedule, type ReleaseSchedule } from '../release-loop/release-schedule.js';
 import { latestGraphRun, type GraphRunState } from '../graph-runner/runner.js';
@@ -64,7 +64,7 @@ function dDay(days: number): string {
 export function dispatchReleaseStatus(args: Record<string, unknown>, deps: ReleaseToolDeps = {}): { text: string; structured: Record<string, unknown> } {
   const requested = args.version;
   if (requested !== undefined && (typeof requested !== 'string' || !requested.trim())) throw new Error('판 이름이 필요합니다');
-  const version = requested ? null : (deps.devVersion?.() ?? devVersion());
+  const version = requested ? null : checklistDevVersion(deps.devVersion?.() ?? devVersion());
   const versions = requested ? [requested as string] : [version!, nextVersion(version!)];
   const now = deps.now ?? new Date();
   const run = (deps.latestRun ?? latestGraphRun)('release-loop');