elanous 0.2.28 → 0.2.29

package/src/cli/usage-cli.ts

@@ -9,13 +9,16 @@ import { join } from 'node:path';
 import type { Command } from 'commander';
 import { collectUnifiedUsage, formatUnifiedUsage } from '../budget/unified-usage.js';
 import { consumeCodexResetCredits, listCodexResetCredits } from '../budget/codex-reset-credits.js';
-import { rollupRunUsage, type RunUsageInput } from '../budget/run-usage-rollup.js';
+import { excludeCoveredPodRawRows, rollupRunUsage, type RunUsageInput } from '../budget/run-usage-rollup.js';
 import { dedupePodRollupRows } from '../../scripts/usage-rollup.js';
 import { formatUsageOutcomes, outcomeTableHasCodexGrokUnknown, queryUsageOutcomes, type UsageOutcomesDeps, type UsageOutcomesReport } from '../budget/usage-outcomes.js';
 import { LogStore, logsDbPath, type LogQuery, type LogStoreRow } from '../mss/logging/log-store.js';
 import { LOGS_SINCE_OPTION, parseSince } from './logs-cli.js';
 import { formatCodexCreditPlan, type CodexCreditPlan } from '../budget/codex-credit-plan.js';
 import { codexCreditPlanFromDisk } from './codex-credit-plan-view.js';
+import { getUserConfig } from '../user-config.js';
+import { defaultSshRunner, type SshRunner } from '../task-agent/parent-host.js';
+import { shellQuote } from '../task-agent/task-hand.js';
 
 export interface UsageCliDeps {
   readonly collect?: typeof collectUnifiedUsage;
@@ -24,6 +27,9 @@ export interface UsageCliDeps {
   readonly out?: { log: (s: string) => void };
   /** Read-only LogStore query seam; returns stored llm-usage rows, newest first. */
   readonly readRunLogs?: (query: LogQuery) => LogStoreRow[];
+  /** Federation seams: the configured TA parent hosts plus this HQ host, and bounded SSH. */
+  readonly usageHosts?: () => { local: string; remote: string[] };
+  readonly ssh?: SshRunner;
   /** 시험 심 — 실물 네트워크를 안 탄다. */
   readonly list?: typeof listCodexResetCredits;
   readonly consume?: typeof consumeCodexResetCredits;
@@ -61,8 +67,16 @@ function readRunLogs(query: LogQuery): LogStoreRow[] {
   }
 }
 
+function configuredUsageHosts(): { local: string; remote: string[] } {
+  const config = getUserConfig();
+  const local = config.hq?.hostName?.trim() || '';
+  const parents = config.taskAgent?.parentHost;
+  const entries = Array.isArray(parents) ? parents : parents ? [parents] : [];
+  return { local, remote: [...new Set(entries.map((entry) => entry.host?.trim()).filter((host): host is string => !!host && host !== local))] };
+}
+
 type UsageAxis = 'stage' | 'model' | 'account';
-type ExtendedRunUsageInput = RunUsageInput & { stage?: string | null; account?: string | null };
+type ExtendedRunUsageInput = RunUsageInput & { stage?: string | null; account?: string | null; origin?: string; podJob?: string; job?: string; measured?: boolean };
 type AxisUsageRow = {
   stage?: string;
   model?: string;
@@ -82,15 +96,78 @@ type AxisUsageRow = {
   rankUsd: number;
 };
 
+type FederatedUsageRow = {
+  runId?: string; role?: string; site?: string; stage?: string; model?: string; account?: string;
+  billingProvider?: string; billing?: string; hostIds: string[]; rankUsd?: number;
+  calls: number; inputTokens: number; outputTokens: number; cacheReadInputTokens: number;
+  cacheCreationInputTokens: number; reasoningOutputTokens: number; usdKnown: number;
+  unknownCostCalls: number; includedCalls: number; apiEquivalentUsd: number;
+};
+type HostMeasurement = { host: string; status: 'ok' | 'unmeasured'; reason?: string };
+const SUM_FIELDS = ['calls', 'inputTokens', 'outputTokens', 'cacheReadInputTokens', 'cacheCreationInputTokens', 'reasoningOutputTokens', 'usdKnown', 'unknownCostCalls', 'includedCalls', 'apiEquivalentUsd'] as const;
+const SSH_HOST = /^[A-Za-z0-9][A-Za-z0-9._@-]{0,127}$/;
+
+function validUsageRows(value: unknown, axis: 'run' | 'role' | UsageAxis): value is FederatedUsageRow[] {
+  if (!Array.isArray(value)) return false;
+  const key = axis === 'run' ? 'runId' : axis;
+  return value.every((candidate) => {
+    if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) return false;
+    const row = candidate as Record<string, unknown>;
+    return typeof row[key] === 'string' && Array.isArray(row.hostIds)
+      && row.hostIds.every((host: unknown) => typeof host === 'string')
+      && (axis !== 'run' && axis !== 'role'
+        || ['model', 'billingProvider', 'billing', ...(axis === 'role' ? ['site'] : [])]
+          .every((field) => typeof row[field] === 'string'))
+      && SUM_FIELDS.every((field) => {
+        const number = row[field];
+        return typeof number === 'number' && Number.isFinite(number) && number >= 0;
+      })
+      && (axis !== 'stage' && axis !== 'model' && axis !== 'account'
+        || typeof row.rankUsd === 'number' && Number.isFinite(row.rankUsd));
+  });
+}
+
+function mergeUsageRows(groups: readonly FederatedUsageRow[][], axis: 'run' | 'role' | UsageAxis): FederatedUsageRow[] {
+  const merged = new Map<string, FederatedUsageRow>();
+  for (const rows of groups) for (const row of rows) {
+    const key = axis === 'run' ? JSON.stringify([row.runId, row.model, row.billingProvider, row.billing])
+      : axis === 'role' ? JSON.stringify([row.role, row.site, row.model, row.billingProvider, row.billing])
+        : JSON.stringify(row[axis]);
+    const previous = merged.get(key);
+    if (!previous) { merged.set(key, { ...row, hostIds: [...row.hostIds] }); continue; }
+    for (const field of SUM_FIELDS) previous[field] += row[field];
+    previous.hostIds = [...new Set([...previous.hostIds, ...row.hostIds])];
+    if (axis === 'stage' || axis === 'model' || axis === 'account') previous.rankUsd = previous.usdKnown + previous.apiEquivalentUsd;
+  }
+  return [...merged.values()];
+}
+
+function readRemoteUsage(host: string, axis: 'run' | 'role' | UsageAxis, opts: { run?: string; sinceMs?: number }, ssh: SshRunner): { rows?: FederatedUsageRow[]; reason?: string } {
+  if (!SSH_HOST.test(host)) return { reason: '호스트 이름 오류' };
+  const args = ['eln', '--config-dir', '"$HOME"/.elanous', 'usage', 'runs', '--by', shellQuote(axis), '--json'];
+  if (opts.run !== undefined) args.push('--run', shellQuote(opts.run));
+  if (opts.sinceMs !== undefined) args.push('--since', shellQuote(new Date(opts.sinceMs).toISOString()));
+  try {
+    // The local usage command returns [] when its store is absent. Check the
+    // same configured store first so federation cannot count absence as zero.
+    const result = ssh(host, 'test -f "$HOME"/.elanous/logs/logs.db || { echo usage-store-missing >&2; exit 68; }; ' + args.join(' '), 20_000);
+    if (result.status === 68 || result.stderr.includes('usage-store-missing')) return { reason: '원격 logs.db 없음' };
+    if (result.status !== 0) return { reason: result.status === null ? '시간 초과 또는 SSH 실패' : `SSH/원격 명령 rc=${result.status}` };
+    const parsed: unknown = JSON.parse(result.stdout);
+    return validUsageRows(parsed, axis) ? { rows: parsed } : { reason: '원격 JSON 형식 오류' };
+  } catch { return { reason: '원격 JSON 또는 SSH 실행 오류' }; }
+}
+
 function usageData(row: LogStoreRow, unwrapPod = false): ExtendedRunUsageInput | null {
   if (row.category !== 'llm.usage' || row.event !== 'llm-usage' || !row.data) return null;
   try {
     let value: unknown = JSON.parse(row.data);
     if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
-    const wrapper = value as { origin?: unknown; originalData?: unknown };
-    if (unwrapPod && wrapper.origin === 'pod') {
-      value = typeof wrapper.originalData === 'string' ? JSON.parse(wrapper.originalData) : wrapper.originalData;
-      if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+    const wrapper = value as { origin?: unknown; podJob?: unknown; originalData?: unknown };
+    if (unwrapPod && wrapper.origin === 'pod' && wrapper.originalData !== undefined) {
+      const original = typeof wrapper.originalData === 'string' ? JSON.parse(wrapper.originalData) : wrapper.originalData;
+      if (!original || typeof original !== 'object' || Array.isArray(original)) return null;
+      value = { ...original, origin: 'pod', podJob: wrapper.podJob };
     }
     return value as ExtendedRunUsageInput;
   } catch { return null; }
@@ -176,8 +253,9 @@ export function registerUsageCommand(program: Command, deps: UsageCliDeps = {}):
     .option('--run <runId>', '런 ID 정확 일치')
     .option('--by <axis>', '집계 축 (run | role | stage | model | account)', 'run')
     .option(...LOGS_SINCE_OPTION)
+    .option('--hosts <scope>', '호스트 연합 (all: 이 호스트 + 설정된 taskAgent.parentHost)')
     .option('--json', '집계 행 JSON 출력')
-    .action((opts: { run?: string; by: string; since?: string; json?: boolean }, command: Command) => {
+    .action((opts: { run?: string; by: string; since?: string; hosts?: string; json?: boolean }, command: Command) => {
       const json = opts.json || command.optsWithGlobals<{ json?: boolean }>().json;
       if (!isUsageAxis(opts.by)) {
         out.log('⛔ --by 는 run | role | stage | model | account');
@@ -190,16 +268,71 @@ export function registerUsageCommand(program: Command, deps: UsageCliDeps = {}):
         exit(2);
         return;
       }
-      const rows = (deps.readRunLogs ?? readRunLogs)({
-        exactCategories: ['llm.usage'], events: ['llm-usage'],
-        ...(sinceMs !== undefined ? { sinceMs } : {}),
-      });
+      if (opts.hosts !== undefined && opts.hosts !== 'all') {
+        out.log(`⛔ --hosts 는 all 만 지원: '${opts.hosts}'`);
+        exit(2);
+        return;
+      }
+      const localUnavailable = opts.hosts === 'all' && !deps.readRunLogs && !existsSync(logsDbPath())
+        ? '로컬 logs.db 없음' : undefined;
+      const emitFederated = (localRows: FederatedUsageRow[], localFailure?: string): void => {
+        const roster = (deps.usageHosts ?? configuredUsageHosts)();
+        if (!roster.local) {
+          const reason = 'hq.hostName 설정 없음 — 로컬 호스트와 원격 중복 여부를 확인할 수 없음';
+          const hosts = [...new Set(roster.remote)].map((host) => ({ host, status: 'unmeasured' as const, reason: '로컬 식별 불가로 조회 중지' }));
+          if (json) out.log(JSON.stringify({ rows: [], hosts, complete: false, reason }, null, 2));
+          else out.log(`호스트 연합: 못 잼 (${reason})`);
+          return;
+        }
+        const hosts: HostMeasurement[] = [localFailure
+          ? { host: roster.local, status: 'unmeasured', reason: localFailure }
+          : { host: roster.local, status: 'ok' }];
+        const parts: FederatedUsageRow[][] = localFailure ? [] : [localRows];
+        const rosterReason = roster.remote.length === 0 ? 'taskAgent.parentHost 설정 없음' : undefined;
+        for (const host of [...new Set(roster.remote.filter((name) => name !== roster.local))]) {
+          const remote = readRemoteUsage(host, opts.by as 'run' | 'role' | UsageAxis,
+            { run: opts.run, sinceMs }, deps.ssh ?? defaultSshRunner);
+          if (remote.rows) { hosts.push({ host, status: 'ok' }); parts.push(remote.rows); }
+          else hosts.push({ host, status: 'unmeasured', reason: remote.reason ?? '원인 미상' });
+        }
+        const complete = !rosterReason && hosts.every((host) => host.status === 'ok');
+        const rows = mergeUsageRows(parts, opts.by as 'run' | 'role' | UsageAxis);
+        if (opts.by === 'role') rows.sort((a, b) => b.calls - a.calls);
+        if (opts.by === 'stage' || opts.by === 'model' || opts.by === 'account') rows.sort((a, b) => (b.rankUsd ?? 0) - (a.rankUsd ?? 0) || b.calls - a.calls);
+        if (json) { out.log(JSON.stringify({ rows, hosts, complete, ...(rosterReason ? { reason: rosterReason } : {}) }, null, 2)); return; }
+        out.log(`호스트 ${hosts.filter((host) => host.status === 'ok').length}/${hosts.length} 측정 · ${complete ? '완결' : '부분 합계'}`);
+        if (rosterReason) out.log(`호스트 목록: 못 잼 (${rosterReason})`);
+        for (const host of hosts) if (host.status === 'unmeasured') out.log(`${host.host}: 못 잼 (${host.reason})`);
+        if (rows.length === 0) { out.log('(일치하는 런 사용량 없음)'); return; }
+        for (const row of rows) {
+          if (opts.by === 'stage' || opts.by === 'model' || opts.by === 'account') out.log(formatAxisUsage(row as AxisUsageRow, opts.by));
+          else if (opts.by === 'role') out.log(`${row.role}  ${row.site}  ${row.model}  ${row.billingProvider}/${row.billing}  calls=${row.calls}  input=${row.inputTokens}  output=${row.outputTokens}  usdKnown=${row.usdKnown}  unknownCostCalls=${row.unknownCostCalls}  includedCalls=${row.includedCalls}  apiEquivalentUsd=${row.apiEquivalentUsd}`);
+          else out.log(`${row.runId}  ${row.model}  ${row.billingProvider}/${row.billing}  hosts=${row.hostIds.join(',') || '(none)'}  calls=${row.calls}  input=${row.inputTokens}  output=${row.outputTokens}  cacheRead=${row.cacheReadInputTokens}  cacheCreation=${row.cacheCreationInputTokens}  reasoning=${row.reasoningOutputTokens}  usdKnown=${row.usdKnown}  unknownCostCalls=${row.unknownCostCalls}  includedCalls=${row.includedCalls}  apiEquivalentUsd=${row.apiEquivalentUsd}`);
+        }
+      };
+      let rows: LogStoreRow[] = [];
+      let localFailure = localUnavailable;
+      if (!localFailure) {
+        try {
+          rows = (deps.readRunLogs ?? readRunLogs)({
+            exactCategories: ['llm.usage'], events: ['llm-usage'],
+            ...(sinceMs !== undefined ? { sinceMs } : {}),
+          });
+        } catch (error) {
+          if (opts.hosts !== 'all') throw error;
+          localFailure = '로컬 logs.db 조회 실패';
+        }
+      }
       const unwrapPod = opts.by === 'stage' || opts.by === 'model' || opts.by === 'account';
       // ⭐ METER-POD-ROLLUP-GAP-2 — Pod 사용량 재방출 행(podRollupKey)은 «더 완전한 한 행»만 센다(키 없는 행은 그대로).
-      const inputs = dedupePodRollupRows(rows.map((row) => usageData(row, unwrapPod)).filter((data): data is ExtendedRunUsageInput => data !== null))
+      const selected = rows.map((row) => usageData(row, unwrapPod))
+        .filter((data): data is ExtendedRunUsageInput => data !== null)
         .filter((data) => opts.run === undefined || data.runId === opts.run);
+      // A returned Pod raw row and its host rollup describe the same usage. Keep raw rows when no measured rollup exists.
+      const inputs = dedupePodRollupRows(unwrapPod ? excludeCoveredPodRawRows(selected) : selected);
       if (opts.by === 'stage' || opts.by === 'model' || opts.by === 'account') {
         const report = rollupByAxis(inputs, opts.by);
+        if (opts.hosts === 'all') { emitFederated(report, localFailure); return; }
         if (json) {
           out.log(JSON.stringify(report, null, 2));
           return;
@@ -209,6 +342,7 @@ export function registerUsageCommand(program: Command, deps: UsageCliDeps = {}):
         return;
       }
       const report = rollupRunUsage(inputs, { by: opts.by });
+      if (opts.hosts === 'all') { emitFederated(report, localFailure); return; }
       if (opts.by === 'role') report.sort((a, b) => b.calls - a.calls);
       if (json) {
         out.log(JSON.stringify(report, null, 2));

package/src/cli/usage-daily-cli.ts

@@ -0,0 +1,84 @@
+import type { Command } from 'commander';
+import { logsDbPath } from '../mss/logging/log-store.js';
+import { readUsageDaily, type DailyUsageRow } from '../budget/usage-daily-store.js';
+
+type Axis = 'day' | 'model' | 'role' | 'stage' | 'account';
+const metricFields = ['calls', 'inputTokens', 'outputTokens', 'cacheReadInputTokens', 'cacheCreationInputTokens',
+  'reasoningOutputTokens', 'usdKnown', 'unknownCostCalls', 'includedCalls', 'apiEquivalentUsd'] as const;
+type Period = 'day' | 'hour';
+type Summary = Pick<DailyUsageRow, typeof metricFields[number]> & { period: string; key: string };
+
+export function summarizeDailyUsage(rows: readonly DailyUsageRow[], axis: Axis, period: Period = 'day'): Summary[] {
+  const groups = new Map<string, Summary>();
+  for (const row of rows) {
+    const bucket = row[period];
+    const key = axis === 'day' ? bucket : row[axis];
+    const id = JSON.stringify([bucket, key]);
+    let summary = groups.get(id);
+    if (!summary) {
+      summary = { period: bucket, key, calls: 0, inputTokens: 0, outputTokens: 0, cacheReadInputTokens: 0,
+        cacheCreationInputTokens: 0, reasoningOutputTokens: 0, usdKnown: 0, unknownCostCalls: 0,
+        includedCalls: 0, apiEquivalentUsd: 0 };
+      groups.set(id, summary);
+    }
+    for (const field of metricFields) summary[field] += row[field];
+  }
+  return [...groups.values()].sort((a, b) => a.period.localeCompare(b.period) || a.key.localeCompare(b.key));
+}
+
+export function registerUsageDailyCommand(program: Command, deps: {
+  path?: () => string; read?: typeof readUsageDaily;
+  out?: (line: string) => void; exit?: (code: number) => void;
+} = {}): void {
+  const usage = program.commands.find((command) => command.name() === 'usage');
+  if (!usage) throw new Error('usage command must be registered before usage daily');
+  const out = deps.out ?? console.log;
+  const exit = deps.exit ?? ((code: number) => { process.exitCode = code; });
+  usage.command('daily')
+    .description('현재 logs.db에 남은 호스트 시간·일 LLM 사용량 (UTC)')
+    .option('--since <day>', 'UTC 시작일 YYYY-MM-DD')
+    .option('--period <period>', 'day | hour', 'day')
+    .option('--by <axis>', 'day | model | role | stage | account', 'day')
+    .option('--json', 'JSON 출력')
+    .action((opts: { since?: string; period: string; by: string; json?: boolean }) => {
+      const parsedSince = opts.since === undefined ? null : Date.parse(`${opts.since}T00:00:00Z`);
+      if (!['day', 'model', 'role', 'stage', 'account'].includes(opts.by) || !['day', 'hour'].includes(opts.period)
+        || opts.since !== undefined && (!/^\d{4}-\d{2}-\d{2}$/.test(opts.since)
+          || !Number.isFinite(parsedSince) || new Date(parsedSince!).toISOString().slice(0, 10) !== opts.since)) {
+        const detail = '--period day|hour · --by day|model|role|stage|account · --since YYYY-MM-DD (UTC)';
+        if (opts.json) out(JSON.stringify({ status: 'error', reason: 'invalid-arguments', detail }));
+        else out(`⛔ ${detail}`);
+        exit(2); return;
+      }
+      const path = (deps.path ?? logsDbPath)();
+      const scope = { source: 'current-logs-db', sinceDay: opts.since ?? null, timeZone: 'UTC' };
+      const unavailable = (reason: 'logs-db-missing' | 'logs-db-unreadable', detail?: string) => {
+        if (opts.json) out(JSON.stringify({ status: 'unmeasured', hostStatus: 'unmeasured', podStatus: 'unmeasured',
+          reason, scope, ...(detail === undefined ? {} : { detail }), rows: [] }));
+        else out(`사용량 집계 불가: ${reason === 'logs-db-missing' ? 'logs.db 없음' : 'logs.db 읽기 실패'} · UTC${opts.since ? ` · ${opts.since} 이후` : ''} · Pod 사용량 측정 불가${detail ? ` (${detail})` : ''}`);
+        exit(1);
+      };
+      let source: ReturnType<typeof readUsageDaily>;
+      try {
+        source = (deps.read ?? readUsageDaily)(path, opts.since);
+      }
+      catch (error) {
+        unavailable('logs-db-unreadable', String(error)); return;
+      }
+      if (source === null) {
+        unavailable('logs-db-missing'); return;
+      }
+      const report = { status: 'partial', hostStatus: 'measured-within-current-logs-horizon',
+        podStatus: 'unmeasured', podObservedRows: source.podObservedRows,
+        unclassifiedRows: source.unclassifiedRows, sourceMaxId: source.sourceMaxId,
+        scope,
+        timeZone: 'UTC', period: opts.period, by: opts.by,
+        rows: summarizeDailyUsage(source.rows, opts.by as Axis, opts.period as Period) };
+      if (opts.json) { out(JSON.stringify(report)); return; }
+      out(`집계 범위: 현재 logs.db에 남은 로그 · UTC${opts.since ? ` · ${opts.since} 이후` : ''} (보존 기간 밖은 포함되지 않음)`);
+      out(`Pod 사용량: 측정 불가 · 위 범위에서 ${report.podObservedRows}행 관측 (0행도 사용량 0을 뜻하지 않음)`);
+      if (report.unclassifiedRows > 0) out(`분류 불가 사용량: 측정 불가 · 위 범위에서 ${report.unclassifiedRows}행 관측`);
+      if (!report.rows.length) { out('(현재 로그에 남은 호스트 사용량 없음 · 과거 로그는 복구 불가)'); return; }
+      for (const row of report.rows) out(`${row.period} ${opts.by}=${row.key} calls=${row.calls} input=${row.inputTokens} output=${row.outputTokens} cacheRead=${row.cacheReadInputTokens} usdKnown=${row.usdKnown} unknownCostCalls=${row.unknownCostCalls}`);
+    });
+}

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

@@ -1,5 +1,6 @@
 import { existsSync, lstatSync, readdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { isMainThread, parentPort, workerData, Worker } from 'node:worker_threads';
 import { queryRunningRuns, type QueriedRunningRunsResult } from '../self-implement/running-runs.js';
 import { loadRunLedger } from '../self-implement/run-ledger.js';
 import { localLoopRows } from '../dashboard/slash-runtime/loops-table.js';
@@ -8,6 +9,7 @@ import { debug, redactSecretText } from '../debug/log.js';
 import { DecisionLedger, type DecisionEntry } from '../decisions/decision-ledger.js';
 import { listChecklist, devVersion, type Checklist } from '../release-loop/checklist.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { setElanousConfigDir } from '../elanous-config-dir.js';
 import { seatDay, seatLedgerPath, type SeatEntry } from '../seat-loop/seat-loop.js';
 import { listCoordEvents, type CoordEvent } from './coord-events.js';
 import { filterPublicDemoContext } from './context-now-public.js';
@@ -50,6 +52,18 @@ function todaySeatEntries(now: Date): Array<{ entry: SeatEntry; source: string }
   });
 }
 
+function seatFact({ entry, source }: { entry: SeatEntry; source: string }): Extract<ContextFact, { kind: 'seat' }> {
+  return { kind: 'seat', seat: entry.seat, at: entry.at, status: entry.status,
+    id: entry.item?.id ?? null, title: entry.item?.source === 'checklist'
+      ? redactSecretText(entry.item.title.split(/\r?\n/, 1)[0] ?? '').slice(0, 120) : null, source };
+}
+
+/** The TUI status line needs seat facts only; it must not scan release or run ledgers. */
+export function seatStatusNow(now = new Date()): ContextNowAnswer {
+  return { at: `${now.toISOString().slice(0, 16)}:00.000Z`, topic: null,
+    facts: todaySeatEntries(now).map(seatFact), events: [], guide: [] };
+}
+
 const runSource = 'elanous://self-implement/running-runs';
 const releaseSource = 'elanous://graph-runs/release-loop';
 const scheduleSource = 'elanous://schedules';
@@ -143,11 +157,7 @@ export function contextNow(options: { topic?: string; limit?: number; audience?:
     facts.push({ kind: 'decision', id: item.id, title: redactSecretText(item.title.split(/\r?\n/, 1)[0] ?? '').slice(0, 120),
       status: item.status, dueAt: item.dueAt ?? null, source: `elanous://decisions/${encodeURIComponent(item.id)}` });
   }
-  for (const { entry, source } of (deps.seatEntries ?? todaySeatEntries)(now)) {
-    facts.push({ kind: 'seat', seat: entry.seat, at: entry.at, status: entry.status,
-      id: entry.item?.id ?? null, title: entry.item?.source === 'checklist'
-        ? redactSecretText(entry.item.title.split(/\r?\n/, 1)[0] ?? '').slice(0, 120) : null, source });
-  }
+  facts.push(...(deps.seatEntries ?? todaySeatEntries)(now).map(seatFact));
   const rawEvents = (deps.events ?? (since => listCoordEvents({ since })))(new Date(now.getTime() - 7 * 86_400_000).toISOString());
   const chronologicalEvents = rawEvents.slice().sort((a, b) => a.at.localeCompare(b.at));
   const matches = (text: string) => !topic || text.toLocaleLowerCase().includes(topic.toLocaleLowerCase());
@@ -199,3 +209,70 @@ export function contextNow(options: { topic?: string; limit?: number; audience?:
   debug.log('context.now', 'answer', { topic, facts: answer.facts, events: answer.events });
   return options.audience === 'public-demo' ? filterPublicDemoContext(answer, deps.brandCheck) : answer;
 }
+
+const workerAnswers = new Map<string, { promise: Promise<ContextNowAnswer>; expiresAt: number }>();
+const WORKER_ANSWER_TTL_MS = 5_000;
+const WORKER_SCAN_TIMEOUT_MS = 60_000;
+let workerScanTail: Promise<void> = Promise.resolve();
+
+/** Keep the ledger scan off the TUI event loop. Repeated identical reads share one scan. */
+export function contextNowInWorker(options: Parameters<typeof contextNow>[0] = {}): Promise<ContextNowAnswer> {
+  const stateRoot = process.env.ELANOUS_STATE_DIR;
+  const selectedRoot = effectiveInstanceRoot();
+  const key = JSON.stringify([selectedRoot, stateRoot ?? null, options.topic ?? null, options.limit ?? null, options.audience ?? null]);
+  const now = Date.now();
+  for (const [cachedKey, cached] of workerAnswers) {
+    if (cached.expiresAt < now) workerAnswers.delete(cachedKey);
+  }
+  const cached = workerAnswers.get(key);
+  if (cached) return cached.promise;
+  // Distinct topics queue behind the active scan instead of multiplying the same costly ledger walk.
+  const promise = workerScanTail.then(() => scanContextNowInWorker(options, stateRoot, selectedRoot));
+  workerScanTail = promise.then(() => undefined, () => undefined);
+  const entry = { promise, expiresAt: Infinity };
+  workerAnswers.set(key, entry);
+  void promise.then(() => { entry.expiresAt = Date.now() + WORKER_ANSWER_TTL_MS; }, () => { workerAnswers.delete(key); });
+  return promise;
+}
+
+export function scanContextNowInWorker(options: Parameters<typeof contextNow>[0], stateRoot: string | undefined, selectedRoot: string,
+  createWorker: () => Worker = () => new Worker(new URL(import.meta.url), { workerData: { kind: 'context-now' } }),
+  timeoutMs = WORKER_SCAN_TIMEOUT_MS): Promise<ContextNowAnswer> {
+  const worker = createWorker();
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const timeout = setTimeout(() => {
+      debug.log('context.now', 'worker-timeout', { timeoutMs, topic: options?.topic ?? null, selectedRoot });
+      finish(new Error(`context_now worker timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    const finish = (error?: Error, answer?: ContextNowAnswer): void => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      void worker.terminate();
+      if (error) reject(error);
+      else resolve(answer!);
+    };
+    worker.on('message', (message: { answer?: ContextNowAnswer; error?: string }) => {
+      if (message.error) finish(new Error(message.error));
+      else if (message.answer) finish(undefined, message.answer);
+    });
+    worker.on('error', error => finish(error instanceof Error ? error : new Error(String(error))));
+    worker.on('exit', code => { if (!settled) finish(new Error(`context_now worker exited before answering: ${code}`)); });
+    // Preserve both caller roots: a programmatic config override is not inherited by workers.
+    worker.postMessage({ options, stateRoot, selectedRoot });
+  });
+}
+
+const contextWorkerPort = parentPort;
+if (!isMainThread && contextWorkerPort && workerData?.kind === 'context-now') {
+  contextWorkerPort.on('message', ({ options, stateRoot, selectedRoot }: { options: Parameters<typeof contextNow>[0]; stateRoot?: string; selectedRoot: string }) => {
+    try {
+      if (stateRoot === undefined) delete process.env.ELANOUS_STATE_DIR;
+      else process.env.ELANOUS_STATE_DIR = stateRoot;
+      setElanousConfigDir(selectedRoot);
+      contextWorkerPort.postMessage({ answer: contextNow(options) });
+    }
+    catch (error) { contextWorkerPort.postMessage({ error: error instanceof Error ? error.message : String(error) }); }
+  });
+}

package/src/core-turn/auth-rejected-notice.ts

@@ -0,0 +1,41 @@
+// 인증 거절(401)로 끝난 턴을 «조용한 완료»가 아니라 처방 한 줄로 드러낸다(TUI 결함 #22 · 10-14).
+//
+// `runCoreTurn` 은 인증 거절을 `stopReason: 'auth_rejected'` 로 «돌려준다»(던지지 않는다) —
+// 재인증과 버그를 가르려는 설계다. 그런데 ACP 브리지가 그 값을 안 읽어서 TUI 엔 «✔ 완료»만 떴다.
+// 브리지는 이 오류를 던져 서버의 실패 경로(`prompt-failed`)와 TUI 의 오류 줄로 보낸다.
+//
+// ⚠️ 문면은 #27498(실패 지문 사전 · `src/self-health/signatures.ts`)의 «⚠ 원인 → 처방 · 원문» 형식을
+//   따른 «임시 상수»다 — 그 PR 이 착지하면 사전 항목(`auth-rejected`)으로 옮기고 이 상수는 지운다.
+
+import { redactSecretText } from '../debug/log.js';
+
+export const AUTH_REJECTED_NOTICE = '⚠ 모델 공급자가 인증을 거절(401) → 다시 로그인하거나 계정 확인(eln usage)';
+
+const RAW_PREVIEW_MAX = 120;
+
+/** 원문 첫 줄을 비밀값 가림 ⊕ 제어 문자 제거 ⊕ 길이 상한으로 줄인다(화면 한 줄을 넘기지 않게). */
+export function authRejectedRawPreview(raw: string | undefined): string {
+  const firstLine = (redactSecretText(raw ?? '').split(/\r\n|\r|\n/, 1)[0] ?? '')
+    // 단독 CR·ESC 같은 터미널 제어 문자가 오류 줄을 덮어쓰지 않게 공백으로(리뷰 r2 should-fix).
+    .replace(/[\u0000-\u001f\u007f-\u009f]/g, ' ')
+    .trim();
+  return firstLine.length > RAW_PREVIEW_MAX ? `${firstLine.slice(0, RAW_PREVIEW_MAX)}…` : firstLine;
+}
+
+/** 처방 한 줄 — 원문이 있으면 꼬리에 붙인다. 줄바꿈은 넣지 않는다(오류 줄이 넘치지 않게). */
+export function formatAuthRejectedNotice(raw: string | undefined): string {
+  const preview = authRejectedRawPreview(raw);
+  return preview ? `${AUTH_REJECTED_NOTICE} · 원문: ${preview}` : AUTH_REJECTED_NOTICE;
+}
+
+/** 브리지가 던지는 오류. `status` 를 401 로 둬 상위의 인증 판정(`isAuthRejectionError`)과도 맞는다. */
+export class CoreTurnAuthRejectedError extends Error {
+  readonly status = 401;
+  readonly rawMessage: string;
+
+  constructor(raw: string | undefined) {
+    super(formatAuthRejectedNotice(raw));
+    this.name = 'CoreTurnAuthRejectedError';
+    this.rawMessage = redactSecretText(raw ?? '');
+  }
+}

package/src/core-turn/run-core-turn.ts

@@ -23,7 +23,7 @@
 import { isAuthRejectionError, streamLLMWithTools } from '../llm.js';
 import { drainPendingUserInput } from '../session/pending-input.js';
 import type { StreamWithToolsHandlers } from '../llm.js';
-import { debug, withAmbientSessionScope } from '../debug/log.js';
+import { debug, redactSecretText, withAmbientSessionScope } from '../debug/log.js';
 import { applyDeferredTools } from '../session-runtime/tier-flip.js';
 import { resolveSessionSurfaceProfile } from '../session-runtime/index.js';
 import type {
@@ -133,6 +133,9 @@ export async function runCoreTurn(
       accumulatedText = full;
       ctx.callbacks?.onText?.(delta, full);
     },
+    ...(ctx.callbacks?.onFinalAnswerSupplement
+      ? { onFinalAnswerSupplement: (info: { answer: string; supplement: string; finalText: string }) => ctx.callbacks?.onFinalAnswerSupplement?.(info) }
+      : {}),
     // This async boundary deliberately returns the dispatcher's fulfilled value
     // or rejection, not its Promise object identity, so completion is recorded.
     dispatchTool: async (name, args, c) => {
@@ -283,6 +286,7 @@ export async function runCoreTurn(
         ...(ctx.sessionId !== undefined ? { sessionId: ctx.sessionId } : {}),
         ...(ctx.maxToolTurns !== undefined ? { maxTurns: ctx.maxToolTurns } : {}),
         ...(ctx.modelOverride !== undefined ? { model: ctx.modelOverride } : {}),
+        ...(ctx.callbacks?.onResolvedProvider !== undefined ? { onResolvedProvider: ctx.callbacks.onResolvedProvider } : {}),
         ...(ctx.budgetGrant !== undefined ? { budgetGrant: ctx.budgetGrant } : {}),
         // ⭐⭐⭐ `B3`(2026-08-19 · 대표 지시 ②) — 도는 턴 «안»으로 들어오는 사용자 발화의 배수구.
         //   ⛔ 종전엔 스트리밍 중 친 발화가 ***턴이 끝난 뒤***에야 나갔다.
@@ -307,9 +311,16 @@ export async function runCoreTurn(
     };
     } catch (err) {
       const stopReason = classifyStopReason(err, ctx.signal);
-      if (stopReason === 'aborted' || stopReason === 'auth_rejected') {
+      if (stopReason === 'aborted') {
         return { stopReason, finalText: accumulatedText };
       }
+      if (stopReason === 'auth_rejected') {
+        return {
+          stopReason,
+          finalText: accumulatedText,
+          errorMessage: redactSecretText(err instanceof Error ? err.message : String(err)),
+        };
+      }
       throw err;
     }
   });

package/src/core-turn/run-goal-loop.ts

@@ -164,6 +164,11 @@ export function buildUpdateGoalToolSpec(): LLMToolSpec {
   };
 }
 
+/** 반려·재요청은 모델에게만 가는 내부 지시다 — 사용자 답에 그 사정(«완료 주장이 거부됐다»·«죄송합니다»)이 새지 않게 한다
+ *  (10-14 OPT 점검: evidence·rejected 판정 14회가 사용자 답의 사과 문장으로 나왔다). */
+export const GOAL_INTERNAL_NOTICE_RULE =
+  '이 반려·재요청은 내부 지시다. 사용자에게 보이는 답에 «완료 주장이 거부됐다/어긋났다»·«죄송합니다» 같은 내부 사정을 쓰지 말고, 고친 결과와 사실만 말하라.';
+
 /** 목표 실행 계약 — 첫 turn 앞에 leading system 메시지로 주입. codex 자체 prompt.md /
  *  ext-goal continuation.md 의 지속·anti-shrink·증거완료 언어 이식. ASCII + 한국어. */
 export const GOAL_SYSTEM_PREAMBLE = [
@@ -173,6 +178,7 @@ export const GOAL_SYSTEM_PREAMBLE = [
   '- 완료는 증거로 판정한다. 모든 요구사항/산출물/검증에 대해 실제 현재 상태에서 증거를 확인하라. 불확실하거나 간접적인 증거는 미달성으로 보고 계속하라.',
   `- 목표가 실제로 완전히 끝났고 증거로 확인됐을 때만 ${UPDATE_GOAL_TOOL_NAME} 도구를 status="complete" 로 호출하고 evidence 에 그 증거를 적어 종료하라. 완료 신호는 이 도구 호출뿐이다(텍스트 문장이 아니다).`,
   '- 아직 할 일이 남았으면 멈추거나 허락을 구하지 말고 다음 최고가치 스텝을 바로 실행하라.',
+  `- [continue]·[finalize]·[evidence required]·[evidence mismatch]·[tool call rejected] 같은 반려·재요청은 내부 지시다. 사용자에게 보이는 답에 «완료 주장이 거부됐다/어긋났다»·«죄송합니다» 같은 내부 사정을 쓰지 말고, ${UPDATE_GOAL_TOOL_NAME} 호출도 답에서 설명하지 마라.`,
 ].join('\n');
 
 /** 미완 판정 시 재주입하는 continuation 프롬프트(user turn). */
@@ -186,6 +192,7 @@ export const GOAL_CONTINUATION_PROMPT = [
   '예산이 곧 소진된다거나 그만두고 싶다는 이유로 완료를 선언하지 마라.',
   `진짜로 진행이 막혔고(같은 장애가 반복) 대안도 없을 때만 ${UPDATE_GOAL_TOOL_NAME} 도구를 status="blocked" 로 호출하고 무엇이 왜 막혔는지 evidence 에 적어라. 단지 어렵거나 느리거나 불확실하다는 이유로는 쓰지 마라.`,
   `모든 요구사항이 증거로 충족됐다면, ${UPDATE_GOAL_TOOL_NAME} 도구를 status="complete" + evidence 로 호출해 종료하라.`,
+  GOAL_INTERNAL_NOTICE_RULE,
 ].join('\n');
 
 /** 감독 메모 블록의 머리말 — 자식이 「이것은 부모가 보낸 것」임을 «구별»하게 한다. */
@@ -198,6 +205,7 @@ export const GOAL_READBACK_PROMPT = [
   `완료를 텍스트로만 말했다. 텍스트 문장은 완료 신호가 아니다 — 완료가 사실이면 ${UPDATE_GOAL_TOOL_NAME} 도구를 status="complete" 로 호출하고 evidence 에 현재 상태에서 실제로 확인한 증거(파일·명령출력·테스트·PR)를 적어라.`,
   '아직 미충족 항목이 있으면 완료를 주장하지 말고 다음 스텝을 지금 실행하라.',
   '이미 사용자에게 한 답을 다시 쓰지 마라 — 새 사실이 없으면 텍스트 없이 update_goal 만 호출하라.',
+  GOAL_INTERNAL_NOTICE_RULE,
 ].join('\n');
 
 /** GOAL-LOOP-INTENT-STALL (0.2.24 · OP or-audit-1010) — 구현 자식이 «도구를 한 번도 안 부르고 말만 한 턴»에
@@ -222,6 +230,7 @@ export const GOAL_EVIDENCE_REQUIRED_PROMPT = [
   '[evidence required]',
   `${UPDATE_GOAL_TOOL_NAME}(status="complete") 를 호출했지만 evidence 가 비어 있어 완료로 인정하지 않는다.`,
   '현재 상태(파일·명령출력·테스트결과·PR)에서 실제로 확인한 증거를 evidence 에 채워 다시 호출하거나, 미충족 항목을 마저 실행하라.',
+  GOAL_INTERNAL_NOTICE_RULE,
 ].join('\n');
 
 /** evidence-mismatch 반려 재주입 (OH8 후속 PR-2) — update_goal(complete) 를 호출했으나 그 턴까지의
@@ -236,6 +245,7 @@ export function buildEvidenceMismatchPrompt(fail: number, unmatchedFilters: read
       `(fail=${fail}, unmatched=${unmatched}). 완료 증거와 실제 테스트 결과가 어긋난다 — 완료로 인정하지 않는다.`,
     '테스트를 실제로 통과시키거나(fail=0 · 모든 필터 매칭), 완료 주장을 철회하고 남은 작업을 마저 실행하라.',
     '통과한 run_tests 없이 complete 를 다시 주장하지 마라.',
+    GOAL_INTERNAL_NOTICE_RULE,
   ].join('\n');
 }
 
@@ -245,6 +255,7 @@ export function buildRejectedToolCompletionPrompt(rejectedTools: readonly string
     '[tool call rejected]',
     `${UPDATE_GOAL_TOOL_NAME}(status="complete") 를 호출했지만 이 turn 에 ${rejectedTools.join(', ')} 도구 호출이 거부되어 실행되지 않았다. 완료 증거와 실제 도구 결과가 어긋난다 — 완료로 인정하지 않는다.`,
     '거부된 작업을 실제로 다시 실행하거나 완료 주장을 철회하고 남은 작업을 마저 실행하라.',
+    GOAL_INTERNAL_NOTICE_RULE,
   ].join('\n');
 }
 
@@ -301,6 +312,8 @@ export interface GoalLoopResult {
   stopReason: GoalLoopStopReason;
   /** 목표가 증거 기준 완료로 선언됐는지(update_goal(complete)+evidence 감지). */
   goalComplete: boolean;
+  /** `auth_rejected` 로 끝났을 때 — 마지막 코어 턴의 공급자 오류 원문(비밀값 가림). */
+  errorMessage?: string;
 }
 
 /** 완료 마커 감지(deprecated fallback) — 마커가 산문 안에 우연히 포함(예: "상수 값은
@@ -856,7 +869,10 @@ export async function runGoalLoop(
         sessionId: ctx.sessionId, ...runAttribution, iterations, stopReason: lastResult.stopReason,
         finalChars: lastResult.finalText.length,
       }, { level: 'error' });
-      return finish({ finalText: lastResult.finalText, iterations, stopReason: lastResult.stopReason, goalComplete: false });
+      return finish({
+        finalText: lastResult.finalText, iterations, stopReason: lastResult.stopReason, goalComplete: false,
+        ...(lastResult.errorMessage !== undefined ? { errorMessage: lastResult.errorMessage } : {}),
+      });
     }
 
     // Evidence-less completion is not authoritative; only retry after stop and terminal outcomes