elanous 0.2.6 → 0.2.7

package/scripts/codex-quota-alert.ts

@@ -23,28 +23,22 @@
 // state: ~/.elanous/conatus/codex_quota_alert_state.json
 
 import { sendOutbound } from '../src/domains/outbound-alert.js';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { ensureCronNodePath } from '../src/domains/cron-path.js';
 import { registerStandaloneLogSink } from '../src/domains/standalone-log-sink.js';
 import { getUserConfig } from '../src/user-config.js';
-import { creditsSummary, formatCreditsSummary } from './codex-quota-alert-format.js';
+import { buildLlmBudgetAlert, type LlmBudgetSnapshot } from '../src/notify/llm-budget-alert.js';
+import { creditPaceStatus, recordCreditBalances } from '../src/budget/codex-credit-pace.js';
+import { loadLlmPolicy } from '../src/policy/llm-policy.js';
+import { DEFAULT_FALLBACK_CHAIN } from '../src/oauth/fallback-chain.js';
 import {
-  CODEX_QUOTA_POLICY_LABEL, codexPolicyAllowsCredits, codexPolicyAllowsFallback, resolveCodexQuotaPolicy,
+  codexPolicyAllowsCredits, codexPolicyAllowsFallback, resolveCodexQuotaPolicy,
 } from '../src/oauth/codex-quota-policy.js';
 
 const STATE = join(homedir(), '.elanous/conatus/codex_quota_alert_state.json');
-/** 잔여가 이 % 이하로 내려간 계정을 «임박»으로 본다. */
-const LOW_REMAINING_PERCENT = 10;
-/** 리셋권 만료가 이 일수 안이면 알린다. */
-const RESET_CREDIT_EXPIRY_DAYS = 7;
-/** 정책 `credits`(크레딧 사용이 «허가된» 상태)에서 잔액 보고의 발송 단위 — 이만큼 줄 때마다 한 번.
- *  ⛔ 허가된 지출을 매시 경보로 보내면 진짜 경보(리셋 전 고갈 · 정책 위반)가 묻힌다(대표 2026-09-28 «정책과 안 맞는다»).
- *  허가 «밖»(within-quota·fallback)에서는 종전대로 줄 때마다 보낸다 — 그때는 줄어드는 것 자체가 사고다. */
-const CREDITS_REPORT_STEP = 5000;
-
 interface AccountRow {
   provider: string; accountName: string;
   credits?: { usedPercent?: number; periodEnd?: string; balance?: number; hasCredits?: boolean };
@@ -86,283 +80,153 @@ function hoursUntil(ms?: number): number | null {
   if (typeof ms !== 'number' || !Number.isFinite(ms)) return null;
   return Math.round(((ms - Date.now()) / 3_600_000) * 10) / 10;
 }
-function daysUntil(iso?: string): number | null {
-  if (!iso) return null;
-  const t = Date.parse(iso);
-  if (Number.isNaN(t)) return null;
-  return Math.round(((t - Date.now()) / 86_400_000) * 10) / 10;
-}
-
-function loadState(): Record<string, string> {
-  try { return JSON.parse(readFileSync(STATE, 'utf8')) as Record<string, string>; } catch { return {}; }
+function loadState(path = STATE): Record<string, string> {
+  try { return JSON.parse(readFileSync(path, 'utf8')) as Record<string, string>; } catch { return {}; }
 }
-function saveState(s: Record<string, string>): void {
-  try { mkdirSync(dirname(STATE), { recursive: true }); writeFileSync(STATE, JSON.stringify(s, null, 1)); }
+function saveState(s: Record<string, string>, path = STATE): void {
+  try { mkdirSync(dirname(path), { recursive: true }); writeFileSync(path, JSON.stringify(s, null, 1)); }
   catch { /* 상태 저장 실패가 발송을 막지 않는다 */ }
 }
 
-export async function runCodexQuotaAlert(): Promise<void> {
-const usage = readUsage();
+export async function runCodexQuotaAlert(deps: { readUsage?: typeof readUsage; statePath?: string; send?: typeof sendOutbound } = {}): Promise<void> {
+const send = deps.send ?? sendOutbound;
+const usage = (deps.readUsage ?? readUsage)();
+const load = () => loadState(deps.statePath);
+const save = (s: Record<string, string>) => saveState(s, deps.statePath);
 if ('error' in usage) {
   // ⛔ 「못 쟀다」도 알린다 — 조회가 죽은 채로 조용하면 한도 경고가 «영영» 안 온다.
   const key = 'usage-unreadable';
-  const prev = loadState();
-  if (prev[key] !== usage.error) {
-    sendOutbound(`⚠️ **LLM 한도 조회가 실패했습니다** — 경고가 이 상태로는 안 옵니다.\n\n사유: \`${usage.error}\``, 'alert');
-    saveState({ ...prev, [key]: usage.error });
+  const prev = load();
+  if (prev[key] !== usage.error && send(`⚠️ **LLM 한도 조회가 실패했습니다** — 경고가 이 상태로는 안 옵니다.\n\n사유: \`${usage.error}\``, 'alert')) {
+    save({ ...prev, [key]: usage.error });
   }
   process.exit(0);
 }
 
 // 대표 2026-09-28 한도 정책(`llm.codexQuotaPolicy`) — 알림 문구·발송 기준이 «설정된 정책»을 따른다.
 let quota = resolveCodexQuotaPolicy(undefined);
-try { quota = resolveCodexQuotaPolicy(getUserConfig().llm); } catch { /* 못 읽으면 기본(fallback) */ }
+let configuredFallback: string[] | undefined;
+try {
+  const llm = getUserConfig().llm;
+  quota = resolveCodexQuotaPolicy(llm);
+  configuredFallback = llm.fallbackChain;
+} catch { /* 못 읽으면 기본(fallback) */ }
 const creditsAllowed = codexPolicyAllowsCredits(quota.policy);
 const fallbackAllowed = codexPolicyAllowsFallback(quota.policy);
 
 const codex = usage.rows.filter((r) => r.provider === 'codex');
 const others = usage.rows.filter((r) => r.provider !== 'codex');
-
-/**
- * 🩸 «못 읽은 계정» — 이 자의 가장 위험한 실패다.
- *   📏 2026-09-19 실측(🅕 관측): `usage --json` 이 ***간헐적으로 전부 null 을 낸다***.
- *   같은 계정을 몇십 초 차로 두 번 쟀는데 한쪽은 `used=100 · hasCredits=true · 잔액 2965`,
- *   다른 쪽은 ***전부 None*** 이었다. 그 틱에 종전 코드는:
- *     exhausted : (rem ?? 100) <= 0          ⇒ null 이 «100» 이 되어 「소진 아님」
- *     burning   : capped && hasCredits       ⇒ capped=false 라 「안 태운다」
- *     low       : typeof rem === 'number'    ⇒ 건너뜀
- *   ⇒ ***세 갈래가 모두 조용해져 「경고 조건 없음」을 낸다 — 자가 눈이 먼 채 「정상」이라 말한다.***
- *   🩹 그래서 「못 읽음」을 «값으로» 센다. ⛔ 「안전」으로도 「소진」으로도 접지 않는다.
- */
-const unreadable = codex.filter((r) => {
-  const rem = r.subscription?.remainingPercent;
-  const used = r.credits?.usedPercent;
-  return typeof rem !== 'number' && typeof used !== 'number';
-});
-
-// ⛔ 「못 읽음」은 소진 판정에서 «뺀다» — 그것은 별도 갈래이고, 섞으면 둘 다 못 읽는다.
-const exhausted = codex.filter((r) => !unreadable.includes(r)
-  && (r.subscription?.remainingPercent ?? 100) <= 0);
-const low = codex.filter((r) => {
-  const rem = r.subscription?.remainingPercent;
-  return typeof rem === 'number' && rem > 0 && rem <= LOW_REMAINING_PERCENT;
-});
-// 🔥 «돈이 나가는 중» — 한도를 넘겼는데 요청이 안 죽는 계정. 소진 경고와 «다른 축»이다:
-//   소진은 「멈췄다」이고 이것은 ***「안 멈췄다」***이다. 후자가 과금이다.
-const burning = codex.filter((r) => {
-  if (unreadable.includes(r)) return false;   // 못 읽은 것은 위 unreadable 이 «따로» 말한다
-  const rem = r.subscription?.remainingPercent;
-  const used = r.credits?.usedPercent;
-  const capped = (typeof rem === 'number' && rem <= 0) || (typeof used === 'number' && used >= 100);
-  return capped && r.credits?.hasCredits === true;
-});
-
-const expiring = codex.filter((r) => {
-  const d = daysUntil(r.resetCredits?.expiresAt);
-  return r.resetCredits?.status === 'available' && d !== null && d <= RESET_CREDIT_EXPIRY_DAYS;
-});
+const unreadableCount = codex.filter((r) => typeof r.subscription?.remainingPercent !== 'number'
+  || !Number.isFinite(r.subscription.remainingPercent)).length;
+const knownExhausted = codex.filter((r) => typeof r.subscription?.remainingPercent === 'number'
+  && Number.isFinite(r.subscription.remainingPercent) && r.subscription.remainingPercent <= 0);
+const knownLow = codex.filter((r) => typeof r.subscription?.remainingPercent === 'number'
+  && Number.isFinite(r.subscription.remainingPercent) && r.subscription.remainingPercent > 0 && r.subscription.remainingPercent <= 10);
+const exhausted = codex.length > 0 && unreadableCount === 0 && knownExhausted.length === codex.length;
+const creditAvailable = codex.some((r) => r.credits?.hasCredits === true && typeof r.credits.balance === 'number' && r.credits.balance > 0);
+const fallback = fallbackAllowed ? others.find((r) =>
+  (configuredFallback ?? DEFAULT_FALLBACK_CHAIN).some((step) => step === r.provider)
+  && typeof r.subscription?.remainingPercent === 'number' && Number.isFinite(r.subscription.remainingPercent)
+  && r.subscription.remainingPercent > 0) : undefined;
 
 const nowMs = Date.now();
-const prevState = loadState();
+const prevState = load();
 
-/**
- * 🩸 「지금도 나가는 중인가」는 «임계»로 못 잡는다 — 그 자가 한 번 눈이 멀었다.
- *   📏 2026-09-18: 실물 유출이 «분당 -0.33» 이었는데, 종전 서명은 잔액을 50 단위로 접어서
- *   ***한 시간에 -20 이면 구간을 안 넘어 「상태 동일 — 무발송」*** 을 냈다. 즉 «켜져 있는데 안 보였다».
- *   🩹 그래서 임계를 버리고 ***직전 표본 대비 «감소했나»*** 로 바꾼다 — 얼마든 줄면 줄었다고 말한다.
- *   ⛔ 도배되지 않는 이유는 «감소 자체»가 아니라 `burning` 게이트다(한도 100% ⊕ hasCredits=true).
- *     그 상태에서 줄고 있으면 그것은 ***지금 돈이 나가는 중***이고, 매 틱 알리는 것이 옳다.
- *   ⛔ 직전 표본이 «없으면» 「안 준다」가 아니라 「모른다」다 — 첫 틱은 기준선만 적는다.
- */
-function drainOf(r: AccountRow): { state: 'draining' | 'flat' | 'unknown'; delta?: number; perHour?: number; windowMin?: number } {
-  const now = r.credits?.balance;
-  const before = Number(prevState[`balance:${r.accountName}`]);
-  const beforeAt = Number(prevState[`balanceAt:${r.accountName}`]);
-  if (typeof now !== 'number' || !Number.isFinite(before)) return { state: 'unknown' };
-  const delta = now - before;
-  if (delta >= 0) return { state: 'flat', delta };
-  const hours = Number.isFinite(beforeAt) ? (nowMs - beforeAt) / 3_600_000 : NaN;
-  // ⛔ 속도와 ETA 는 «한 구간의 기울기»다 — 창이 짧으면 버스트 하나가 그 기울기를 지배한다.
-  //   📏 2026-09-18 실측: 5분 창이 «시간당 -165 · 19시간 뒤 0» 을 냈는데, 직후 187초 실측은
-  //   «시간당 -4.2»(33배 차이)였다. 앞의 수는 틀린 게 아니라 ***그 창에서 참***이었고,
-  //   읽는 사람이 그것을 「지속 속도」로 읽은 것이 문제다.
-  //   🩹 ⇒ 임의 임계로 «막지» 않는다(그 상수를 관례로 채울 근거가 없다).
-  //      대신 ***창의 길이를 값으로 같이 낸다*** — 읽는 쪽이 짧은 창을 스스로 깎게 한다.
-  return {
-    state: 'draining', delta,
-    ...(hours > 0 ? { perHour: delta / hours, windowMin: Math.round(hours * 60) } : {}),
-  };
-}
-const drain = new Map((quota.policy === 'credits' ? codex : burning)
-  .map((r) => [r.accountName, drainOf(r)] as const));
-// 🩸 2026-09-28: 머리줄이 «찬 ⊕ 크레딧 있음» 계정 수(3)를 «나가는 중» 으로 셌다 — 실제로 줄던 것은 default 하나.
-//   ⇒ «줄고 있다»(draining)와 «크레딧은 있지만 안 쓰는 중»을 가른다.
-const draining = burning.filter((r) => drain.get(r.accountName)?.state === 'draining');
-const creditHolders = quota.policy === 'credits'
-  ? codex.filter((r) => r.credits?.hasCredits === true)
-  : [];
-const combinedCredits = creditHolders.length >= 2 ? creditsSummary(creditHolders.map((r) => ({
-  name: r.accountName,
-  balance: r.credits?.balance,
-  perHour: drain.get(r.accountName)?.state === 'flat' ? 0 : drain.get(r.accountName)?.perHour,
-  resetInHours: hoursUntil(r.subscription?.resetsAt) ?? undefined,
-}))) : null;
-
-// ⭐ 상태를 «문자열 하나»로 접어 두고, 바뀔 때만 보낸다(같은 경고 반복 금지).
-const signature = JSON.stringify({
-  ex: exhausted.map((r) => r.accountName).sort(),
-  low: low.map((r) => `${r.accountName}:${r.subscription?.remainingPercent}`).sort(),
-  exp: expiring.map((r) => r.accountName).sort(),
-  // ⛔ 「못 읽음」이 서명에 없으면, 자가 눈먼 상태가 「상태 동일」로 조용해진다.
-  unread: unreadable.map((r) => r.accountName).sort(),
-  policy: quota.policy,
-  ...(combinedCredits ? { beforeReset: combinedCredits.beforeReset } : {}),
-  // ⛔ 「줄고 있는 중」은 «매 틱» 서명이 달라야 한다 — 돈이 계속 나가는데 한 번만 알리면
-  //   두 번째 시간부터는 「상태 동일」로 조용해진다. 그래서 draining 이면 원값을 넣는다.
-  //   ⛔ 반대로 멎었으면(flat) 원값을 넣지 «않는다» — 그래야 반복 발송이 멎는다.
-  burn: burning.map((r) => {
-    const d = drain.get(r.accountName);
-    if (d?.state !== 'draining') return `${r.accountName}:${d?.state ?? 'unknown'}`;
-    const b = r.credits?.balance;
-    // 허가된 크레딧 지출은 «단위»로 접는다 — 단 «리셋 전에 바닥난다»로 바뀌면 단위와 무관하게 서명이 바뀐다.
-    const resetH = hoursUntil(r.subscription?.resetsAt);
-    const etaH = d.perHour && d.perHour < 0 && typeof b === 'number' ? b / -d.perHour : null;
-    const risk = !combinedCredits && etaH !== null && (resetH === null || etaH < resetH) ? ':before-reset' : '';
-    return `${r.accountName}:${creditsAllowed ? b === undefined ? 'balance-unknown' : `step${Math.floor(b / CREDITS_REPORT_STEP)}${risk}` : String(b ?? 0)}`;
-  }).sort(),
-});
-const prev = prevState;
-// ⭐ 잔액은 «경고와 무관하게» 매 틱 적어 둔다 — 안 적으면 델타의 기준선이 영영 안 생긴다.
-//   ⛔ 다만 signature 는 «발송에 성공했을 때만» 전진한다(그 규율은 아래 그대로다).
 const balances: Record<string, string> = {};
+const creditBalances: Record<string, number> = {};
 for (const r of codex) {
   if (typeof r.credits?.balance === 'number') {
+    creditBalances[r.accountName] = r.credits.balance;
     balances[`balance:${r.accountName}`] = String(r.credits.balance);
     // ⭐ 값과 «시각»을 같이 남긴다 — 속도(시간당 얼마)는 두 축이 있어야 나온다.
     balances[`balanceAt:${r.accountName}`] = String(nowMs);
   }
 }
-
-if (prev.signature === signature) {
-  saveState({ ...prev, ...balances });
-  console.log(`[codex-quota-alert] 상태 동일 — 무발송 (소진 ${exhausted.length} · 임박 ${low.length})`);
-  process.exit(0);
-}
-
-if (exhausted.length === 0 && low.length === 0 && expiring.length === 0 && burning.length === 0
-    && unreadable.length === 0 && !combinedCredits) {
-  console.log('[codex-quota-alert] 경고 조건 없음');
-  saveState({ ...prev, ...balances, signature });
-  process.exit(0);
-}
-
-const lines: string[] = [];
-lines.push(`🧭 정책: **${CODEX_QUOTA_POLICY_LABEL[quota.policy]}** (\`llm.codexQuotaPolicy=${quota.policy}\`${quota.source === 'legacy-credits' ? ' · 옛 codexCreditsAllowed 에서' : quota.source === 'default' ? ' · 기본값' : quota.source === 'invalid' ? ' · ⚠️ 모르는 값이라 기본값' : ''})`);
-lines.push('');
-// ⛔ 「못 읽음」을 맨 위에 둔다 — 아래 판정들이 «그만큼 눈이 먼» 상태임을 먼저 말해야 한다.
-if (unreadable.length > 0) {
-  lines.push(`⚠️ **계정 ${unreadable.length}개를 «못 읽었습니다»** — 아래 판정은 그만큼 눈이 멉니다.`);
-  for (const r of unreadable) lines.push(`  • \`${r.accountName}\` — 사용률·잔여가 «둘 다» 없습니다`);
-  lines.push('⛔ 이것은 「정상」이 아니라 「모름」입니다. 다음 틱에 값이 돌아오면 그때 판정이 바뀝니다.');
-  lines.push('');
-}
-// 🔥 돈이 나가는 축을 «맨 위»에 둔다 — 소진은 멈춘 것이고 이것은 안 멈춘 것이다.
-if (burning.length > 0 || combinedCredits) {
-  if (creditsAllowed) {
-    lines.push(burning.length > 0
-      ? `💳 **크레딧으로 진행 중 — 줄고 있는 계정 ${draining.length}개** (크레딧 보유 ${burning.length}개 · 정책상 허가된 지출)`
-      : '💳 **크레딧 보유 계정**');
-    if (combinedCredits) lines.push(formatCreditsSummary(combinedCredits));
-    if (burning.length > 0) lines.push(combinedCredits
-      ? `잔액이 ${CREDITS_REPORT_STEP} 단위로 줄 때마다 한 번 알립니다. 리셋 전 고갈은 합계로 판정합니다.`
-      : `잔액이 ${CREDITS_REPORT_STEP} 단위로 줄 때마다 한 번 알립니다. 🚨 표시가 있으면 리셋 전에 바닥납니다.`);
-  } else {
-    lines.push(`🚨 **정책 밖 지출 — 한도를 넘겼는데 크레딧에서 나가고 있습니다 (줄고 있는 계정 ${draining.length}개 · 크레딧 보유 ${burning.length}개)**`);
-    lines.push(`정책이 «${CODEX_QUOTA_POLICY_LABEL[quota.policy]}» 인데 레이트리밋 오류가 안 나 회전·폴백이 안 열립니다. 크레딧을 허가하려면 \`elanous config set llm.codexQuotaPolicy credits\`.`);
-  }
-  for (const r of burning) {
-    const now = r.credits?.balance;
-    const nowText = typeof now === 'number' ? now.toFixed(2) : '미상';
-    const d = drain.get(r.accountName);
-    let tail: string;
-    if (!d || d.state === 'unknown') tail = ' (직전 관측 없음 — 이번이 첫 표본입니다)';
-    else if (d.state === 'flat') tail = ' · 크레딧 보유 · 직전 관측 이후 «안 썼습니다»';
-    else {
-      // ⛔ 남은 시간은 «속도를 실제로 쟀을 때만» 말한다 — 지어내면 사람이 그 수로 계획을 세운다.
-      const rate = d.perHour;
-      // 🩸 그리고 「N시간 뒤 0」만 내면 «겁만 준다» — 한도 창이 «먼저» 리셋되면 고갈은 «안 온다».
-      //   📏 2026-09-18 실측: 고갈 예상 144시간 vs 리셋 22.5시간 ⇒ 리셋이 먼저다(고갈 안 된다).
-      //   그 비교 없이 내면 사람이 「145시간 뒤 0」을 읽고 «긴급»으로 오독한다.
-      //   ⇒ 「나가는 중」(늘 말할 값)과 「고갈된다」(진짜 긴급)를 «가른다».
-      const etaH = rate && rate < 0 && typeof now === 'number' ? now / -rate : null;
-      const resetH = hoursUntil(r.subscription?.resetsAt);
-      let eta = '';
-      if (etaH !== null && !combinedCredits) {
-        const h = Math.max(0, Math.round(etaH));
-        if (resetH !== null && resetH > 0 && resetH < etaH) {
-          // 리셋이 먼저 온다 — 이 창에서 탈 양까지 «수»로 말한다.
-          const burnLeft = Math.round(-(rate as number) * resetH);
-          eta = ` · ⏳ 리셋(${resetH}시간 뒤)이 «먼저» 옵니다 — 이 창에서 약 ${burnLeft} 더 타고 고갈은 «안 됩니다»`;
-        } else if (resetH === null) {
-          eta = ` · 이 속도면 약 ${h}시간 뒤 0 (⚠️ 리셋 시각을 못 읽어 «어느 쪽이 먼저인지» 모릅니다)`;
-        } else {
-          eta = ` · 🚨 이 속도면 약 ${h}시간 뒤 0 — 리셋(${resetH}시간 뒤)«보다 먼저»입니다`;
-        }
-      }
-      // ⭐ 창을 «값으로» 낸다 — 「시간당 -165」가 5분 창의 것인지 한 시간 창의 것인지가 갈린다.
-      const win = d.windowMin !== undefined ? `${d.windowMin}분 창 · ` : '';
-      tail = ` · 직전 대비 **${d.delta?.toFixed(2)}**`
-        + (rate ? ` (${win}시간당 ${rate.toFixed(1)})` : ' (경과를 못 재 속도는 미상)') + eta;
-    }
-    lines.push(`  • \`${r.accountName}\` — 잔액 ${nowText}${tail}`);
-  }
-  lines.push('');
-}
-if (exhausted.length === codex.length && codex.length > 0) {
-  lines.push(`${creditsAllowed ? '💳' : '🚨'} **codex 구독 한도가 «전부» 찼습니다 (${codex.length}/${codex.length})**`);
-  if (creditsAllowed) lines.push('정책 «크레딧까지» — codex 를 크레딧으로 계속 씁니다. 크레딧까지 떨어지면 폴백 체인으로 갑니다.');
-  else if (fallbackAllowed) lines.push(`정책 «자동 폴백» — 폴백 체인(\`llm.fallbackChain\`)으로 갑니다. 폴백 대상의 한도도 같이 보십시오.`);
-  else lines.push('정책 «한도 안에서만» — codex 작업은 리셋까지 «멈춥니다»(폴백·크레딧 없음).');
-} else if (exhausted.length > 0) {
-  lines.push(`⚠️ **codex 계정 ${exhausted.length}/${codex.length} 한도 참** — 남은 계정으로 회전합니다`);
-}
-for (const r of exhausted) {
-  const h = hoursUntil(r.subscription?.resetsAt);
-  lines.push(`  • \`${r.accountName}\` — 잔여 0% · 리셋 ${h === null ? '시각 미상' : `${h}시간 뒤`}`);
-}
-for (const r of low) {
-  const h = hoursUntil(r.subscription?.resetsAt);
-  lines.push(`  • \`${r.accountName}\` — 잔여 ${r.subscription?.remainingPercent}% · 리셋 ${h === null ? '미상' : `${h}시간 뒤`}`);
-}
-if (expiring.length > 0) {
-  lines.push('');
-  lines.push(`💳 **리셋권 만료 임박 (${RESET_CREDIT_EXPIRY_DAYS}일 이내)**`);
-  for (const r of expiring) lines.push(`  • \`${r.accountName}\` — ${daysUntil(r.resetCredits?.expiresAt)}일 뒤`);
-}
-if (others.length > 0 && fallbackAllowed) {
-  lines.push('');
-  lines.push(creditsAllowed ? '폴백 대상(크레딧까지 떨어진 뒤):' : '폴백 대상:');
-  for (const r of others) {
-    const rem = r.subscription?.remainingPercent;
-    const used = r.credits?.usedPercent;
-    lines.push(`  • \`${r.provider}/${r.accountName}\` — ${rem !== undefined ? `잔여 ${rem}%` : used !== undefined ? `사용 ${used}%` : '미상'}`);
-  }
-}
-lines.push('');
-lines.push('⛔ 잔액 숫자는 provider 가 준 값 그대로입니다 — 토큰을 달러로 바꾸는 자는 아직 없습니다.');
-
-const msg = lines.join('\n');
-console.log(msg);
-if (sendOutbound(msg, 'alert')) {
-  saveState({ ...prev, ...balances, signature });
+try { recordCreditBalances(creditBalances, new Date(nowMs)); }
+catch { /* 날짜 원장 저장 실패는 기존 알림의 발송을 막지 않는다 */ }
+
+let policy;
+try { policy = loadLlmPolicy({ now: new Date(nowMs) }); }
+catch { policy = undefined; }
+let pace;
+try {
+  if (policy?.valid) pace = creditPaceStatus({ policy: policy.policy, balances: creditBalances, now: new Date(nowMs) });
+} catch { /* 페이스 조회 실패도 잔액 기록·알림 발송을 막지 않는다 */ }
+const resetExpiry = codex.map((r) => r.resetCredits?.status === 'available' ? r.resetCredits.expiresAt : undefined)
+  .filter((date): date is string => typeof date === 'string' && Number.isFinite(Date.parse(date)) && Date.parse(date) >= nowMs)
+  .sort((a, b) => Date.parse(a) - Date.parse(b))[0];
+const expiresAt = [
+  ...(policy?.valid ? policy.policy.credits.grants
+    .filter((grant) => grant.expires >= new Date(nowMs).toISOString().slice(0, 10))
+    .map((grant) => `${grant.expires}T15:00:00Z`) : []),
+  ...(resetExpiry ? [resetExpiry] : []),
+].sort((a, b) => Date.parse(a) - Date.parse(b))[0];
+const snapshot: LlmBudgetSnapshot = {
+  at: new Date(nowMs).toISOString(),
+  credits: {
+    total: codex.reduce((sum, r) => sum + (typeof r.credits?.balance === 'number' && Number.isFinite(r.credits.balance) ? r.credits.balance : 0), 0),
+    usedToday: pace?.todaySpent ?? 0,
+    paceTarget: pace?.target ?? 0,
+    ...(expiresAt ? { expiresAt } : {}),
+    ...(policy?.valid && policy.policy.credits.codex === 'use' && policy.policy.credits.pace?.until
+      && nowMs < Date.parse(`${policy.policy.credits.pace.until}T15:00:00Z`) ? { useFirst: true } : {}),
+  },
+  accounts: codex.map((r) => ({
+    name: r.accountName,
+    subscriptionRemainingPct: r.subscription?.remainingPercent,
+    credits: r.credits?.balance,
+    resetInHours: hoursUntil(r.subscription?.resetsAt) ?? undefined,
+  })),
+  selected: { reason: exhausted
+    ? creditsAllowed && creditAvailable ? 'credits' : fallback ? 'fallback' : 'none'
+    : 'subscription' },
+  ...(fallback && exhausted && !(creditsAllowed && creditAvailable) ? { fallback: {
+    provider: fallback.provider,
+    remainingPct: fallback.subscription?.remainingPercent,
+  } } : {}),
+};
+const knownAlerts = [...knownExhausted, ...knownLow].map((r) =>
+  `${r.accountName}:${r.subscription!.remainingPercent}`).sort();
+const unreadableAccounts = codex.filter((r) => typeof r.subscription?.remainingPercent !== 'number'
+  || !Number.isFinite(r.subscription.remainingPercent)).map((r) => r.accountName).sort();
+const unreadableKey = knownAlerts.length > 0
+  ? `unreadable:${unreadableAccounts.join(',')}:${knownAlerts.join(',')}`
+  : unreadableAccounts.length > 1 ? `unreadable:${unreadableAccounts.join(',')}` : 'unreadable';
+const alertKey = unreadableCount > 0 && prevState.nt1Key === unreadableKey ? undefined : prevState.nt1Key;
+const budgetAlert = buildLlmBudgetAlert(snapshot, alertKey);
+// 정책 밖 지출(리뷰 3라운드 must-fix) — 정책이 크레딧을 허가하지 않는데 직전 관측보다 잔액이 줄었다.
+//   NT1 모양의 다른 상태보다 앞선다(행동이 필요한 유일한 «사고»). 같은 날이라도 잔액이 한 단계 더 줄면 다시 알린다.
+const offPolicyDraining = creditsAllowed ? [] : codex.filter((r) => {
+  const before = Number(prevState[`balance:${r.accountName}`]);
+  return typeof r.credits?.balance === 'number' && Number.isFinite(before) && r.credits.balance < before;
+});
+const offPolicyStep = policy?.valid ? policy.policy.alerts.creditsStep : 5000;
+const offPolicyKey = offPolicyDraining.length > 0
+  ? `off-policy:${new Date(nowMs + 9 * 3600_000).toISOString().slice(0, 10)}:${Math.floor(snapshot.credits.total / Math.max(1, offPolicyStep))}`
+  : undefined;
+const offPolicyAlert = offPolicyKey ? {
+  send: prevState.nt1Key !== offPolicyKey,
+  key: offPolicyKey,
+  text: `🚨 정책 밖 지출 — 한도를 넘겼는데 크레딧에서 나가고 있습니다(줄고 있는 계정 ${offPolicyDraining.length}개).\n남은 크레딧 ${Math.round(snapshot.credits.total).toLocaleString('en-US')}.\n할 일: 허가하려면 \`elanous config set llm.codexQuotaPolicy credits\`, 아니면 크레딧 지출을 멈추세요.`,
+} : undefined;
+const alert = offPolicyAlert ?? (budgetAlert.key !== 'ok' || unreadableCount === 0 ? budgetAlert : {
+  send: prevState.nt1Key !== unreadableKey,
+  key: unreadableKey,
+  text: `⚠️ 일부 codex 계정의 구독 한도를 읽지 못했습니다.${knownExhausted.length > 0 ? ` 확인된 ${knownExhausted.length}개 계정은 한도가 소진됐습니다.` : knownLow.length > 0 ? ` 확인된 ${knownLow.length}개 계정은 잔여가 10% 이하입니다.` : ''}\n할 일: 한도 조회 상태를 확인해 주세요.`,
+});
+const state = { ...prevState, ...balances };
+if (!alert.send) {
+  if (alert.key === 'ok') delete state.nt1Key;
+  save(state);
+  console.log('[codex-quota-alert] NT1 상태 동일 또는 경고 조건 없음 — 무발송');
+  return;
+}
+console.log(alert.text);
+if (send(alert.text, 'alert')) {
+  save({ ...state, nt1Key: alert.key });
   console.log('\n✅ 텔레그램 발송');
 } else {
-  // ⛔ 발송 실패면 signature 를 «저장하지 않는다» — 다음 틱에 다시 시도해야 한다.
-  // 🩸 그런데 «잔액은 저장한다». 종전엔 여기서 통째로 안 저장해서, 발송이 막힌 동안
-  //   ***델타의 기준선이 얼어붙고 「직전 대비」가 「마지막 성공 발송 대비」로 «조용히» 둔갑***했다.
-  //   📏 실측 2026-09-18: 50초 간격 두 번에 -12.41 → -12.55 로 «거의 안 움직였고» 속도는 영영 「미상」이었다.
-  //   ⇒ 이 파일 머리의 규율(「잔액은 경고와 무관하게 매 틱 적는다」)이 «이 갈래에만» 안 걸려 있었다.
-  saveState({ ...prev, ...balances });
+  save(state);
   console.error('발송 실패(/v1/outbound + 텔레그램 직접 모두 실패) — 잔액 기준선은 갱신했다');
   process.exit(1);
 }

package/scripts/coord-tracks.json

@@ -1,10 +1,10 @@
 {
   "_comment": "조율 채널 세션 신원의 정본(09-30 역할 재편). id = 2글자 신원(발신 접두 **[TC]**) · title = 직함 · alias = 옛 한 글자(기록 읽기·전환기 발신용) · mark = 옛 표지. 세션을 더하려면 여기 한 줄만 더한다 — coord-post.sh · coord-channel-watch.sh · build-docs-site.ts · mission-phase-track.ts 가 이 파일을 읽는다.",
   "tracks": [
-    { "id": "OP", "title": "COO", "alias": "S", "mark": "🅢", "owns": ["판올림", "컷", "체크리스트", "분배", "통합", "로드맵", "기획", "총괄", "전략", "인계", "release cut", "roadmap", "plan", "strategy"] },
-    { "id": "MK", "title": "CMO", "alias": "T", "mark": "🅣", "owns": ["블로그", "콘텐츠", "발행", "광고", "프로모션", "소구점", "마케팅", "영상", "비디오", "티저", "하이퍼프레임", "렌더", "blog", "content", "marketing", "ads", "video", "teaser", "render", "B-roll", "상표", "변리사", "브랜드", "trademark", "brand", "홈페이지", "웹사이트", "elanous.ai", "elanvital.ai", "website"] },
-    { "id": "TC", "title": "CTO", "alias": "O", "mark": "🅞", "owns": ["하니스", "게이트", "원장", "리뷰", "관측", "릴리스 루프", "흡수", "Obsidian", "매뉴얼", "문서", "기술", "harness", "gate", "ledger", "review", "observability", "intake", "manual", "docs"] },
-    { "id": "UX", "title": "CXO", "alias": "F", "mark": "🅕", "owns": ["PWA", "웹", "탭", "화면", "UI", "프론트엔드", "안드로이드", "아이폰", "데스크톱", "텔레그램", "디스코드", "메신저", "봇", "frontend", "web", "tab", "android", "ios", "desktop", "telegram", "discord", "bot"] },
+    { "id": "OP", "title": "COO", "alias": "S", "mark": "🅢", "runtime": "claude-code", "owns": ["판올림", "컷", "체크리스트", "분배", "통합", "로드맵", "기획", "총괄", "전략", "인계", "release cut", "roadmap", "plan", "strategy"] },
+    { "id": "MK", "title": "CMO", "alias": "T", "mark": "🅣", "runtime": "claude-code", "owns": ["블로그", "콘텐츠", "발행", "광고", "프로모션", "소구점", "마케팅", "영상", "비디오", "티저", "하이퍼프레임", "렌더", "blog", "content", "marketing", "ads", "video", "teaser", "render", "B-roll", "상표", "변리사", "브랜드", "trademark", "brand", "홈페이지", "웹사이트", "elanous.ai", "elanvital.ai", "website"] },
+    { "id": "TC", "title": "CTO", "alias": "O", "mark": "🅞", "runtime": "claude-code", "owns": ["하니스", "게이트", "원장", "리뷰", "관측", "릴리스 루프", "흡수", "Obsidian", "매뉴얼", "문서", "기술", "harness", "gate", "ledger", "review", "observability", "intake", "manual", "docs"] },
+    { "id": "UX", "title": "CXO", "alias": "F", "mark": "🅕", "runtime": "claude-code", "owns": ["PWA", "웹", "탭", "화면", "UI", "프론트엔드", "안드로이드", "아이폰", "데스크톱", "텔레그램", "디스코드", "메신저", "봇", "frontend", "web", "tab", "android", "ios", "desktop", "telegram", "discord", "bot"] },
     { "id": "E", "mark": "🅔", "owns": [] }
   ]
 }

package/scripts/field-feed/deliver-node.ts

@@ -0,0 +1,52 @@
+#!/usr/bin/env bun
+// deliver node — «최종 게시» 승인 «뒤»에만 돈다. 읽는 것은 그 시점의 초안 파일(사람이 고친 최신본)이지 처음 생성본이 아니다.
+// ① 커버 문구·사진별 한 줄이 렌더 당시와 다르면 그 장만 다시 그린다 ② 포함된 장만 순서대로 <folder>/feed/ready/ 에 모은다
+// ③ caption.txt(훅·본문·해시태그·위치) ⊕ 릴스 사본 ④ 텔레그램(/v1/outbound)에 «승인됨 · 게시 준비 완료» 한 줄.
+// ⛔ 인스타그램에 올리지 않는다 — 실제 Meta 게시는 다음 판.
+import { copyFileSync, existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { sendOutbound } from '../../src/domains/outbound-alert.js';
+import { coverHtml, readContext, readDraft, result, screenshot, slideHtml, writeDraft } from './lib.js';
+
+try {
+  const { folder } = readContext();
+  const draft = readDraft(folder);
+  if (!draft) throw new Error('초안 없음 — feed 노드가 먼저 돌아야 한다');
+  const included = draft.slides.filter((s) => s.include);
+  if (!included.length) throw new Error('포함된 사진이 0장이다');
+
+  let redrawn = 0;
+  if (draft.cover.text !== draft.cover.renderedText || draft.cover.sub !== draft.cover.renderedSub || draft.cover.renderedSource !== included[0]!.source) {
+    screenshot(coverHtml(join(folder, included[0]!.source), draft.cover.text, draft.cover.sub), join(folder, draft.cover.image));
+    draft.cover.renderedText = draft.cover.text; draft.cover.renderedSub = draft.cover.sub; draft.cover.renderedSource = included[0]!.source; redrawn++;
+  }
+  included.forEach((s, i) => {
+    // 번호(01 / N)는 포함된 장 기준이라, 빼거나 순서를 바꾸면 글이 같아도 다시 그린다.
+    const label = `${i + 1}/${included.length}:${s.caption}`;
+    if (s.renderedCaption !== label) {
+      screenshot(slideHtml(join(folder, s.source), s.caption, i + 1, included.length), join(folder, s.image));
+      s.renderedCaption = label; redrawn++;
+    }
+  });
+  if (redrawn) writeDraft(folder, { ...draft, updatedAt: new Date().toISOString() });
+
+  const ready = join(folder, 'feed', 'ready');
+  rmSync(ready, { recursive: true, force: true });
+  mkdirSync(ready, { recursive: true });
+  copyFileSync(join(folder, draft.cover.image), join(ready, '00-cover.png'));
+  included.forEach((s, i) => copyFileSync(join(folder, s.image), join(ready, `${String(i + 1).padStart(2, '0')}.png`)));
+  const text = [draft.caption.hook, '', draft.caption.body, '', draft.hashtags.join(' '), ...(draft.location ? ['', `📍 ${draft.location}`] : [])].join('\n');
+  writeFileSync(join(ready, 'caption.txt'), text + '\n');
+  const reel = draft.reel && existsSync(join(folder, draft.reel)) ? join(ready, 'reel-9x16.mp4') : null;
+  if (reel) copyFileSync(join(folder, draft.reel!), reel);
+
+  // FIELD_FEED_NOTIFY=0 — 시험·리허설에서 텔레그램으로 나가지 않게.
+  const sent = process.env.FIELD_FEED_NOTIFY === '0' ? false : sendOutbound([
+    `✅ 승인됨 · 게시 준비 완료 — ${draft.event.title} (${draft.event.date})`,
+    `캐러셀 ${included.length + 1}장${reel ? ' ⊕ 릴스 1편' : ''} · 초안 r${draft.revision}${draft.updatedBy === 'human' ? '(사람이 고침)' : ''}`,
+    '', text, '', `묶음: ${ready}`, '(인스타그램 게시는 아직 사람이 한다 — 자동 게시는 다음 판)',
+  ].join('\n'), 'report');
+  result({ ready, slides: included.length + 1, reel: Boolean(reel), redrawn, revision: draft.revision, notified: sent });
+} catch (error) {
+  console.log(JSON.stringify({ outcome: 'fail', reason: error instanceof Error ? error.message : String(error) }));
+}

package/scripts/field-feed/feed-node.ts

@@ -0,0 +1,67 @@
+#!/usr/bin/env bun
+// feed node — 현장 폴더 → 인스타 피드 초안 한 벌: 4:5(1080×1350) 캐러셀(커버 ⊕ 사진별 한 줄) ⊕ 캡션(훅·본문·해시태그·위치) ⊕ 릴스 경로.
+// 쓰는 곳: <folder>/feed/feed-draft.json(정본) · <folder>/feed/slide-N.png. 사진별 한 줄과 제목은 앞 reel 노드의
+// reel/timeline.json(비전 결과)을 그대로 쓴다 — 같은 사진을 두 번 읽지 않는다. 없으면 «현장 N».
+// 사람이 이미 고친 초안(updatedBy: human)이 있으면 덮지 않는다.
+import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ask, coverHtml, draftPath, kstDate, lastJson, listPhotos, readContext, readDraft, result, screenshot, slideHtml, writeDraft, type FeedDraft } from './lib.js';
+
+const started = Date.now();
+try {
+  const { folder, runId } = readContext();
+  const existing = readDraft(folder);
+  if (existing?.updatedBy === 'human') {
+    result({ draftPath: draftPath(folder), slides: existing.slides.length, kept: 'human-edited' });
+    process.exit(0);
+  }
+  let timeline: { title?: string; sub?: string; items?: { file: string; video?: boolean; cap?: string }[] } = {};
+  try { timeline = JSON.parse(readFileSync(join(folder, 'reel', 'timeline.json'), 'utf8')); } catch { /* reel 없이도 돈다 */ }
+  // 릴스가 쓴 순서(와 reel/v<i>.jpg 번호)를 그대로 따른다 — 같은 사진이 두 순서로 갈리지 않게.
+  const reelOrder = (timeline.items ?? []).map((it) => it.file);
+  const photos = reelOrder.length ? (timeline.items ?? []).filter((it) => !it.video).map((it) => it.file) : listPhotos(folder);
+  if (!photos.length) throw new Error('현장 폴더에 사진이 없다');
+  const capOf = new Map((timeline.items ?? []).map((it) => [it.file, it.cap ?? '']));
+  const title = timeline.title && timeline.title !== '현장 스케치' ? timeline.title : '현장 스케치';
+  const date = timeline.sub || kstDate(photos);
+  const shown = photos.slice(0, 9); // 커버 ⊕ 9장 = 인스타 캐러셀 상한 10
+  const captions = shown.map((f, i) => capOf.get(f) || `현장 ${i + 1}`);
+
+  const out = join(folder, 'feed');
+  mkdirSync(out, { recursive: true });
+  screenshot(coverHtml(join(folder, shown[0]!), title, `${date} · 현장 스케치`), join(out, 'slide-0.png'));
+  shown.forEach((f, i) => screenshot(slideHtml(join(folder, f), captions[i]!, i + 1, shown.length), join(out, `slide-${i + 1}.png`)));
+  const rendered = Date.now();
+
+  // 캡션: 행사 제목 ⊕ 사진별 한 줄 ⊕ 사진(앞 셋)을 보고 한 벌. 실패하면 템플릿.
+  const prompt = [
+    '행사 현장 사진으로 인스타그램 게시글 초안을 쓴다. JSON 객체 하나만 출력하라:',
+    '{"hook": 첫 줄(25자 이내 · 이모지 0~1개), "body": 본문 2~3문장(보이는 장면과 아래 한 줄들만 근거 · 사람 이름·외모·감정 추측 금지 · 과장 금지), "hashtags": 6~8개(한국어 위주 · # 포함), "location": 화면 글자에서 읽히는 장소 이름 또는 null}',
+    `행사 제목: ${title}`, `날짜: ${date}`, `사진별 한 줄: ${captions.join(' / ')}`,
+  ].join('\n');
+  const reply = lastJson(await ask(prompt, shown.slice(0, 3).map((f) => join(folder, 'reel', `v${reelOrder.indexOf(f)}.jpg`)).filter(existsSync)));
+  const str = (v: unknown, max: number) => (typeof v === 'string' && v.trim() && v.length <= max ? v.trim() : '');
+  const tags = Array.isArray(reply?.hashtags) ? (reply!.hashtags as unknown[]).filter((t): t is string => typeof t === 'string' && /^#\S{1,30}$/.test(t)).slice(0, 10) : [];
+  const draft: FeedDraft = {
+    kind: 'feed-draft', version: 1, revision: (existing?.revision ?? 0) + 1, updatedAt: new Date().toISOString(), updatedBy: 'graph',
+    graphId: 'field-feed', runId, folder,
+    brand: { name: 'Elanous', handle: 'elanous.ai', avatar: null },
+    event: { title, date },
+    cover: { text: title, sub: `${date} · 현장 스케치`, image: 'feed/slide-0.png', renderedText: title, renderedSub: `${date} · 현장 스케치`, renderedSource: shown[0]! },
+    slides: shown.map((f, i) => ({ image: `feed/slide-${i + 1}.png`, source: f, caption: captions[i]!, include: true, renderedCaption: `${i + 1}/${shown.length}:${captions[i]!}` })),
+    caption: {
+      hook: str(reply?.hook, 40) || `${title} 현장`,
+      body: str(reply?.body, 400) || `${date}, ${title} 현장을 사진으로 담았습니다.`,
+    },
+    hashtags: tags.length ? tags : ['#현장스케치', `#${title.replace(/\s+/g, '')}`],
+    location: str(reply?.location, 40) || null,
+    reel: existsSync(join(folder, 'reel', 'reel-9x16.mp4')) ? 'reel/reel-9x16.mp4' : null,
+  };
+  writeDraft(folder, draft);
+  result({
+    draftPath: draftPath(folder), slides: draft.slides.length + 1, vision: Boolean(reply),
+    renderMs: rendered - started, totalMs: Date.now() - started,
+  });
+} catch (error) {
+  console.log(JSON.stringify({ outcome: 'fail', reason: error instanceof Error ? error.message : String(error) }));
+}